From b3ee5cb71c73bf943efe5334776e737a24508649 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 1 Oct 2013 13:34:13 -0700
Subject: [PATCH 0001/1866] Adds compress to README

---
 README.md | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/README.md b/README.md
index 7c8222db..8650f13d 100644
--- a/README.md
+++ b/README.md
@@ -11,6 +11,7 @@ library.
 [dropwhile](#dropwhile)<br />
 [enumerate](#enumerate)<br />
 [cycle](#cycle)<br />
+[compress](#compress)<br />
 [zip](#zip)<br />
 [chain](#chain)<br />
 [reverse](#reverse)<br />
@@ -163,6 +164,21 @@ range instead of the shortest. because of that you have to return a
 `zip_get`
 
 
+compress
+--------
+
+Yields only the values corresponding to true in the selectors iterable.
+Terminates on the shortest sequence.
+
+Prints 2 6
+```c++
+vector<int> ivec{1, 2, 3, 4, 5, 6};
+vector<bool> bvec{false, true, false, false, false, true};
+for (auto i : compress(ivec, bvec) {
+    cout << i << '\n';
+}
+```
+
 chain
 -----
 

From 3b2d874653b0d7c4420709f837945b22c6fe5db0 Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Wed, 2 Oct 2013 00:58:22 -0400
Subject: [PATCH 0002/1866] zip_iter now derefs to a tuple of the iterators
 elements, not a tuple of iterators

---
 tests/testzip.cpp | 50 +++++++++++++++++++++++------------------------
 zip.hpp           | 11 ++++++-----
 2 files changed, 31 insertions(+), 30 deletions(-)

diff --git a/tests/testzip.cpp b/tests/testzip.cpp
index f3cd6e39..6f635a97 100644
--- a/tests/testzip.cpp
+++ b/tests/testzip.cpp
@@ -14,15 +14,15 @@ int main() {
         std::vector<std::string> svec{"hello", "good day", "goodbye"};
 
         for (auto e : zip(ivec, svec)) {
-            auto &i = iter::zip_get<0>(e);
+            auto &i = std::get<0>(e);
             std::cout << i << std::endl;
             i = 69;
-            std::cout << iter::zip_get<1>(e) << std::endl;
+            std::cout << std::get<1>(e) << std::endl;
         }
 
         for (auto e : zip(ivec, svec)) {
-            std::cout << iter::zip_get<0>(e) << std::endl;
-            std::cout << iter::zip_get<1>(e) << std::endl;
+            std::cout << std::get<0>(e) << std::endl;
+            std::cout << std::get<1>(e) << std::endl;
         }
     }
     //Aaron's test
@@ -33,40 +33,40 @@ int main() {
         std::array<double,5> d{{1.2,1.2,1.2,1.2,1.2}};
         std::cout << std::endl << "Variadic template zip iterator" << std::endl;
         for (auto e : iter::zip(i,f,s,d)) {
-            std::cout << iter::zip_get<0>(e) << " " 
-                << iter::zip_get<1>(e) << " " 
-                << iter::zip_get<2>(e) << " "
-                << iter::zip_get<3>(e) << std::endl;
-            iter::zip_get<1>(e)=2.2f; //modify the float array
+            std::cout << std::get<0>(e) << " " 
+                << std::get<1>(e) << " " 
+                << std::get<2>(e) << " "
+                << std::get<3>(e) << std::endl;
+            std::get<1>(e)=2.2f; //modify the float array
         }
         std::cout<<std::endl;
         for (auto e : iter::zip(i,s,f,d)) {
-            std::cout << iter::zip_get<0>(e) << " " 
-                << iter::zip_get<1>(e) << " "
-                << iter::zip_get<2>(e) << " " 
-                << iter::zip_get<3>(e) << std::endl;
+            std::cout << std::get<0>(e) << " " 
+                << std::get<1>(e) << " "
+                << std::get<2>(e) << " " 
+                << std::get<3>(e) << std::endl;
         }
         std::cout << std::endl << "Try some weird range differences" << std::endl;
         std::vector<int> empty{};
         for (auto e : iter::zip(empty,f,s,d)) {
-            std::cout << iter::zip_get<0>(e) << " " 
-                << iter::zip_get<1>(e) << " " 
-                << iter::zip_get<2>(e) << " "
-                << iter::zip_get<3>(e) << std::endl;
+            std::cout << std::get<0>(e) << " " 
+                << std::get<1>(e) << " " 
+                << std::get<2>(e) << " "
+                << std::get<3>(e) << std::endl;
         }
         std::cout<<std::endl;
         for (auto e : iter::zip(f,s,empty,d)) {
-            std::cout << iter::zip_get<0>(e) << " " 
-                << iter::zip_get<1>(e) << " " 
-                << iter::zip_get<2>(e) << " "
-                << iter::zip_get<3>(e) << std::endl;
+            std::cout << std::get<0>(e) << " " 
+                << std::get<1>(e) << " " 
+                << std::get<2>(e) << " "
+                << std::get<3>(e) << std::endl;
         }//both should print nothing
         std::cout<<std::endl;
         for (auto e : iter::zip(f,s,i,d)) { //i should be the limiter now
-            std::cout << iter::zip_get<0>(e) << " " 
-                << iter::zip_get<1>(e) << " " 
-                << iter::zip_get<2>(e) << " "
-                << iter::zip_get<3>(e) << std::endl;
+            std::cout << std::get<0>(e) << " " 
+                << std::get<1>(e) << " " 
+                << std::get<2>(e) << " "
+                << std::get<3>(e) << std::endl;
         }
         std::cout<<std::endl;
     }
diff --git a/zip.hpp b/zip.hpp
index 8a900d1e..52681dcb 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -15,11 +15,12 @@ namespace iter {
             auto end = zip_iter<decltype(containers.end())...>(containers.end()...);
             return iterator_range<decltype(begin)>(begin,end);
         }   
-    template <int N,typename Tuple>
+    /*template <int N,typename Tuple>
         auto zip_get(Tuple & t) ->decltype(*std::get<N>(t))&
         {
             return *std::get<N>(t);
         }
+        */
     template <typename First, typename Second>
         struct zip_iter<First,Second> {
 
@@ -33,9 +34,9 @@ namespace iter {
             zip_iter(const First & f, const Second & s) :
                 iter1(f),iter2(s) { }
 
-            auto operator*() -> decltype(std::make_tuple(iter1,iter2))
+            auto operator*() -> decltype(std::tie(*iter1,*iter2))
             {
-                return std::make_tuple(iter1,iter2);
+                return std::tie(*iter1,*iter2);
             }
             zip_iter & operator++() {
                 ++iter1;
@@ -56,7 +57,7 @@ namespace iter {
         public:
             using Elem_t = decltype(*iter);
             using tuple_t = 
-                decltype(std::tuple_cat(std::make_tuple(iter),*inner_iter));
+                decltype(std::tuple_cat(std::tie(*iter),*inner_iter));
 
             zip_iter(const First & f, const Rest & ... rest) :
                 iter(f),
@@ -66,7 +67,7 @@ namespace iter {
 
             tuple_t operator*()
             {
-                return std::tuple_cat(std::make_tuple(iter),*inner_iter);
+                return std::tuple_cat(std::tie(*iter),*inner_iter);
             }
             zip_iter & operator++() {
                 ++iter;

From c971b3be83168caf68fd37c3d5c6fcd85807fe3a Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Wed, 2 Oct 2013 01:16:17 -0400
Subject: [PATCH 0003/1866] zip_longest_iter returns tuple of boost::optional

---
 tests/testzip_longest.cpp |  6 +++---
 zip_longest.hpp           | 15 ++++++++++-----
 2 files changed, 13 insertions(+), 8 deletions(-)

diff --git a/tests/testzip_longest.cpp b/tests/testzip_longest.cpp
index d58fd476..e2fb8aab 100644
--- a/tests/testzip_longest.cpp
+++ b/tests/testzip_longest.cpp
@@ -11,7 +11,7 @@ using iter::zip_longest;
 template <typename T>
 std::ostream & operator<<(std::ostream & o, const boost::optional<T> & opt) {
     if (opt) {
-        std::cout << **opt << std::endl;
+        std::cout << *opt << std::endl;
     }
     else {
         std::cout << "Object disengaged of type " << typeid(T).name() << std::endl;
@@ -43,9 +43,9 @@ int main() {
                 << std::get<1>(e) 
                 << std::get<2>(e) 
                 << std::get<3>(e) << std::endl;
-            **std::get<1>(e)=2.2f; //modify the float array
+            *std::get<1>(e)=2.2f; //modify the float array
         }
-        std::cout<<std::endl;
+        std::cout<<"modified array" <<std::endl;
         for (auto e : iter::zip_longest(i,s,f,d)) {
             std::cout << std::get<0>(e) 
                 << std::get<1>(e) 
diff --git a/zip_longest.hpp b/zip_longest.hpp
index b9db743c..b546abe3 100644
--- a/zip_longest.hpp
+++ b/zip_longest.hpp
@@ -38,11 +38,12 @@ namespace iter {
             zip_longest_iter(Container & c) :
                 begin(c.begin()),end(c.end()) {}
 
-            std::tuple<boost::optional<Iterator>> operator*()     
+            std::tuple<boost::optional<decltype(*std::declval<Iterator>())>> 
+            operator*()     
             {
                 return std::make_tuple(begin != end ? 
-                        boost::optional<Iterator>(begin)
-                        : boost::optional<Iterator>());
+                        boost::optional<decltype(*std::declval<Iterator>())>(*begin)
+                        : boost::optional<decltype(*std::declval<Iterator>())>());
             }
             zip_longest_iter & operator++() {
                 if(begin!=end)++begin;
@@ -64,7 +65,9 @@ namespace iter {
         public:
             using Elem_t = decltype(*begin);
             using tuple_t = 
-                decltype(std::tuple_cat(std::tuple<boost::optional<Iterator>>(),*inner_iter));
+                decltype(std::tuple_cat(
+                            std::tuple<boost::optional<Elem_t>>(),
+                            *inner_iter));
 
             zip_longest_iter(Container & c, Containers & ... containers) :
                 begin(c.begin()),
@@ -75,7 +78,9 @@ namespace iter {
 
             tuple_t operator*()
             {
-                return std::tuple_cat(std::make_tuple(begin != end ?boost::optional<Iterator>(begin):boost::optional<Iterator>()),*inner_iter);
+                return std::tuple_cat(std::make_tuple(begin != end 
+                            ?boost::optional<Elem_t>(*begin)
+                            :boost::optional<Elem_t>()),*inner_iter);
             }
             zip_longest_iter & operator++() {
                 if (begin != end) ++begin;

From ccb1c8d22f1e7ed74a730b5027d9d5cd0ba7e48d Mon Sep 17 00:00:00 2001
From: aaronjosephs <ajoseph4@binghamton.edu>
Date: Wed, 2 Oct 2013 01:24:52 -0400
Subject: [PATCH 0004/1866] Readme updated for improved zip and zip_longest

---
 README.md | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/README.md b/README.md
index 8650f13d..16b71a4b 100644
--- a/README.md
+++ b/README.md
@@ -137,8 +137,8 @@ zip
 
 Takes an arbitrary number of ranges of different types and efficiently iterates over 
 them in parallel (so an iterator to each container is incremented simultaneously). 
-When you dereference an iterator to "zipped" range you get a tuple of iterators to 
-those containers.
+When you dereference an iterator to "zipped" range you get a tuple of whatever elements 
+the iterators were holding.
 
 Example usage:
 ```c++
@@ -148,20 +148,20 @@ vector<string> s{"i","like","apples","alot","dude"};
 array<double,5> d{{1.2,1.2,1.2,1.2,1.2}};                             
 
 for (auto e : zip(i,f,s,d)) {                                        
-    cout << zip_get<0>(e) << ' '                                
-         << zip_get<1>(e) << ' '                                      
-         << zip_get<2>(e) << ' '                                      
-         << zip_get<3>(e) << '\n';                               
-    zip_get<1>(e)=2.2f; // modify the float array                     
+    cout << std::get<0>(e) << ' '                                
+         << std::get<1>(e) << ' '                                      
+         << std::get<2>(e) << ' '                                      
+         << std::get<3>(e) << '\n';                               
+    std::get<1>(e)=2.2f; // modify the float array                     
 }
 ```
 
-`iter::zip_get` is used to readably dereference the iterators yielded
+~~`iter::zip_get` is used to readably dereference the iterators yielded~~
 
 a `zip_longest` also exists where the range terminates on the longest
 range instead of the shortest. because of that you have to return a
-`boost::optional` (`std::optional` when it is released) and cannot use
-`zip_get`
+`boost::optional<T>` where `T` is whatever type the iterator dereferenced
+to (`std::optional` when it is released, if ever)
 
 
 compress

From 3dec5d2a089db083ec434a9367fcae6efd41ff94 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 2 Oct 2013 02:37:43 -0700
Subject: [PATCH 0005/1866] Adds SConstruct and adds *.o to .gitignore

I haven't used SCons all that much, but it's implicit dependency
checking on header files is extremely useful.
---
 tests/.gitignore |  1 +
 tests/SConstruct | 27 +++++++++++++++++++++++++++
 2 files changed, 28 insertions(+)
 create mode 100644 tests/SConstruct

diff --git a/tests/.gitignore b/tests/.gitignore
index 8f7d5db6..b07f3462 100644
--- a/tests/.gitignore
+++ b/tests/.gitignore
@@ -1,3 +1,4 @@
+*.o
 testchain
 testcycle
 testenumerate
diff --git a/tests/SConstruct b/tests/SConstruct
new file mode 100644
index 00000000..d06bfecd
--- /dev/null
+++ b/tests/SConstruct
@@ -0,0 +1,27 @@
+progs = Split( '''
+		cycle 
+		enumerate 
+		range 
+		zip 
+		slice 
+		reverse 
+		filter 
+		repeat 
+		takewhile 
+		dropwhile 
+		zip_longest 
+		product 
+		permutations 
+		compress 
+		combinations_with_replacement 
+		combinations 
+		powerset
+        ''')
+
+cxx_flags = '-Wall -Wextra -pedantic -std=c++11'
+
+for p in progs:
+    Program(target='test{0}'.format(p), source='test{0}.cpp'.format(p),
+            CXXFLAGS=cxx_flags, CPPPATH='..', CXX='clang++')
+
+

From c23441defdd515597fe5915ed55f6090b67a6867 Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Wed, 2 Oct 2013 15:44:51 -0400
Subject: [PATCH 0006/1866] started to do moving section

---
 iter_ideas.txt               |  3 +-
 itertools.hpp                |  1 +
 moving_section.hpp           | 57 ++++++++++++++++++++++++++++++++++++
 tests/Makefile               |  3 +-
 tests/testmoving_section.cpp | 16 ++++++++++
 5 files changed, 78 insertions(+), 2 deletions(-)
 create mode 100644 moving_section.hpp
 create mode 100644 tests/testmoving_section.cpp

diff --git a/iter_ideas.txt b/iter_ideas.txt
index 7c68e9c1..be6d2b9c 100644
--- a/iter_ideas.txt
+++ b/iter_ideas.txt
@@ -1,4 +1,5 @@
-x at a time iterator. Lets say you have a list
+movingsection(Container & container,size_t section_size);
+Lets say you have a list
     [1,2,3,4,5,6,7,8]
 and you want to iterate over 3 elements at a time. You could create three 
 iterators and incrment them simulatneously, or do something like this.
diff --git a/itertools.hpp b/itertools.hpp
index 20119bb8..6e395e08 100644
--- a/itertools.hpp
+++ b/itertools.hpp
@@ -24,6 +24,7 @@
 #include "zip.hpp"
 #include "zip_longest.hpp"
 #include "powerset.hpp"
+#include "moving_section.hpp"
 
 //not sure if should include "iterator_range.hpp"
 //since it's already in everything
diff --git a/moving_section.hpp b/moving_section.hpp
new file mode 100644
index 00000000..bf05c404
--- /dev/null
+++ b/moving_section.hpp
@@ -0,0 +1,57 @@
+#ifndef MOVING_SECTION_HPP
+#define MOVING_SECTION_HPP
+
+#include "iterator_range.hpp"
+#include <vector>
+#include <algorithm>
+
+namespace iter {
+    template <typename Container>
+        struct moving_section_iter;
+    template <typename Container>
+        iterator_range<moving_section_iter<Container>>
+        moving_section(Container & container, size_t s) {
+            auto begin = moving_section_iter<Container>(container,s);
+            auto end = moving_section_iter<Container>(container);
+            return iterator_range<moving_section_iter<Container>>(begin,end);
+        }
+
+    template <typename Container>
+        struct moving_section_iter {
+            Container & container;
+            using Iterator = decltype(container.begin());
+            std::vector<Iterator> section;
+            size_t section_size = 0;
+            moving_section_iter(Container & c, size_t s) :
+                container(c),section_size(s) {
+                    for (size_t i = 0; i < section_size; ++i) 
+                        section.push_back(container.begin()+i);
+                }
+            moving_section_iter(Container & c) : container(c)
+            //creates the end iterator
+            {
+                section.push_back(container.end());
+            }
+
+            moving_section_iter & operator++() {
+                for (auto & iter : section) {
+                    ++iter;
+                }
+                return *this;
+                //std::for_each(section.begin(),section.end(),[](Iterator & i){++i;});
+            }
+            bool operator!=(const moving_section_iter & rhs) {
+               return this->section.back() != rhs.section.back();
+            }
+            auto operator*() -> std::vector<decltype(*(section.front()))>
+            {
+                std::vector<decltype(*(section.front()))&> vec(section.front(),section.back()+1);
+                //for (auto iter : section) {
+                  //  vec.push_back(*iter);
+                //}
+                return vec;
+            }
+        };
+}
+
+#endif //MOVING_SECTION_HPP
diff --git a/tests/Makefile b/tests/Makefile
index 83c3d7ce..7fadaf98 100644
--- a/tests/Makefile
+++ b/tests/Makefile
@@ -30,7 +30,8 @@ TESTS = \
 		testcompress \
 		testcombinations_with_replacement \
 		testcombinations \
-		testpowerset
+		testpowerset \
+		testmoving_section
 
 all: $(TESTS)
 
diff --git a/tests/testmoving_section.cpp b/tests/testmoving_section.cpp
new file mode 100644
index 00000000..65ce754f
--- /dev/null
+++ b/tests/testmoving_section.cpp
@@ -0,0 +1,16 @@
+#include "moving_section.hpp"
+#include <iostream>
+#include <vector>
+using iter::moving_section;
+int main() {
+    std::vector<int> v = {1,2,3,4,5,6,7,8,9}; 
+    for (auto sec : moving_section(v,4)) {
+        /*
+        for (auto & i : sec) {
+            std::cout << i << " ";
+        }
+        */
+        std::cout << std::endl;
+    }
+    return 0;
+}

From 09e20368bd278bb35641402b32ec7ba9261f7050 Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Wed, 2 Oct 2013 19:44:49 -0400
Subject: [PATCH 0007/1866] Test moving section working with reference wrapper,
 it has to be that way as vector cannot store references

---
 moving_section.hpp           | 13 ++++++++-----
 tests/.gitignore             |  1 +
 tests/testmoving_section.cpp |  5 ++---
 3 files changed, 11 insertions(+), 8 deletions(-)

diff --git a/moving_section.hpp b/moving_section.hpp
index bf05c404..35b940bf 100644
--- a/moving_section.hpp
+++ b/moving_section.hpp
@@ -4,6 +4,8 @@
 #include "iterator_range.hpp"
 #include <vector>
 #include <algorithm>
+#include <functional>
+#include <type_traits>
 
 namespace iter {
     template <typename Container>
@@ -43,12 +45,13 @@ namespace iter {
             bool operator!=(const moving_section_iter & rhs) {
                return this->section.back() != rhs.section.back();
             }
-            auto operator*() -> std::vector<decltype(*(section.front()))>
+            using Deref_type = std::vector<std::reference_wrapper<typename std::remove_reference<decltype(*std::declval<Iterator>())>::type>>;
+            Deref_type operator*()
             {
-                std::vector<decltype(*(section.front()))&> vec(section.front(),section.back()+1);
-                //for (auto iter : section) {
-                  //  vec.push_back(*iter);
-                //}
+                Deref_type vec;
+                for (auto i : section) {
+                    vec.push_back(*i);
+                }
                 return vec;
             }
         };
diff --git a/tests/.gitignore b/tests/.gitignore
index b07f3462..5db5fc20 100644
--- a/tests/.gitignore
+++ b/tests/.gitignore
@@ -17,3 +17,4 @@ testcombinations_with_replacement
 testtakewhile
 testcombinations
 testpowerset
+testmoving_section
diff --git a/tests/testmoving_section.cpp b/tests/testmoving_section.cpp
index 65ce754f..3faf21e7 100644
--- a/tests/testmoving_section.cpp
+++ b/tests/testmoving_section.cpp
@@ -5,11 +5,10 @@ using iter::moving_section;
 int main() {
     std::vector<int> v = {1,2,3,4,5,6,7,8,9}; 
     for (auto sec : moving_section(v,4)) {
-        /*
-        for (auto & i : sec) {
+        for (auto i : sec) {
             std::cout << i << " ";
+            i.get() = 90;
         }
-        */
         std::cout << std::endl;
     }
     return 0;

From 8f0e0ed06bdc8077e7950a91d1b5a701c4a897c9 Mon Sep 17 00:00:00 2001
From: ryanhaining <rhainin1@binghamton.edu>
Date: Wed, 2 Oct 2013 17:06:17 -0700
Subject: [PATCH 0008/1866] Update LICENSE.md

---
 LICENSE.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/LICENSE.md b/LICENSE.md
index 1d6598bb..3b340456 100644
--- a/LICENSE.md
+++ b/LICENSE.md
@@ -1,4 +1,4 @@
-Copyright (c) {{year}}, {{fullname}}
+Copyright (c) 2013, Ryan Haining, Aaron Josephs
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without modification,

From 433b6ef05c23f73f43ae25ce86a8b1e22b8e672d Mon Sep 17 00:00:00 2001
From: aaronjosephs <ajoseph4@binghamton.edu>
Date: Thu, 3 Oct 2013 02:38:18 -0400
Subject: [PATCH 0009/1866] Updated README for moving_section

---
 README.md | 34 ++++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/README.md b/README.md
index 16b71a4b..598465c7 100644
--- a/README.md
+++ b/README.md
@@ -16,6 +16,7 @@ library.
 [chain](#chain)<br />
 [reverse](#reverse)<br />
 [slice](#slice)<br />
+[moving_section](#moving_section)<br />
 
 ##### Combinatoric fuctions
 [product](#product)<br />
@@ -285,3 +286,36 @@ for (auto v : powerset(vec)) {
     std::cout << std::endl;                                                    
 }
 ```
+
+moving_section
+-------------
+
+Takes a section from a range and increments the whole section.  
+
+Example:
+`[1, 2, 3, 4, 5, 6, 7, 8, 9]`  
+
+take a section of size 4, output is:
+```
+1 2 3 4 
+2 3 4 5 
+3 4 5 6 
+4 5 6 7 
+5 6 7 8 
+6 7 8 9 
+```
+
+Example Usage:
+```c++
+std::vector<int> v = {1,2,3,4,5,6,7,8,9};                                      
+for (auto sec : moving_section(v,4)) {                                         
+    for (auto i : sec) {                                                       
+        std::cout << i << " ";                                                 
+        i.get() = 90; 
+        //has to be accessed with get if you want to store references
+        //because it is stored in a reference_wrapper (std::vector 
+        //cannot hold references)
+    }                                                                          
+    std::cout << std::endl;                                                    
+}
+```    

From b7630230f8c6509e89704d2b96337394005aee25 Mon Sep 17 00:00:00 2001
From: aaronjosephs <ajoseph4@binghamton.edu>
Date: Thu, 3 Oct 2013 02:40:26 -0400
Subject: [PATCH 0010/1866] moving_section put in wrong spot

---
 README.md | 66 ++++++++++++++++++++++++++++---------------------------
 1 file changed, 34 insertions(+), 32 deletions(-)

diff --git a/README.md b/README.md
index 598465c7..b57e1407 100644
--- a/README.md
+++ b/README.md
@@ -221,6 +221,39 @@ for (auto i : slice(a,0,15,3)) {
 }
 ```
 
+moving_section
+-------------
+
+Takes a section from a range and increments the whole section.  
+
+Example:
+`[1, 2, 3, 4, 5, 6, 7, 8, 9]`  
+
+take a section of size 4, output is:
+```
+1 2 3 4 
+2 3 4 5 
+3 4 5 6 
+4 5 6 7 
+5 6 7 8 
+6 7 8 9 
+```
+
+Example Usage:
+```c++
+std::vector<int> v = {1,2,3,4,5,6,7,8,9};                                      
+for (auto sec : moving_section(v,4)) {                                         
+    for (auto i : sec) {                                                       
+        std::cout << i << " ";                                                 
+        i.get() = 90; 
+        //has to be accessed with get if you want to store references
+        //because it is stored in a reference_wrapper (std::vector 
+        //cannot hold references)
+    }                                                                          
+    std::cout << std::endl;                                                    
+}
+```  
+
 product
 ------
 
@@ -287,35 +320,4 @@ for (auto v : powerset(vec)) {
 }
 ```
 
-moving_section
--------------
-
-Takes a section from a range and increments the whole section.  
-
-Example:
-`[1, 2, 3, 4, 5, 6, 7, 8, 9]`  
-
-take a section of size 4, output is:
-```
-1 2 3 4 
-2 3 4 5 
-3 4 5 6 
-4 5 6 7 
-5 6 7 8 
-6 7 8 9 
-```
-
-Example Usage:
-```c++
-std::vector<int> v = {1,2,3,4,5,6,7,8,9};                                      
-for (auto sec : moving_section(v,4)) {                                         
-    for (auto i : sec) {                                                       
-        std::cout << i << " ";                                                 
-        i.get() = 90; 
-        //has to be accessed with get if you want to store references
-        //because it is stored in a reference_wrapper (std::vector 
-        //cannot hold references)
-    }                                                                          
-    std::cout << std::endl;                                                    
-}
-```    
+  

From 37fca81bb6d76c4bb6a2798fb491b5b12fbcf8b7 Mon Sep 17 00:00:00 2001
From: ryanhaining <rhainin1@binghamton.edu>
Date: Thu, 3 Oct 2013 10:42:21 -0700
Subject: [PATCH 0011/1866] Adds compress to itertools.hpp

---
 itertools.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/itertools.hpp b/itertools.hpp
index 6e395e08..13b5c57a 100644
--- a/itertools.hpp
+++ b/itertools.hpp
@@ -8,6 +8,7 @@
 #include "chain.hpp"
 #include "combinations_with_replacement.hpp"
 #include "combinations.hpp"
+#include "compress.hpp"
 #include "cycle.hpp"
 #include "dropwhile.hpp"
 #include "enumerate.hpp"

From 094b1d366d7b60c0d18f6c18e25339149a63112d Mon Sep 17 00:00:00 2001
From: ryanhaining <rhainin1@binghamton.edu>
Date: Thu, 3 Oct 2013 12:25:25 -0700
Subject: [PATCH 0012/1866] Update README.md

---
 README.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/README.md b/README.md
index b57e1407..ca6752c2 100644
--- a/README.md
+++ b/README.md
@@ -157,7 +157,6 @@ for (auto e : zip(i,f,s,d)) {
 }
 ```
 
-~~`iter::zip_get` is used to readably dereference the iterators yielded~~
 
 a `zip_longest` also exists where the range terminates on the longest
 range instead of the shortest. because of that you have to return a

From 9e21aa135e079ec935e1b767b06924676dd12718 Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Thu, 3 Oct 2013 17:25:42 -0400
Subject: [PATCH 0013/1866] removed extra include from itertools.hpp

---
 itertools.hpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/itertools.hpp b/itertools.hpp
index 13b5c57a..fe40a3e3 100644
--- a/itertools.hpp
+++ b/itertools.hpp
@@ -5,7 +5,6 @@
 #include "reverse.hpp"
 #include "slice.hpp"
 #include "chain.hpp"
-#include "chain.hpp"
 #include "combinations_with_replacement.hpp"
 #include "combinations.hpp"
 #include "compress.hpp"

From ec8adef238017f33b58db964e4ac50658affb0cb Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 4 Oct 2013 15:47:14 -0700
Subject: [PATCH 0014/1866] Adds simple imap

Only works on a single iterator.
---
 imap.hpp           | 99 ++++++++++++++++++++++++++++++++++++++++++++++
 tests/SConstruct   |  2 +
 tests/testimap.cpp | 14 +++++++
 3 files changed, 115 insertions(+)
 create mode 100644 imap.hpp
 create mode 100644 tests/testimap.cpp

diff --git a/imap.hpp b/imap.hpp
new file mode 100644
index 00000000..8d94e726
--- /dev/null
+++ b/imap.hpp
@@ -0,0 +1,99 @@
+#ifndef IMAP__H__
+#define IMAP__H__
+
+#include <utility>
+#include <type_traits>
+
+namespace iter {
+
+    //Forward declarations of IMap and imap
+    template <typename MapFunc, typename Container>
+    class IMap;
+
+    template <typename MapFunc, typename Container>
+    IMap<MapFunc, Container> imap(MapFunc, Container &);
+
+    template <typename MapFunc, typename Container>
+    class IMap {
+        // The imap function is the only thing allowed to create a IMap
+        friend IMap imap<MapFunc, Container>(MapFunc, Container &);
+
+        // Type of the Container::Iterator, but since the name of that 
+        // iterator can be anything, we have to grab it with this
+        using contained_iter_type =
+            decltype(std::declval<Container>().begin());
+
+        // The type returned when dereferencing the Container::Iterator
+        using contained_iter_ret =
+            decltype(std::declval<contained_iter_type>().operator*());
+
+        private:
+            Container & container;
+            MapFunc map_func;
+            
+            // Value constructor for use only in the imap function
+            IMap(MapFunc map_func, Container & container) :
+                container(container),
+                map_func(map_func)
+            { }
+            IMap () = delete;
+            IMap & operator=(const IMap &) = delete;
+
+        public:
+            IMap (const IMap &) = default;
+
+            class Iterator {
+                private:
+                    contained_iter_type sub_iter;
+                    const contained_iter_type sub_end;
+                    MapFunc map_func;
+
+                public:
+                    Iterator (contained_iter_type iter,
+                            contained_iter_type end,
+                            MapFunc map_func) :
+                        sub_iter(iter),
+                        sub_end(end),
+                        map_func(map_func)
+                    { } 
+
+                    auto operator*() const -> decltype(map_func(*this->sub_iter)) {
+                        return map_func(*this->sub_iter);
+                    }
+
+                    Iterator & operator++() { 
+                        ++this->sub_iter;
+                        return *this;
+                    }
+
+                    bool operator!=(const Iterator & other) const {
+                        return this->sub_iter != other.sub_iter;
+                    }
+            };
+
+            Iterator begin() const {
+                return Iterator(
+                        this->container.begin(),
+                        this->container.end(),
+                        this->map_func);
+            }
+
+            Iterator end() const {
+                return Iterator(
+                        this->container.end(),
+                        this->container.end(),
+                        this->map_func);
+            }
+
+    };
+
+    // Helper function to instantiate a IMap
+    template <typename MapFunc, typename Container>
+    IMap<MapFunc, Container> imap(
+            MapFunc map_func, Container & container) {
+        return IMap<MapFunc, Container>(map_func, container);
+    }
+
+}
+
+#endif //ifndef IMAP__H__
diff --git a/tests/SConstruct b/tests/SConstruct
index d06bfecd..06332784 100644
--- a/tests/SConstruct
+++ b/tests/SConstruct
@@ -16,6 +16,8 @@ progs = Split( '''
 		combinations_with_replacement 
 		combinations 
 		powerset
+        moving_section
+        imap
         ''')
 
 cxx_flags = '-Wall -Wextra -pedantic -std=c++11'
diff --git a/tests/testimap.cpp b/tests/testimap.cpp
new file mode 100644
index 00000000..e764d9fb
--- /dev/null
+++ b/tests/testimap.cpp
@@ -0,0 +1,14 @@
+#include <imap.hpp>
+
+#include <vector>
+#include <iostream>
+
+using iter::imap;
+
+int main() {
+    std::vector<int> vec= {1, 2, 3, 4, 5, 6};
+    for (auto i : imap([] (int x) { return x * x; }, vec)) {
+        std::cout << i << '\n';
+    }
+    return 0;
+}

From aa6ae78167d78ce0e6fd1cd2fe58adf0da89c562 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 4 Oct 2013 17:56:11 -0700
Subject: [PATCH 0015/1866] Starts to covert to variadic imap

---
 imap.hpp           | 106 ++++++++++++++++++++++++++++-----------------
 tests/testimap.cpp |   5 ++-
 2 files changed, 70 insertions(+), 41 deletions(-)

diff --git a/imap.hpp b/imap.hpp
index 8d94e726..d5570539 100644
--- a/imap.hpp
+++ b/imap.hpp
@@ -1,40 +1,77 @@
 #ifndef IMAP__H__
 #define IMAP__H__
 
+#include "zip.hpp"
+
 #include <utility>
 #include <type_traits>
 
 namespace iter {
 
+    // implementation details, users never invoke these directly
+    namespace detail
+    {
+        template <typename F, typename Tuple, bool Done, int Total, int... N>
+        struct call_impl
+        {
+            static void call(F f, Tuple && t)
+            {
+                call_impl<F,
+                    Tuple,
+                    Total == 1 + sizeof...(N),
+                    Total,
+                    N...,
+                    sizeof...(N)>::call(f, std::forward<Tuple>(t));
+            }
+        };
+
+        template <typename F, typename Tuple, int Total, int... N>
+        struct call_impl<F, Tuple, true, Total, N...>
+        {
+            static void call(F f, Tuple && t)
+            {
+                f(std::get<N>(std::forward<Tuple>(t))...);
+            }
+        };
+
+        // user invokes this
+        template <typename F, typename Tuple>
+        void call(F f, Tuple && t)
+        {
+            typedef typename std::decay<Tuple>::type ttype;
+            call_impl<F,
+                Tuple,
+                0 == std::tuple_size<ttype>::value,
+                std::tuple_size<ttype>::value>::call(f,
+                        std::forward<Tuple>(t));
+        }
+    }
+
     //Forward declarations of IMap and imap
-    template <typename MapFunc, typename Container>
+    template <typename MapFunc, typename... Containers>
     class IMap;
 
-    template <typename MapFunc, typename Container>
-    IMap<MapFunc, Container> imap(MapFunc, Container &);
+    template <typename MapFunc, typename... Containers>
+    IMap<MapFunc, Containers...> imap(MapFunc, Containers &...);
 
-    template <typename MapFunc, typename Container>
+    template <typename MapFunc, typename... Containers>
     class IMap {
         // The imap function is the only thing allowed to create a IMap
-        friend IMap imap<MapFunc, Container>(MapFunc, Container &);
+        friend IMap imap<MapFunc, Containers...>(MapFunc, Containers & ...);
 
-        // Type of the Container::Iterator, but since the name of that 
-        // iterator can be anything, we have to grab it with this
-        using contained_iter_type =
-            decltype(std::declval<Container>().begin());
+        // The type returned when dereferencing the Containers...::Iterator
+        using Zipped = iterator_range<zip_iter<Containers...>>;
 
-        // The type returned when dereferencing the Container::Iterator
-        using contained_iter_ret =
-            decltype(std::declval<contained_iter_type>().operator*());
+        using ZippedIterType = decltype(std::declval<Zipped>().begin());
 
         private:
-            Container & container;
             MapFunc map_func;
+            Zipped zipped;
             
             // Value constructor for use only in the imap function
-            IMap(MapFunc map_func, Container & container) :
-                container(container),
-                map_func(map_func)
+            IMap(MapFunc map_func, Containers & ... containers) :
+                map_func(map_func),
+                zipped(zip(containers...))
             { }
             IMap () = delete;
             IMap & operator=(const IMap &) = delete;
@@ -44,54 +81,45 @@ namespace iter {
 
             class Iterator {
                 private:
-                    contained_iter_type sub_iter;
-                    const contained_iter_type sub_end;
                     MapFunc map_func;
+                    ZippedIterType zipiter;
 
                 public:
-                    Iterator (contained_iter_type iter,
-                            contained_iter_type end,
-                            MapFunc map_func) :
-                        sub_iter(iter),
-                        sub_end(end),
+                    Iterator (MapFunc map_func, ZippedIterType zipiter) :
+                        zipiter(zipiter),
                         map_func(map_func)
                     { } 
 
-                    auto operator*() const -> decltype(map_func(*this->sub_iter)) {
-                        return map_func(*this->sub_iter);
+                    auto operator*() const ->
+                            decltype(detail::call(map_func, *this->zipter)) {
+                        return detail::call(map_func, *zipiter);
                     }
 
                     Iterator & operator++() { 
-                        ++this->sub_iter;
+                        ++this->zipiter;
                         return *this;
                     }
 
                     bool operator!=(const Iterator & other) const {
-                        return this->sub_iter != other.sub_iter;
+                        return this->zipiter != other.zipiter;
                     }
             };
 
             Iterator begin() const {
-                return Iterator(
-                        this->container.begin(),
-                        this->container.end(),
-                        this->map_func);
+                return Iterator(this->map_func, this->zipped.begin());
             }
 
             Iterator end() const {
-                return Iterator(
-                        this->container.end(),
-                        this->container.end(),
-                        this->map_func);
+                return Iterator(this->map_func, this->zipped.end());
             }
 
     };
 
     // Helper function to instantiate a IMap
-    template <typename MapFunc, typename Container>
-    IMap<MapFunc, Container> imap(
-            MapFunc map_func, Container & container) {
-        return IMap<MapFunc, Container>(map_func, container);
+    template <typename MapFunc, typename... Containers>
+    IMap<MapFunc, Containers...> imap(
+            MapFunc map_func, Containers & ... containers) {
+        return IMap<MapFunc, Containers...>(map_func, containers...);
     }
 
 }
diff --git a/tests/testimap.cpp b/tests/testimap.cpp
index e764d9fb..a2b74f5b 100644
--- a/tests/testimap.cpp
+++ b/tests/testimap.cpp
@@ -6,8 +6,9 @@
 using iter::imap;
 
 int main() {
-    std::vector<int> vec= {1, 2, 3, 4, 5, 6};
-    for (auto i : imap([] (int x) { return x * x; }, vec)) {
+    std::vector<int> vec1 = {1, 2, 3, 4, 5, 6};
+    std::vector<int> vec2 = {10, 20, 30, 40, 50, 60};
+    for (auto i : imap([] (int x, int y) { return x + y; }, vec1, vec2)) {
         std::cout << i << '\n';
     }
     return 0;

From 89f7303e4752c56669b9fb50fd2310c24c5c8b4a Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 4 Oct 2013 22:27:21 -0700
Subject: [PATCH 0016/1866] Closer to a working variadic imap

---
 imap.hpp | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/imap.hpp b/imap.hpp
index d5570539..fb345e76 100644
--- a/imap.hpp
+++ b/imap.hpp
@@ -60,7 +60,9 @@ namespace iter {
         friend IMap imap<MapFunc, Containers...>(MapFunc, Containers & ...);
 
         // The type returned when dereferencing the Containers...::Iterator
-        using Zipped = iterator_range<zip_iter<Containers...>>;
+        // XXX depends on zip using iterator_range.  would be nice if it didn't
+        using Zipped = 
+            iterator_range<zip_iter<decltype(std::declval<Containers>().begin())...>>;
 
         using ZippedIterType = decltype(std::declval<Zipped>().begin());
 
@@ -86,13 +88,14 @@ namespace iter {
 
                 public:
                     Iterator (MapFunc map_func, ZippedIterType zipiter) :
-                        zipiter(zipiter),
-                        map_func(map_func)
+                        map_func(map_func),
+                        zipiter(zipiter)
                     { } 
 
                     auto operator*() const ->
-                            decltype(detail::call(map_func, *this->zipter)) {
-                        return detail::call(map_func, *zipiter);
+                            decltype(map_func(*this->zipiter))
+                    {
+                        return detail::call(this->map_func, *this->zipiter);
                     }
 
                     Iterator & operator++() { 

From a46fc449dc5db94f528ad037bf5a8934251342be Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Fri, 4 Oct 2013 22:55:12 -0400
Subject: [PATCH 0017/1866] bullshit fix for imap

---
 imap.hpp | 9 +++++----
 zip.hpp  | 1 -
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/imap.hpp b/imap.hpp
index fb345e76..9fb1999a 100644
--- a/imap.hpp
+++ b/imap.hpp
@@ -65,6 +65,7 @@ namespace iter {
             iterator_range<zip_iter<decltype(std::declval<Containers>().begin())...>>;
 
         using ZippedIterType = decltype(std::declval<Zipped>().begin());
+            //typename std::remove_const<decltype(std::declval<Zipped>().begin())>::type;
 
         private:
             MapFunc map_func;
@@ -84,7 +85,7 @@ namespace iter {
             class Iterator {
                 private:
                     MapFunc map_func;
-                    ZippedIterType zipiter;
+                    mutable ZippedIterType zipiter;
 
                 public:
                     Iterator (MapFunc map_func, ZippedIterType zipiter) :
@@ -92,10 +93,10 @@ namespace iter {
                         zipiter(zipiter)
                     { } 
 
-                    auto operator*() const ->
-                            decltype(map_func(*this->zipiter))
+                    auto operator*() const -> 
+                        decltype(detail::call(this->map_func, *(this->zipiter)))
                     {
-                        return detail::call(this->map_func, *this->zipiter);
+                        return detail::call(this->map_func, *(this->zipiter));
                     }
 
                     Iterator & operator++() { 
diff --git a/zip.hpp b/zip.hpp
index 52681dcb..a9286e97 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -63,7 +63,6 @@ namespace iter {
                 iter(f),
                 inner_iter(rest...) {}
 
-            //this is for returning a tuple of iterators
 
             tuple_t operator*()
             {

From 4eea483e07354e000e0526238030d39424606580 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 4 Oct 2013 23:12:07 -0700
Subject: [PATCH 0018/1866] Adds return type to detail::call

---
 imap.hpp | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

diff --git a/imap.hpp b/imap.hpp
index 9fb1999a..18c1a0d8 100644
--- a/imap.hpp
+++ b/imap.hpp
@@ -14,9 +14,9 @@ namespace iter {
         template <typename F, typename Tuple, bool Done, int Total, int... N>
         struct call_impl
         {
-            static void call(F f, Tuple && t)
+            static auto call(F f, Tuple && t) -> decltype(f(t))
             {
-                call_impl<F,
+                return call_impl<F,
                     Tuple,
                     Total == 1 + sizeof...(N),
                     Total,
@@ -28,22 +28,21 @@ namespace iter {
         template <typename F, typename Tuple, int Total, int... N>
         struct call_impl<F, Tuple, true, Total, N...>
         {
-            static void call(F f, Tuple && t)
+            static auto call(F f, Tuple && t) -> decltype(f(t))
             {
-                f(std::get<N>(std::forward<Tuple>(t))...);
+                return f(std::get<N>(std::forward<Tuple>(t))...);
             }
         };
 
         // user invokes this
         template <typename F, typename Tuple>
-        void call(F f, Tuple && t)
+        auto call(F f, Tuple && t) -> decltype(f(t))
         {
             typedef typename std::decay<Tuple>::type ttype;
-            call_impl<F,
+            return call_impl<F,
                 Tuple,
                 0 == std::tuple_size<ttype>::value,
-                std::tuple_size<ttype>::value>::call(f,
-                        std::forward<Tuple>(t));
+                std::tuple_size<ttype>::value>::call(f,std::forward<Tuple>(t));
         }
     }
 

From 6bdc0c3ac15fe5bca5f9005f9f0ae0e8bf2e7294 Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Fri, 4 Oct 2013 23:23:23 -0400
Subject: [PATCH 0019/1866] imap fixed with crazy delctypes

---
 imap.hpp | 18 +++++++++++++++---
 1 file changed, 15 insertions(+), 3 deletions(-)

diff --git a/imap.hpp b/imap.hpp
index 18c1a0d8..6de22b48 100644
--- a/imap.hpp
+++ b/imap.hpp
@@ -14,7 +14,13 @@ namespace iter {
         template <typename F, typename Tuple, bool Done, int Total, int... N>
         struct call_impl
         {
-            static auto call(F f, Tuple && t) -> decltype(f(t))
+            static auto call(F f, Tuple && t) -> 
+                decltype(call_impl<F,
+                    Tuple,
+                    Total == 1 + sizeof...(N),
+                    Total,
+                    N...,
+                    sizeof...(N)>::call(f, std::forward<Tuple>(t)))
             {
                 return call_impl<F,
                     Tuple,
@@ -28,7 +34,8 @@ namespace iter {
         template <typename F, typename Tuple, int Total, int... N>
         struct call_impl<F, Tuple, true, Total, N...>
         {
-            static auto call(F f, Tuple && t) -> decltype(f(t))
+            static auto call(F f, Tuple && t) -> 
+                decltype(f(std::get<N>(std::forward<Tuple>(t))...))
             {
                 return f(std::get<N>(std::forward<Tuple>(t))...);
             }
@@ -36,7 +43,12 @@ namespace iter {
 
         // user invokes this
         template <typename F, typename Tuple>
-        auto call(F f, Tuple && t) -> decltype(f(t))
+        auto call(F f, Tuple && t) -> 
+            decltype(call_impl<F,
+                Tuple,
+                0 == std::tuple_size<typename std::decay<Tuple>::type>::value,
+                std::tuple_size<typename std::decay<Tuple>::type>::value>
+                ::call(f,std::forward<Tuple>(t)))
         {
             typedef typename std::decay<Tuple>::type ttype;
             return call_impl<F,

From 234524cc84bac1445f64384da064fa134f119cad Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 4 Oct 2013 23:48:30 -0700
Subject: [PATCH 0020/1866] Adds citation

---
 imap.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/imap.hpp b/imap.hpp
index 6de22b48..19239cdc 100644
--- a/imap.hpp
+++ b/imap.hpp
@@ -8,6 +8,7 @@
 
 namespace iter {
 
+    // modified from http://stackoverflow.com/questions/10766112/
     // implementation details, users never invoke these directly
     namespace detail
     {

From b66271f3d745f53c191831d36b0e2d479d2af031 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 4 Oct 2013 23:56:54 -0700
Subject: [PATCH 0021/1866] Adds tests for imap

---
 tests/testimap.cpp | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/tests/testimap.cpp b/tests/testimap.cpp
index a2b74f5b..6f4e6f1f 100644
--- a/tests/testimap.cpp
+++ b/tests/testimap.cpp
@@ -11,5 +11,16 @@ int main() {
     for (auto i : imap([] (int x, int y) { return x + y; }, vec1, vec2)) {
         std::cout << i << '\n';
     }
+
+    std::vector<int> vec3 = {100, 200, 300, 400, 500, 600};
+    for (auto i : imap([] (int a, int b, int c) { return a + b + c; }, 
+                vec1, vec2, vec3)) {
+        std::cout << i << '\n';
+    }
+
+    for (auto i : imap([] (int i) {return i * i; }, vec1)) {
+        std::cout << i << '\n';
+    }
+
     return 0;
 }

From d4298b55a1b00f613360480ef07d78860ab2178a Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 5 Oct 2013 00:03:47 -0700
Subject: [PATCH 0022/1866] changes to range

---
 range.hpp | 54 +++++++++++++++++++++++++++++++-----------------------
 1 file changed, 31 insertions(+), 23 deletions(-)

diff --git a/range.hpp b/range.hpp
index 265d65e1..0415c71c 100644
--- a/range.hpp
+++ b/range.hpp
@@ -22,16 +22,19 @@ namespace iter {
     // Thrown when step 0 occurs
     class RangeException : public std::exception {
         virtual const char *what() const throw() { 
-            return "range() step argument must not be zero";
+            return "Range() step argument must not be zero";
         }
     };
 
-    class range {
+    template <typename T>
+    class Range {
         private:
             const int start; 
             const int stop;
             const int step;
             void step_check() const throw(RangeException);
+
+
         public:
             class Iterator {
                 private:
@@ -45,9 +48,17 @@ namespace iter {
                     bool operator!=(const Iterator & other) const;
             };
 
-            range(int stop);
-            range(int start, int stop);
-            range(int start, int stop, int step);
+            //Range 
+            Range::Range(int stop) :
+                start(0),
+                stop(stop),
+                step(1)
+            { }
+            Range(int start, int stop);
+            Range(int start, int stop, int step);
+
+            Range() = delete;
+            Range(const Range &) = default;
 
             Iterator begin() const;
             Iterator end() const;
@@ -56,16 +67,16 @@ namespace iter {
     // definitions
 
     // Iterator subclass
-    range::Iterator::Iterator (int val, int step) :
+    Range::Iterator::Iterator (int val, int step) :
         value(val),
         step(step)
     { }
 
-    int range::Iterator::operator*() const {
+    int Range::Iterator::operator*() const {
         return this->value;
     }
 
-    range::Iterator & range::Iterator::operator++() {
+    Range::Iterator & Range::Iterator::operator++() {
         this->value += this->step;
         return *this;
     }
@@ -74,31 +85,25 @@ namespace iter {
     // because exact comparison with the end isn't good enough for the purposes
     // of this Iterator.  
     // There are two odd cases that need to be handled
-    // 1) The range is infinite, such as range (-1, 0, -1) which would go
+    // 1) The Range is infinite, such as Range (-1, 0, -1) which would go
     //    forever down toward infinitely (theoretically).  If this occurs,
-    //    the range will instead effectively be empty
-    // 2) (stop - start) % step != 0.  For example range(1, 10, 2).  The
+    //    the Range will instead effectively be empty
+    // 2) (stop - start) % step != 0.  For example Range(1, 10, 2).  The
     //    iterator will never be exactly equal to the stop value.
-    bool range::Iterator::operator!=(const range::Iterator & other) const {
+    bool Range::Iterator::operator!=(const Range::Iterator & other) const {
         return !(this->step > 0 && this->value >= other.value) 
             && !(this->step < 0 && this->value <= other.value);
     }
 
 
-    //Range 
-    range::range(int stop) :
-        start(0),
-        stop(stop),
-        step(1)
-    { }
 
-    range::range(int start, int stop) :
+    Range::Range(int start, int stop) :
         start(start),
         stop(stop),
         step(1)
     { }
 
-    range::range(int start, int stop, int step) :
+    Range::Range(int start, int stop, int step) :
         start(start),
         stop(stop),
         step(step)
@@ -106,20 +111,23 @@ namespace iter {
         this->step_check();
     }
 
-    void range::step_check() const throw(RangeException) {
+    void Range::step_check() const throw(RangeException) {
         if (step == 0) {
             throw RangeException();
         }
     }
 
-    range::Iterator range::begin() const {
+    Range::Iterator Range::begin() const {
         return Iterator(start, step);
     }
 
-    range::Iterator range::end() const { 
+    Range::Iterator Range::end() const { 
         return Iterator(stop, step);
     }
 
 }
 
+template <typename T>
+Range<t> range
+
 #endif //ifndef __RANGE__H__

From aaea6b8658284b6894903c32ed58300715bc84e7 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 5 Oct 2013 00:31:01 -0700
Subject: [PATCH 0023/1866] Templates range

Templates range so it works with whatever the user wants.
range(0.0, 10.0, 0.5) for example.
---
 range.hpp           | 149 ++++++++++++++++++++++----------------------
 tests/testrange.cpp |   5 ++
 2 files changed, 78 insertions(+), 76 deletions(-)

diff --git a/range.hpp b/range.hpp
index 0415c71c..2ccfb1e1 100644
--- a/range.hpp
+++ b/range.hpp
@@ -29,105 +29,102 @@ namespace iter {
     template <typename T>
     class Range {
         private:
-            const int start; 
-            const int stop;
-            const int step;
-            void step_check() const throw(RangeException);
+            const T start; 
+            const T stop;
+            const T step;
+            void step_check() const throw(RangeException) {
+                if (step == 0) {
+                    throw RangeException();
+                }
+            }
 
 
         public:
             class Iterator {
                 private:
-                    int value;
-                    const int step;
+                    T value;
+                    const T step;
                 public:
-                    Iterator (int val, int step);
-
-                    int operator*() const;
-                    Iterator & operator++();
-                    bool operator!=(const Iterator & other) const;
+                    Iterator(T val, T step) :
+                        value(val),
+                        step(step)
+                    { }
+
+                    T operator*() const {
+                        return this->value;
+                    }
+
+                    Iterator & operator++() {
+                        this->value += this->step;
+                        return *this;
+                    }
+
+                    // This operator would more accurately read as "in bounds"
+                    // or "incomplete" because exact comparison with the end
+                    // isn't good enough for the purposes of this Iterator.
+                    // There are two odd cases that need to be handled
+                    //
+                    // 1) The Range is infinite, such as
+                    // Range (-1, 0, -1) which would go    forever down toward
+                    // infinitely (theoretically).  If this occurs, the Range
+                    // will instead effectively be empty
+                    //
+                    // 2) (stop - start) % step != 0.  For
+                    // example Range(1, 10, 2).  The     iterator will never be
+                    // exactly equal to the stop value.
+                    bool operator!=(const Range::Iterator & other) const {
+                        return !(this->step > 0 && this->value >= other.value) 
+                            && !(this->step < 0 && this->value <= other.value);
+                    }
             };
 
-            //Range 
-            Range::Range(int stop) :
+            Range() = delete;
+            Range(const Range &) = default;
+            Range(T stop) :
                 start(0),
                 stop(stop),
                 step(1)
             { }
-            Range(int start, int stop);
-            Range(int start, int stop, int step);
 
-            Range() = delete;
-            Range(const Range &) = default;
+            Range(T start, T stop) :
+                start(start),
+                stop(stop),
+                step(1)
+            { }
 
-            Iterator begin() const;
-            Iterator end() const;
+            Range(T start, T stop, T step) :
+                start(start),
+                stop(stop),
+                step(step)
+            {
+                this->step_check();
+            }
+
+            Iterator begin() const {
+                return Iterator(start, step);
+            }
+
+            Iterator end() const { 
+                return Iterator(stop, step);
+            }
     };
 
-    // definitions
-
-    // Iterator subclass
-    Range::Iterator::Iterator (int val, int step) :
-        value(val),
-        step(step)
-    { }
-
-    int Range::Iterator::operator*() const {
-        return this->value;
-    }
-
-    Range::Iterator & Range::Iterator::operator++() {
-        this->value += this->step;
-        return *this;
-    }
-
-    // This operator would more accurately read as "in bounds" or "incomplete"
-    // because exact comparison with the end isn't good enough for the purposes
-    // of this Iterator.  
-    // There are two odd cases that need to be handled
-    // 1) The Range is infinite, such as Range (-1, 0, -1) which would go
-    //    forever down toward infinitely (theoretically).  If this occurs,
-    //    the Range will instead effectively be empty
-    // 2) (stop - start) % step != 0.  For example Range(1, 10, 2).  The
-    //    iterator will never be exactly equal to the stop value.
-    bool Range::Iterator::operator!=(const Range::Iterator & other) const {
-        return !(this->step > 0 && this->value >= other.value) 
-            && !(this->step < 0 && this->value <= other.value);
-    }
-
 
 
-    Range::Range(int start, int stop) :
-        start(start),
-        stop(stop),
-        step(1)
-    { }
-
-    Range::Range(int start, int stop, int step) :
-        start(start),
-        stop(stop),
-        step(step)
-    {
-        this->step_check();
-    }
-
-    void Range::step_check() const throw(RangeException) {
-        if (step == 0) {
-            throw RangeException();
-        }
+    template <typename T>
+    Range<T> range(T stop) {
+        return Range<T>(stop);
     }
 
-    Range::Iterator Range::begin() const {
-        return Iterator(start, step);
+    template <typename T>
+    Range<T> range(T start, T stop) {
+        return Range<T>(start, stop);
     }
 
-    Range::Iterator Range::end() const { 
-        return Iterator(stop, step);
+    template <typename T>
+    Range<T> range(T start, T stop, T step) {
+        return Range<T>(start, stop, step);
     }
-
 }
 
-template <typename T>
-Range<t> range
-
 #endif //ifndef __RANGE__H__
diff --git a/tests/testrange.cpp b/tests/testrange.cpp
index 158b3d14..5fa2a75e 100644
--- a/tests/testrange.cpp
+++ b/tests/testrange.cpp
@@ -34,6 +34,11 @@ int main()
         std::cout << i << std::endl;
     }
     
+    std::cout << "Tests with different types" << std::endl;
+    for(auto i : range(0.0, 10.0, 0.5)) {
+        std::cout << i << std::endl;
+    }
+
     // invalid ranges:
     std::cout << "Should not print anything after this line until exception\n";
     for (auto i : range(-10, 0, -1)) {

From ae5a92776808a41648f72257ac488b264cab30b4 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 5 Oct 2013 01:53:20 -0700
Subject: [PATCH 0024/1866] Adds full SO citation to imap

---
 imap.hpp | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/imap.hpp b/imap.hpp
index 19239cdc..5e156ff3 100644
--- a/imap.hpp
+++ b/imap.hpp
@@ -8,10 +8,13 @@
 
 namespace iter {
 
+    // Everything in detail namespace 
     // modified from http://stackoverflow.com/questions/10766112/
-    // implementation details, users never invoke these directly
+    // Question by Thomas http://stackoverflow.com/users/115355/thomas
+    // Answer by Kerrek SB http://stackoverflow.com/users/596781/kerrek-sb
     namespace detail
     {
+        // implementation details, users never invoke these directly
         template <typename F, typename Tuple, bool Done, int Total, int... N>
         struct call_impl
         {

From d6c23a1af8113528fcef26f6c3d199530e670201 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 5 Oct 2013 02:07:28 -0700
Subject: [PATCH 0025/1866] Makes range ctors private and range()s friends

---
 range.hpp | 56 ++++++++++++++++++++++++++++++++++---------------------
 1 file changed, 35 insertions(+), 21 deletions(-)

diff --git a/range.hpp b/range.hpp
index 2ccfb1e1..edd48505 100644
--- a/range.hpp
+++ b/range.hpp
@@ -26,8 +26,22 @@ namespace iter {
         }
     };
 
+    //Forward declarations of Enumerable and enumerate
+    template <typename T>
+    class Range;
+
+    template <typename T>
+    Range<T> range(T);
+    template <typename T>
+    Range<T> range(T, T);
+    template <typename T>
+    Range<T> range(T, T, T);
+
     template <typename T>
     class Range {
+        friend Range range<T>(T);
+        friend Range range<T>(T, T);
+        friend Range range<T>(T, T, T);
         private:
             const T start; 
             const T stop;
@@ -38,8 +52,29 @@ namespace iter {
                 }
             }
 
+            Range(T stop) :
+                start(0),
+                stop(stop),
+                step(1)
+            { }
+
+            Range(T start, T stop) :
+                start(start),
+                stop(stop),
+                step(1)
+            { }
+
+            Range(T start, T stop, T step) :
+                start(start),
+                stop(stop),
+                step(step)
+            {
+                this->step_check();
+            }
 
         public:
+            Range() = delete;
+            Range(const Range &) = default;
             class Iterator {
                 private:
                     T value;
@@ -78,27 +113,6 @@ namespace iter {
                     }
             };
 
-            Range() = delete;
-            Range(const Range &) = default;
-            Range(T stop) :
-                start(0),
-                stop(stop),
-                step(1)
-            { }
-
-            Range(T start, T stop) :
-                start(start),
-                stop(stop),
-                step(1)
-            { }
-
-            Range(T start, T stop, T step) :
-                start(start),
-                stop(stop),
-                step(step)
-            {
-                this->step_check();
-            }
 
             Iterator begin() const {
                 return Iterator(start, step);

From eabedcac6f58314698a836ba2e87fcc73facd03f Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 5 Oct 2013 02:08:17 -0700
Subject: [PATCH 0026/1866] Adds count

---
 count.hpp | 35 +++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 count.hpp

diff --git a/count.hpp b/count.hpp
new file mode 100644
index 00000000..15119e8b
--- /dev/null
+++ b/count.hpp
@@ -0,0 +1,35 @@
+#ifndef COUNT__H__
+#define COUNT__H__
+
+#include "range.hpp"
+
+#include <limits>
+
+namespace iter {
+
+    namespace {
+        typedef long DefaultRangeType;
+    }
+
+    Range<DefaultRangeType> count() {
+        return range(DefaultRangeType(0),
+                std::numeric_limits<DefaultRangeType>::max());
+    }
+
+    template <typename T>
+    Range<T> count(T start, T step) {
+        // if step is < 0, set the stop to numeric min, otherwise numeric max
+        T stop = step < T(0) ? std::numeric_limits<T>::min() :
+                            std::numeric_limits<T>::max();
+        return range(start, stop, step);
+    }
+
+    template <typename T>
+    Range<T> count(T start) {
+        return range(start, T(1));
+    }
+}
+
+
+#endif //define COUNT__H__
+

From 70b84291b98cc6c32963c18444e5f92965cc2d58 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 5 Oct 2013 02:08:33 -0700
Subject: [PATCH 0027/1866] Adds testcount

---
 tests/testcount.cpp | 38 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)
 create mode 100644 tests/testcount.cpp

diff --git a/tests/testcount.cpp b/tests/testcount.cpp
new file mode 100644
index 00000000..946d6841
--- /dev/null
+++ b/tests/testcount.cpp
@@ -0,0 +1,38 @@
+#include <count.hpp>
+
+#include <iostream>
+
+using iter::count;
+
+int main() {
+    for (auto i : count()) {
+        std::cout << i << '\n';
+        if (i == 100) {
+            break;
+        }
+    }
+
+    for (auto i : count(5.0, 0.5)){
+        std::cout << i << '\n';
+        if (i > 100) {
+            break;
+        }
+    }
+
+    for (auto i : count(0, -1)) {
+        std::cout << i << '\n';
+        if (i < -100) {
+            break;
+        }
+    }
+
+    for (auto i : count()) {
+        std::cout << i << '\n';
+        if (i > 10000) {
+            break;
+        }
+    }
+
+
+    return 0;
+}

From c160d7d27f1c6c61e49e9d02d6f651c796489948 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 5 Oct 2013 02:09:27 -0700
Subject: [PATCH 0028/1866] Adds testcount to SConstruct

---
 tests/SConstruct | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tests/SConstruct b/tests/SConstruct
index 06332784..e8fbd4e8 100644
--- a/tests/SConstruct
+++ b/tests/SConstruct
@@ -18,6 +18,7 @@ progs = Split( '''
 		powerset
         moving_section
         imap
+        count
         ''')
 
 cxx_flags = '-Wall -Wextra -pedantic -std=c++11'

From 41bb4685e315eb8dfac035a8f4e4b99fb6d847ec Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 5 Oct 2013 02:10:14 -0700
Subject: [PATCH 0029/1866] Adds testimap to Makefile

---
 tests/Makefile | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tests/Makefile b/tests/Makefile
index 7fadaf98..c3d0d83f 100644
--- a/tests/Makefile
+++ b/tests/Makefile
@@ -31,7 +31,8 @@ TESTS = \
 		testcombinations_with_replacement \
 		testcombinations \
 		testpowerset \
-		testmoving_section
+		testmoving_section \
+		testimap 
 
 all: $(TESTS)
 

From f95bb71812cd2a3e66bda2869f6e3c956b3db107 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 5 Oct 2013 02:10:37 -0700
Subject: [PATCH 0030/1866] Adds testcount to Makefile

---
 tests/Makefile | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tests/Makefile b/tests/Makefile
index c3d0d83f..209a3d2b 100644
--- a/tests/Makefile
+++ b/tests/Makefile
@@ -32,7 +32,8 @@ TESTS = \
 		testcombinations \
 		testpowerset \
 		testmoving_section \
-		testimap 
+		testimap \
+		testcount
 
 all: $(TESTS)
 

From 094aff499a1998206edf2d30baf3518170fccf96 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 5 Oct 2013 02:26:26 -0700
Subject: [PATCH 0031/1866] adds the rest of the tests to testimap

---
 tests/testimap.cpp | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/tests/testimap.cpp b/tests/testimap.cpp
index a2b74f5b..6f4e6f1f 100644
--- a/tests/testimap.cpp
+++ b/tests/testimap.cpp
@@ -11,5 +11,16 @@ int main() {
     for (auto i : imap([] (int x, int y) { return x + y; }, vec1, vec2)) {
         std::cout << i << '\n';
     }
+
+    std::vector<int> vec3 = {100, 200, 300, 400, 500, 600};
+    for (auto i : imap([] (int a, int b, int c) { return a + b + c; }, 
+                vec1, vec2, vec3)) {
+        std::cout << i << '\n';
+    }
+
+    for (auto i : imap([] (int i) {return i * i; }, vec1)) {
+        std::cout << i << '\n';
+    }
+
     return 0;
 }

From 58b47b9216542276aa5837b15a3585c8bbe7fb1d Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Sat, 5 Oct 2013 11:28:14 -0400
Subject: [PATCH 0032/1866] Got rid of two range specialization for zip iter

---
 tests/.gitignore |  1 +
 zip.hpp          | 31 ++++++++++++++++++++++++-------
 2 files changed, 25 insertions(+), 7 deletions(-)

diff --git a/tests/.gitignore b/tests/.gitignore
index 5db5fc20..8bc90b6e 100644
--- a/tests/.gitignore
+++ b/tests/.gitignore
@@ -18,3 +18,4 @@ testtakewhile
 testcombinations
 testpowerset
 testmoving_section
+testimap
diff --git a/zip.hpp b/zip.hpp
index a9286e97..927f480d 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -14,13 +14,30 @@ namespace iter {
             auto begin = zip_iter<decltype(containers.begin())...>(containers.begin()...);
             auto end = zip_iter<decltype(containers.end())...>(containers.end()...);
             return iterator_range<decltype(begin)>(begin,end);
-        }   
-    /*template <int N,typename Tuple>
-        auto zip_get(Tuple & t) ->decltype(*std::get<N>(t))&
-        {
-            return *std::get<N>(t);
         }
-        */
+    template <typename Iterator>
+        struct zip_iter<Iterator> {
+
+        private:
+            Iterator iter;
+
+        public:
+            using Elem_t = decltype(*iter);
+            zip_iter(const Iterator & i) :
+                iter(i){ }
+
+            auto operator*() -> decltype(std::tie(*iter))
+            {
+                return std::tie(*iter);
+            }
+            zip_iter & operator++() {
+                ++iter;
+                return *this;
+            }
+            bool operator!=(const zip_iter & rhs) const {
+                return (this->iter != rhs.iter);
+            }
+        };  /* 
     template <typename First, typename Second>
         struct zip_iter<First,Second> {
 
@@ -46,7 +63,7 @@ namespace iter {
             bool operator!=(const zip_iter & rhs) const {
                 return (this->iter1 != rhs.iter1) && (this->iter2 != rhs.iter2);
             }
-        };
+        };*/
     template <typename First, typename ... Rest>
         struct zip_iter<First,Rest...> {
 

From 97a3115930cba020b6c3d020b11b347073a876ad Mon Sep 17 00:00:00 2001
From: ryanhaining <rhainin1@binghamton.edu>
Date: Sat, 5 Oct 2013 15:11:33 -0700
Subject: [PATCH 0033/1866] Adds filterfalse to TOC

---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index b4ba422e..f0d75640 100644
--- a/README.md
+++ b/README.md
@@ -7,6 +7,7 @@ library.
 ##### Table of Contents
 [range](#range)<br />
 [filter](#filter)<br />
+[filterfalse](#filterfalse)<br />
 [takewhile](#takewhile)<br />
 [dropwhile](#dropwhile)<br />
 [enumerate](#enumerate)<br />

From 8f775dfbb9405bd7734c1cd2fd55e4c758bac4f4 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 5 Oct 2013 17:07:41 -0700
Subject: [PATCH 0034/1866] Adds testfilterfalse

---
 tests/testfilterfalse.cpp | 46 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 46 insertions(+)
 create mode 100644 tests/testfilterfalse.cpp

diff --git a/tests/testfilterfalse.cpp b/tests/testfilterfalse.cpp
new file mode 100644
index 00000000..2c1cd3f3
--- /dev/null
+++ b/tests/testfilterfalse.cpp
@@ -0,0 +1,46 @@
+#include <filterfalse.hpp>
+
+#include <vector>
+#include <iostream>
+
+using iter::filterfalse;
+
+bool greater_than_four(int i) {
+    return i > 4;
+}
+
+class LessThanValue {
+    private:
+        int compare_val;
+
+    public:
+        LessThanValue() = delete;
+        LessThanValue(int v) : compare_val(v) { }
+        
+        bool operator() (int i) {
+            return i < this->compare_val;
+        }
+};
+
+
+int main() {
+    std::vector<int> vec{1, 5, 6, 7, 2, 3, 8, 3, 2, 1};
+
+    std::cout << "Greater than 4 (function pointer)\n";
+    for (auto i : filterfalse(greater_than_four, vec)) {
+        std::cout << i << '\n';
+    }
+
+    std::cout << "Less than 4 (lambda)\n";
+    for (auto i : filterfalse([] (const int i) { return i < 4; }, vec)) {
+        std::cout << i << '\n';
+    }
+
+    LessThanValue lv(4);
+    std::cout << "Less than 4 (callable object)\n";
+    for (auto i : filterfalse(lv, vec)) {
+        std::cout << i << '\n';
+    }
+
+    return 0;
+}

From 961c4aead96fc89c181f95a13880719a5d5ce804 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 5 Oct 2013 17:08:19 -0700
Subject: [PATCH 0035/1866] Adds testfilterfalse to SConstruct and Makefile

---
 tests/Makefile   | 3 ++-
 tests/SConstruct | 1 +
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/tests/Makefile b/tests/Makefile
index 209a3d2b..fb57ac31 100644
--- a/tests/Makefile
+++ b/tests/Makefile
@@ -33,7 +33,8 @@ TESTS = \
 		testpowerset \
 		testmoving_section \
 		testimap \
-		testcount
+		testcount \
+		testfilterfalse
 
 all: $(TESTS)
 
diff --git a/tests/SConstruct b/tests/SConstruct
index e8fbd4e8..61ac24f4 100644
--- a/tests/SConstruct
+++ b/tests/SConstruct
@@ -19,6 +19,7 @@ progs = Split( '''
         moving_section
         imap
         count
+        filterfalse
         ''')
 
 cxx_flags = '-Wall -Wextra -pedantic -std=c++11'

From 40604998861ff8d64a2dcece3cbff6c2c657932e Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 5 Oct 2013 17:08:51 -0700
Subject: [PATCH 0036/1866] Adds testfilterfalse to .gitignore

---
 tests/.gitignore | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tests/.gitignore b/tests/.gitignore
index 8bc90b6e..ab2fff9a 100644
--- a/tests/.gitignore
+++ b/tests/.gitignore
@@ -19,3 +19,4 @@ testcombinations
 testpowerset
 testmoving_section
 testimap
+testfilterfalse

From 266acb4d2c00ca01f38af161617c6fbab2f1ed9a Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 5 Oct 2013 17:09:07 -0700
Subject: [PATCH 0037/1866] Adds filterfalse.hpp

---
 filterfalse.hpp | 91 +++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 91 insertions(+)
 create mode 100644 filterfalse.hpp

diff --git a/filterfalse.hpp b/filterfalse.hpp
new file mode 100644
index 00000000..578b57c2
--- /dev/null
+++ b/filterfalse.hpp
@@ -0,0 +1,91 @@
+#ifndef FILTERFALSE__H__
+#define FILTERFALSE__H__
+
+#include "filter.hpp"
+
+namespace iter {
+
+    //Forward declarations of FilterFalse and filterfalse
+    template <typename FilterFunc, typename Container>
+    class FilterFalse;
+
+    template <typename FilterFunc, typename Container>
+    FilterFalse<FilterFunc, Container> filterfalse(FilterFunc, Container &);
+
+    template <typename FilterFunc, typename Container>
+    class FilterFalse : public Filter<FilterFunc, Container> {
+        // The filterfalse function is the only thing allowed to
+        // create a FilterFalse
+        friend FilterFalse filterfalse<FilterFunc, Container>(
+                FilterFunc, Container &);
+        using Base = Filter<FilterFunc, Container>;
+
+        public:
+            using Filter<FilterFunc, Container>::Filter;
+
+            class Iterator {
+                protected:
+                    typename Base::contained_iter_type sub_iter;
+                    const typename Base::contained_iter_type sub_end;
+                    FilterFunc filter_func;
+
+                    // skip every element that is true ender the predicate
+                    void skip_passes() { 
+                        while (this->sub_iter != this->sub_end
+                                && this->filter_func(*this->sub_iter)) {
+                            ++this->sub_iter;
+                        }
+                    }
+
+                public:
+                    Iterator (typename Base::contained_iter_type iter,
+                            typename Base::contained_iter_type end,
+                            FilterFunc filter_func) :
+                        sub_iter(iter),
+                        sub_end(end),
+                        filter_func(filter_func)
+                    { 
+                        this->skip_passes();
+                    } 
+
+                    typename Base::contained_iter_ret operator*() const {
+                        return *this->sub_iter;
+                    }
+
+                    Iterator & operator++() { 
+                        ++this->sub_iter;
+                        this->skip_passes();
+                        return *this;
+                    }
+
+                    bool operator!=(const Iterator & other) const {
+                        return this->sub_iter != other.sub_iter;
+                    }
+            };
+
+            Iterator begin() const {
+                return Iterator(
+                        this->container.begin(),
+                        this->container.end(),
+                        this->filter_func);
+            }
+
+            Iterator end() const {
+                return Iterator(
+                        this->container.end(),
+                        this->container.end(),
+                        this->filter_func);
+            }
+    };
+
+
+    template <typename FilterFunc, typename Container>
+    FilterFalse<FilterFunc, Container> filterfalse(FilterFunc filter_func,
+            Container & container) {
+        return FilterFalse<FilterFunc, Container>(filter_func, container);
+    }
+}
+
+
+
+#endif //ifndef FILTERFALSE__H__

From 5f0c29272faa6906b96a665bcf878bae3401a346 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 5 Oct 2013 17:18:42 -0700
Subject: [PATCH 0038/1866] Adds filterfalse to README

---
 README.md | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index ca6752c2..b4ba422e 100644
--- a/README.md
+++ b/README.md
@@ -82,7 +82,20 @@ Called as `filter(predicate, iterable)`.  The predicate can be any callable.
 
 Prints values greater than 4:  5 6 7 8
 ```c++
-vector<int> vec{1, 5, 6, 7, 3, 2, 8, 3, 2, 1};
+vector<int> vec{1, 5, 4, 6, 7, 3, 2, 8, 3, 2, 1};
+for (auto i : filter([] (int i) { return i > 4; }, vec)) {
+    cout << i <<'\n';
+}
+
+```
+
+filterfalse
+-----------
+Similar to filter, but only prints values that are false under the predicate.
+
+Prints values not greater than 4: 1 4 3 2 3 2 1 
+```c++
+vector<int> vec{1, 5, 4, 6, 7, 3, 2, 8, 3, 2, 1};
 for (auto i : filter([] (int i) { return i > 4; }, vec)) {
     cout << i <<'\n';
 }

From 7df0dfcb03149dce493ebefbb9aecc09fee1787d Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 5 Oct 2013 17:19:15 -0700
Subject: [PATCH 0039/1866] Changes filter.hpp to be subclassed

---
 filter.hpp | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/filter.hpp b/filter.hpp
index 8671a73a..8e442e2b 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -18,16 +18,16 @@ namespace iter {
         friend Filter filter<FilterFunc, Container>(FilterFunc, Container &);
 
         
-        // Type of the Container::Iterator, but since the name of that 
-        // iterator can be anything, we have to grab it with this
-        using contained_iter_type =
-            decltype(std::declval<Container>().begin());
+        protected:
+            // Type of the Container::Iterator, but since the name of that 
+            // iterator can be anything, we have to grab it with this
+            using contained_iter_type =
+                decltype(std::declval<Container>().begin());
 
-        // The type returned when dereferencing the Container::Iterator
-        using contained_iter_ret =
-            decltype(std::declval<contained_iter_type>().operator*());
+            // The type returned when dereferencing the Container::Iterator
+            using contained_iter_ret =
+                decltype(std::declval<contained_iter_type>().operator*());
 
-        private:
             Container & container;
             FilterFunc filter_func;
             
@@ -42,7 +42,7 @@ namespace iter {
 
         public:
             class Iterator {
-                private:
+                protected:
                     contained_iter_type sub_iter;
                     const contained_iter_type sub_end;
                     FilterFunc filter_func;

From ac6e4ea445fa91c582cd4c7d4db6400a55c2b97b Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Sat, 5 Oct 2013 23:46:47 -0400
Subject: [PATCH 0040/1866] Did grouper from python recipes

---
 grouper.hpp           | 69 +++++++++++++++++++++++++++++++++++++++++++
 tests/.gitignore      |  2 ++
 tests/Makefile        |  3 +-
 tests/testgrouper.cpp | 15 ++++++++++
 4 files changed, 88 insertions(+), 1 deletion(-)
 create mode 100644 grouper.hpp
 create mode 100644 tests/testgrouper.cpp

diff --git a/grouper.hpp b/grouper.hpp
new file mode 100644
index 00000000..879a419d
--- /dev/null
+++ b/grouper.hpp
@@ -0,0 +1,69 @@
+#ifndef GROUPER_HPP 
+#define GROUPER_HPP 
+
+#include "iterator_range.hpp"
+#include <vector>
+#include <algorithm>
+#include <functional>
+#include <type_traits>
+
+namespace iter {
+    template <typename Container>
+        struct grouper_iter;
+    template <typename Container>
+        iterator_range<grouper_iter<Container>>
+        grouper(Container & container, size_t s) {
+            auto begin = grouper_iter<Container>(container,s);
+            auto end = grouper_iter<Container>(container);
+            return iterator_range<grouper_iter<Container>>(begin,end);
+        }
+
+    template <typename Container>
+        struct grouper_iter {
+            Container & container;
+            using Iterator = decltype(container.begin());
+            std::vector<Iterator> group;
+            size_t group_size = 0;
+            bool not_done = true;
+            grouper_iter(Container & c, size_t s) :
+                container(c),group_size(s) 
+            {
+                for (size_t i = 0; i < group_size; ++i) 
+                    group.push_back(container.begin()+i);
+            }
+            //seems like constructor is same as moving_section_iter
+            grouper_iter(Container & c) : container(c)
+            //creates the end iterator
+            {
+                group.push_back(container.end());
+            }
+
+            grouper_iter & operator++() {
+                for (auto & iter : group) {
+                    iter += group_size;
+                }
+                return *this;
+            }
+            bool operator!=(const grouper_iter &) {
+                return not_done;
+            }
+            using Deref_type = std::vector<std::reference_wrapper<typename std::remove_reference<decltype(*std::declval<Iterator>())>::type>>;
+            Deref_type operator*()
+            {
+                Deref_type vec;
+                for (auto i : group) {
+                    if(i == container.end()) {
+                        not_done = false;
+                        break;
+                    } 
+                    //if the group is at the end the vector will be smaller 
+                    else { 
+                        vec.push_back(*i);
+                    }
+                }
+                return vec;
+            }
+        };
+}
+
+#endif //MOVING_SECTION_HPP
diff --git a/tests/.gitignore b/tests/.gitignore
index ab2fff9a..38e72819 100644
--- a/tests/.gitignore
+++ b/tests/.gitignore
@@ -20,3 +20,5 @@ testpowerset
 testmoving_section
 testimap
 testfilterfalse
+testcount
+testgrouper
diff --git a/tests/Makefile b/tests/Makefile
index fb57ac31..58640431 100644
--- a/tests/Makefile
+++ b/tests/Makefile
@@ -34,7 +34,8 @@ TESTS = \
 		testmoving_section \
 		testimap \
 		testcount \
-		testfilterfalse
+		testfilterfalse \
+		testgrouper
 
 all: $(TESTS)
 
diff --git a/tests/testgrouper.cpp b/tests/testgrouper.cpp
new file mode 100644
index 00000000..b951b158
--- /dev/null
+++ b/tests/testgrouper.cpp
@@ -0,0 +1,15 @@
+#include "grouper.hpp"
+#include <iostream>
+#include <vector>
+using iter::grouper;
+int main() {
+    std::vector<int> v = {1,2,3,4,5,6,7,8,9}; 
+    for (auto sec : grouper(v,4)) {
+        for (auto i : sec) {
+            std::cout << i << " ";
+            //i.get() = 90;
+        }
+        std::cout << std::endl;
+    }
+    return 0;
+}

From 9e3b3a228d2d22b2b49d0980275ebad70b2e7bcf Mon Sep 17 00:00:00 2001
From: Eitan Adler <lists@eitanadler.com>
Date: Sun, 6 Oct 2013 02:00:36 -0400
Subject: [PATCH 0041/1866] Fix sconstruct:

'c++' is the C++ compiler.  There is no reason to assume either clang++
or g++.

/usr/local/include must be included on modern unixes to use boost.
---
 tests/SConstruct | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/SConstruct b/tests/SConstruct
index 4720ceae..5c2f74ba 100644
--- a/tests/SConstruct
+++ b/tests/SConstruct
@@ -24,9 +24,9 @@ progs = Split( '''
         filterfalse
         ''')
 
-cxx = 'clang++'
-cxx_flags = ' -Wall -Wextra -pedantic -std=c++11 '
-ldflags = ''
+cxx = 'c++'
+cxx_flags = ' -Wall -Wextra -pedantic -std=c++11 -I/usr/local/include'
+ldflags = ' -L/usr/local/lib'
 
 # if on MAC, needs the linker flag for -stdlib=libc++
 if platform.system() == 'Darwin':

From d630c1847958ba0704f97781572884eb8055d48a Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 6 Oct 2013 00:43:31 -0700
Subject: [PATCH 0042/1866] Adds check for mac to SConstruct

---
 tests/SConstruct | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/tests/SConstruct b/tests/SConstruct
index 61ac24f4..d6e2f747 100644
--- a/tests/SConstruct
+++ b/tests/SConstruct
@@ -1,3 +1,5 @@
+import platform
+
 progs = Split( '''
 		cycle 
 		enumerate 
@@ -22,10 +24,11 @@ progs = Split( '''
         filterfalse
         ''')
 
-cxx_flags = '-Wall -Wextra -pedantic -std=c++11'
+cxx_flags = ' -Wall -Wextra -pedantic -std=c++11 '
+
+if platform.system() == 'Darwin':
+    cxx_flags += ' -stdlib=libc++ '
 
 for p in progs:
-    Program(target='test{0}'.format(p), source='test{0}.cpp'.format(p),
+    Program(source='test{0}.cpp'.format(p),
             CXXFLAGS=cxx_flags, CPPPATH='..', CXX='clang++')
-
-

From 03393170057da4dd97f3b3c11e949e08c75a5cbc Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 6 Oct 2013 00:44:16 -0700
Subject: [PATCH 0043/1866] Removes Makefile.  All scons now

---
 tests/Makefile | 42 ------------------------------------------
 1 file changed, 42 deletions(-)
 delete mode 100644 tests/Makefile

diff --git a/tests/Makefile b/tests/Makefile
deleted file mode 100644
index fb57ac31..00000000
--- a/tests/Makefile
+++ /dev/null
@@ -1,42 +0,0 @@
-CXX := clang++
-CXXFLAGS := -Wall -Wextra -pedantic -std=c++11
-
-KERNEL := $(shell uname -s)
-ifeq ($(KERNEL),Darwin)
-ifeq ($(CXX),clang++)
-	CXXFLAGS += -stdlib=libc++
-endif
-endif
-
-LINK.o = $(LINK.cc)
-
-CPPFLAGS := -I".."
-
-TESTS = \
-		testchain \
-		testcycle \
-		testenumerate \
-		testrange \
-		testzip \
-		testslice \
-		testreverse \
-		testfilter \
-		testrepeat \
-		testtakewhile \
-		testdropwhile \
-		testzip_longest \
-		testproduct \
-		testpermutations \
-		testcompress \
-		testcombinations_with_replacement \
-		testcombinations \
-		testpowerset \
-		testmoving_section \
-		testimap \
-		testcount \
-		testfilterfalse
-
-all: $(TESTS)
-
-clean:
-	rm -f *.o $(TESTS)

From 2385f8baf734c65b4a1bd0e6b5e507a1378a748b Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 6 Oct 2013 01:05:13 -0700
Subject: [PATCH 0044/1866] Fixes mac check to use the linker flags

I'm still fairly new to scons though so I'm sure this can be improved.
---
 tests/SConstruct | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/tests/SConstruct b/tests/SConstruct
index d6e2f747..197e4a97 100644
--- a/tests/SConstruct
+++ b/tests/SConstruct
@@ -24,11 +24,13 @@ progs = Split( '''
         filterfalse
         ''')
 
+cxx = 'clang++'
 cxx_flags = ' -Wall -Wextra -pedantic -std=c++11 '
 
-if platform.system() == 'Darwin':
-    cxx_flags += ' -stdlib=libc++ '
+# if on MAC, needs the linker flag for -stdlib=libc++
+ldflags = '-stdlib=libc++' if platform.system() == 'Darwin' else ''
 
 for p in progs:
     Program(source='test{0}.cpp'.format(p),
-            CXXFLAGS=cxx_flags, CPPPATH='..', CXX='clang++')
+            CXXFLAGS=cxx_flags, CPPPATH='..', CXX=cxx,
+            LINKFLAGS=ldflags)

From 28d3f1d190daaecb80306dc5438c6d72e93bbf8e Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 6 Oct 2013 01:33:27 -0700
Subject: [PATCH 0045/1866] Fixes SConstruct mac check (again)

CXXFLAGS needs -stdlib=libc++ too.
---
 tests/SConstruct | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/tests/SConstruct b/tests/SConstruct
index 197e4a97..4720ceae 100644
--- a/tests/SConstruct
+++ b/tests/SConstruct
@@ -26,9 +26,12 @@ progs = Split( '''
 
 cxx = 'clang++'
 cxx_flags = ' -Wall -Wextra -pedantic -std=c++11 '
+ldflags = ''
 
 # if on MAC, needs the linker flag for -stdlib=libc++
-ldflags = '-stdlib=libc++' if platform.system() == 'Darwin' else ''
+if platform.system() == 'Darwin':
+    ldflags += ' -stdlib=libc++ '
+    cxx_flags += ' -stdlib=libc++ '
 
 for p in progs:
     Program(source='test{0}.cpp'.format(p),

From 4ac571d1ba24514a6af7ba092a6d6c05c2e90011 Mon Sep 17 00:00:00 2001
From: ryanhaining <rhainin1@binghamton.edu>
Date: Sun, 6 Oct 2013 09:57:13 -0700
Subject: [PATCH 0046/1866] Adds imap to README

---
 README.md | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/README.md b/README.md
index f0d75640..21d3cbc1 100644
--- a/README.md
+++ b/README.md
@@ -14,6 +14,7 @@ library.
 [cycle](#cycle)<br />
 [compress](#compress)<br />
 [zip](#zip)<br />
+[imap](#imap)<br />
 [chain](#chain)<br />
 [reverse](#reverse)<br />
 [slice](#slice)<br />
@@ -178,6 +179,37 @@ range instead of the shortest. because of that you have to return a
 to (`std::optional` when it is released, if ever)
 
 
+imap
+----
+
+Takes a function and one or more iterables.  The number of iterables must
+match the number of arguments to the function.  Applies the function to
+each element (or elements) in the iterable(s).  Terminates on the shortest
+sequence.
+
+Prints the squares of the numbers in vec: `1 4 9 16 25`
+```c++
+vector<int> vec{1, 2, 3, 4, 5};
+for (auto i : imap([] (int x) {return x * x;}, vec)) {
+    cout << i << '\n';
+}
+```
+
+With more than one sequence, the below adds corresponding elements from
+each vector together, printing `11 23 35 47 59 71`
+```c++
+vector<int> vec1{1, 3, 5, 7, 9, 11};
+vector<int> vec2{10, 20, 30, 40, 50, 60};
+for (auto i : imap([] (int x, int y) { return x + y; }, vec1, vec2)) {
+    cout << i << '\n';
+}
+```
+
+*Note*: The name `imap` is chosen to prevent confusion/collision with 
+`std::map`, and because it is more related to `itertools.imap` than
+the python builtin `map`.
+
+
 compress
 --------
 

From ef0bcf2ad302de7881c68d715b0df23d2f7e480c Mon Sep 17 00:00:00 2001
From: ryanhaining <rhainin1@binghamton.edu>
Date: Sun, 6 Oct 2013 10:08:33 -0700
Subject: [PATCH 0047/1866] Adds double range use case to README

---
 README.md | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/README.md b/README.md
index 21d3cbc1..d9d9ecdf 100644
--- a/README.md
+++ b/README.md
@@ -60,6 +60,16 @@ for (auto i : range(2, -3, -1)) {
 }
 ```
 
+In addition to normal integer range operations, doubles and
+other numeric types are supported through the template
+
+Prints: `5.0 5.5 6.0` ... `9.5`
+```c++
+for(auto i : range(5.0, 10.0, 0.5)) {
+    cout << i << '\n';
+}
+```
+
 enumerate
 ---------
 

From 9bd047b0591bc47c36c29c7913f66e8740204c45 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 6 Oct 2013 13:11:27 -0700
Subject: [PATCH 0048/1866] Adds `` tags around output in examples

---
 README.md | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/README.md b/README.md
index d9d9ecdf..176d87db 100644
--- a/README.md
+++ b/README.md
@@ -32,28 +32,28 @@ range
 Uses an underlying iterator to acheive the same effect of the python range
 function.  `range` can be used in three different ways:
 
-Only the stopping point is provided.  Prints 0 1 2 3 4 5 6 7 8 9
+Only the stopping point is provided.  Prints `0 1 2 3 4 5 6 7 8 9`
 ```c++
 for (auto i : range(10)) {
     cout << i << '\n';
 }
 ```
 
-The start and stop are both provided.  Prints 10 11 12 13 14
+The start and stop are both provided.  Prints `10 11 12 13 14`
 ```c++
 for (auto i : range(10, 15)) {
     cout << i << '\n';
 }
 ```
 
-The start, stop, and step are all provided.  Prints 20 22 24 26 28
+The start, stop, and step are all provided.  Prints `20 22 24 26 28`
 ```c++
 for (auto i : range(20, 30, 2)) {
     cout << i << '\n';
 }
 ```
 
-Negative values are allowed as well.  Prints 2 1 0 -1 -2
+Negative values are allowed as well.  Prints `2 1 0 -1 -2`
 ```c++
 for (auto i : range(2, -3, -1)) {
     cout << i << '\n';
@@ -92,7 +92,7 @@ filter
 Called as `filter(predicate, iterable)`.  The predicate can be any callable.
 `filter` will only yield values that are true under the predicate.
 
-Prints values greater than 4:  5 6 7 8
+Prints values greater than 4:  `5 6 7 8`
 ```c++
 vector<int> vec{1, 5, 4, 6, 7, 3, 2, 8, 3, 2, 1};
 for (auto i : filter([] (int i) { return i > 4; }, vec)) {
@@ -105,7 +105,7 @@ filterfalse
 -----------
 Similar to filter, but only prints values that are false under the predicate.
 
-Prints values not greater than 4: 1 4 3 2 3 2 1 
+Prints values not greater than 4: `1 4 3 2 3 2 1 `
 ```c++
 vector<int> vec{1, 5, 4, 6, 7, 3, 2, 8, 3, 2, 1};
 for (auto i : filter([] (int i) { return i > 4; }, vec)) {
@@ -119,7 +119,7 @@ takewhile
 Yields elements from an iterable until the first element that is false under
 the predicate is encountered.
 
-Prints 1 2 3 4.  (5 is false under the predicate)
+Prints `1 2 3 4`.  (5 is false under the predicate)
 ```c++
 vector<int> ivec{1, 2, 3, 4, 5, 6, 7, 6, 5, 4, 3, 2, 1};
 for (auto i : takewhile([] (int i) {return i < 5;}, ivec)) {
@@ -132,7 +132,7 @@ dropwhile
 Yields all elements after and including the first element that is false under
 the predicate.
 
-Prints 5 6 7 1 2
+Prints `5 6 7 1 2`
 ```c++
 vector<int> ivec{1, 2, 3, 4, 5, 6, 7, 1, 2};
 for (auto i : dropwhile([] (int i) {return i < 5;}, ivec)) {
@@ -146,7 +146,7 @@ cycle
 Repeatedly produce all values of an iterable.  The loop will be infinite, so a
 `break` is necessary to exit.
 
-Prints 1 2 3 repeatedly until `some_condition` is true
+Prints `1 2 3` repeatedly until `some_condition` is true
 ```c++
 vector<int> vec{1, 2, 3};
 for (auto i : cycle(vec)) {

From d604931a045b5e75588584388c0ad9f0ab5461d7 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 6 Oct 2013 13:12:31 -0700
Subject: [PATCH 0049/1866] Modifiies tests

---
 tests/testimap.cpp  | 5 +++++
 tests/testrange.cpp | 2 +-
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/tests/testimap.cpp b/tests/testimap.cpp
index 6f4e6f1f..32ded424 100644
--- a/tests/testimap.cpp
+++ b/tests/testimap.cpp
@@ -22,5 +22,10 @@ int main() {
         std::cout << i << '\n';
     }
 
+    std::vector<int> vec{1, 2, 3, 4, 5};
+    for (auto i : imap([] (int x) {return x * x;}, vec)) {
+        std::cout << i << '\n';
+    }
+
     return 0;
 }
diff --git a/tests/testrange.cpp b/tests/testrange.cpp
index 5fa2a75e..fd7a294f 100644
--- a/tests/testrange.cpp
+++ b/tests/testrange.cpp
@@ -35,7 +35,7 @@ int main()
     }
     
     std::cout << "Tests with different types" << std::endl;
-    for(auto i : range(0.0, 10.0, 0.5)) {
+    for(auto i : range(5.0, 10.0, 0.5)) {
         std::cout << i << std::endl;
     }
 

From 79205fad405d1bad1858b2c73808db018cd580b1 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 6 Oct 2013 13:13:31 -0700
Subject: [PATCH 0050/1866] Puts `` around compress output in REAME

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 176d87db..1ae99384 100644
--- a/README.md
+++ b/README.md
@@ -226,7 +226,7 @@ compress
 Yields only the values corresponding to true in the selectors iterable.
 Terminates on the shortest sequence.
 
-Prints 2 6
+Prints `2 6`
 ```c++
 vector<int> ivec{1, 2, 3, 4, 5, 6};
 vector<bool> bvec{false, true, false, false, false, true};

From e9b6a707761e3803993d57e79aa045384df41fcf Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Sun, 6 Oct 2013 22:38:43 -0400
Subject: [PATCH 0051/1866] fixed slight error in grouper if given an empty
 range

---
 grouper.hpp           |  5 +++++
 tests/.gitignore      |  1 +
 tests/SConstruct      |  1 +
 tests/testgrouper.cpp | 16 +++++++++++++++-
 4 files changed, 22 insertions(+), 1 deletion(-)

diff --git a/grouper.hpp b/grouper.hpp
index 879a419d..562d7b31 100644
--- a/grouper.hpp
+++ b/grouper.hpp
@@ -28,6 +28,11 @@ namespace iter {
             grouper_iter(Container & c, size_t s) :
                 container(c),group_size(s) 
             {
+                //if the group size is 0 or the container is empty produce nothing
+                if (group_size == 0 || !(container.begin() != container.end())) {
+                    not_done = false;
+                    return;
+                }
                 for (size_t i = 0; i < group_size; ++i) 
                     group.push_back(container.begin()+i);
             }
diff --git a/tests/.gitignore b/tests/.gitignore
index 38e72819..450ff7b2 100644
--- a/tests/.gitignore
+++ b/tests/.gitignore
@@ -22,3 +22,4 @@ testimap
 testfilterfalse
 testcount
 testgrouper
+.sconsign.dblite
diff --git a/tests/SConstruct b/tests/SConstruct
index 5c2f74ba..08eb17de 100644
--- a/tests/SConstruct
+++ b/tests/SConstruct
@@ -22,6 +22,7 @@ progs = Split( '''
         imap
         count
         filterfalse
+        grouper
         ''')
 
 cxx = 'c++'
diff --git a/tests/testgrouper.cpp b/tests/testgrouper.cpp
index b951b158..b98a1af5 100644
--- a/tests/testgrouper.cpp
+++ b/tests/testgrouper.cpp
@@ -3,13 +3,27 @@
 #include <vector>
 using iter::grouper;
 int main() {
-    std::vector<int> v = {1,2,3,4,5,6,7,8,9}; 
+    std::vector<int> v {1,2,3,4,5,6,7,8,9}; 
     for (auto sec : grouper(v,4)) {
+        for (auto i : sec) {
+            std::cout << i << " ";
+            i.get() *= 2;
+        }
+        std::cout << std::endl;
+    }
+    for (auto sec : grouper(v,3)) {
         for (auto i : sec) {
             std::cout << i << " ";
             //i.get() = 90;
         }
         std::cout << std::endl;
     }
+    std::vector<int> empty {};
+    for (auto sec : grouper(empty,3)) {
+        std::cout << "Shouldn't print\n";
+        for (auto i : sec) {
+            std::cout << i << " Shouldn't print\n";
+        }
+    }
     return 0;
 }

From 462ca9505e2fb29eada1cefc378ba513f7e51532 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 7 Oct 2013 01:57:53 -0700
Subject: [PATCH 0052/1866] Adds default case to filter

filter(iterable) filters out the items in iterable that themselves are
false
---
 filter.hpp           | 93 +++++++++++++++++++++++++++++++++++++++++++-
 tests/testfilter.cpp |  7 ++++
 2 files changed, 99 insertions(+), 1 deletion(-)

diff --git a/filter.hpp b/filter.hpp
index 8e442e2b..1a611bce 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -98,13 +98,104 @@ namespace iter {
 
     };
 
-    // Helper function to instantiate a Filter
+    // Helper function to instantiate a FilterDefault
     template <typename FilterFunc, typename Container>
     Filter<FilterFunc, Container> filter(
             FilterFunc filter_func, Container & container) {
         return Filter<FilterFunc, Container>(filter_func, container);
     }
 
+    //Forward declarations of FilterDefault and filter
+    template <typename Container>
+    class FilterDefault;
+
+    template <typename Container>
+    FilterDefault<Container> filter(Container &);
+
+    template <typename Container>
+    class FilterDefault {
+        // The filter function is the only thing allowed to create a FilterDefault
+        friend FilterDefault filter<Container>(Container &);
+
+        
+        protected:
+            // Type of the Container::Iterator, but since the name of that 
+            // iterator can be anything, we have to grab it with this
+            using contained_iter_type =
+                decltype(std::declval<Container>().begin());
+
+            // The type returned when dereferencing the Container::Iterator
+            using contained_iter_ret =
+                decltype(std::declval<contained_iter_type>().operator*());
+
+            Container & container;
+            
+            // Value constructor for use only in the filter function
+            FilterDefault(Container & container) :
+                container(container)
+            { }
+            FilterDefault () = delete;
+            FilterDefault & operator=(const FilterDefault &) = delete;
+            // Default copy constructor used
+
+        public:
+            class Iterator {
+                protected:
+                    contained_iter_type sub_iter;
+                    const contained_iter_type sub_end;
+
+                    // increment until the iterator points to is true on the 
+                    // predicate.  Called by constructor and operator++
+                    void skip_failures() { 
+                        while (this->sub_iter != this->sub_end
+                                && !(*this->sub_iter)) {
+                            ++this->sub_iter;
+                        }
+                    }
+
+                public:
+                    Iterator (contained_iter_type iter,
+                            contained_iter_type end) :
+                        sub_iter(iter),
+                        sub_end(end)
+                    { 
+                        this->skip_failures();
+                    } 
+
+                    contained_iter_ret operator*() const {
+                        return *this->sub_iter;
+                    }
+
+                    Iterator & operator++() { 
+                        ++this->sub_iter;
+                        this->skip_failures();
+                        return *this;
+                    }
+
+                    bool operator!=(const Iterator & other) const {
+                        return this->sub_iter != other.sub_iter;
+                    }
+            };
+
+            Iterator begin() const {
+                return Iterator(
+                        this->container.begin(),
+                        this->container.end());
+            }
+
+            Iterator end() const {
+                return Iterator(
+                        this->container.end(),
+                        this->container.end());
+            }
+
+    };
+
+    // Helper function to instantiate a FilterDefault
+    template <typename Container>
+    FilterDefault<Container> filter(Container & container) {
+        return FilterDefault<Container>(container);
+    }
 }
 
 #endif //ifndef FILTER__H__
diff --git a/tests/testfilter.cpp b/tests/testfilter.cpp
index 05ce83f3..63718646 100644
--- a/tests/testfilter.cpp
+++ b/tests/testfilter.cpp
@@ -42,5 +42,12 @@ int main() {
         std::cout << i << '\n';
     }
 
+    std::cout << "Nonzero ints filter(vec2)\n";
+    std::vector<int> vec2 {0, 1, 2, 0, 3, 0, 0, 0, 4, 5, 0};
+    for (auto i : filter(vec2)) {
+        std::cout << i << '\n';
+    }
+
+
     return 0;
 }

From b537ab010e04b2279d21609297769c8aff600578 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 7 Oct 2013 02:12:55 -0700
Subject: [PATCH 0053/1866] Formatting on grouper

---
 grouper.hpp | 72 ++++++++++++++++++++++++++++++++---------------------
 1 file changed, 44 insertions(+), 28 deletions(-)

diff --git a/grouper.hpp b/grouper.hpp
index 562d7b31..94273260 100644
--- a/grouper.hpp
+++ b/grouper.hpp
@@ -9,56 +9,72 @@
 
 namespace iter {
     template <typename Container>
-        struct grouper_iter;
+    class grouper_iter;
+
     template <typename Container>
-        iterator_range<grouper_iter<Container>>
-        grouper(Container & container, size_t s) {
-            auto begin = grouper_iter<Container>(container,s);
-            auto end = grouper_iter<Container>(container);
-            return iterator_range<grouper_iter<Container>>(begin,end);
-        }
+    iterator_range<grouper_iter<Container>> grouper(
+            Container & container, size_t s) {
+        auto begin = grouper_iter<Container>(container, s);
+        auto end = grouper_iter<Container>(container);
+        return iterator_range<grouper_iter<Container>>(begin, end);
+    }
 
     template <typename Container>
-        struct grouper_iter {
+    class grouper_iter {
+        private:
             Container & container;
             using Iterator = decltype(container.begin());
+            using Deref_type =
+                std::vector<
+                    std::reference_wrapper<
+                        typename std::remove_reference<
+                            decltype(*std::declval<Iterator>())>::type>>;
+
+
             std::vector<Iterator> group;
+
             size_t group_size = 0;
             bool not_done = true;
+
+        public: 
             grouper_iter(Container & c, size_t s) :
                 container(c),group_size(s) 
             {
-                //if the group size is 0 or the container is empty produce nothing
-                if (group_size == 0 || !(container.begin() != container.end())) {
-                    not_done = false;
+                // if the group size is 0 or the container is empty produce
+                // nothing
+                if (this->group_size == 0 ||
+                        !(this->container.begin() != this->container.end())) {
+                    this->not_done = false;
                     return;
                 }
-                for (size_t i = 0; i < group_size; ++i) 
-                    group.push_back(container.begin()+i);
+                for (size_t i = 0; i < this->group_size; ++i) 
+                    this->group.push_back(this->container.begin() + i);
             }
-            //seems like constructor is same as moving_section_iter
-            grouper_iter(Container & c) : container(c)
-            //creates the end iterator
+
+            //seems like conclassor is same as moving_section_iter
+            grouper_iter(Container & c) :
+                container(c)
             {
+                //creates the end iterator
                 group.push_back(container.end());
             }
 
             grouper_iter & operator++() {
-                for (auto & iter : group) {
-                    iter += group_size;
+                for (auto & iter : this->group) {
+                    iter += this->group_size;
                 }
                 return *this;
             }
-            bool operator!=(const grouper_iter &) {
-                return not_done;
+
+            bool operator!=(const grouper_iter &) const {
+                return this->not_done;
             }
-            using Deref_type = std::vector<std::reference_wrapper<typename std::remove_reference<decltype(*std::declval<Iterator>())>::type>>;
-            Deref_type operator*()
-            {
+
+            Deref_type operator*() {
                 Deref_type vec;
-                for (auto i : group) {
-                    if(i == container.end()) {
-                        not_done = false;
+                for (auto i : this->group) {
+                    if(i == this->container.end()) {
+                        this->not_done = false;
                         break;
                     } 
                     //if the group is at the end the vector will be smaller 
@@ -68,7 +84,7 @@ namespace iter {
                 }
                 return vec;
             }
-        };
+    };
 }
 
-#endif //MOVING_SECTION_HPP
+#endif // ifndef GROUPER_HPP

From 1084c753c761c0e17a98100a10788a5c996a9bc6 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 7 Oct 2013 02:21:42 -0700
Subject: [PATCH 0054/1866] Shortens using in enumerate

---
 enumerate.hpp | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index 30db629c..2c3dad18 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -25,21 +25,21 @@ namespace iter {
 
     template <typename Container>
     class Enumerable {
-        // The only thing allowed to directly instantiate an Enumerable is
-        // the enumerate function
-        friend Enumerable enumerate<Container>(Container &);
+        private:
+            Container & container;
+            // The only thing allowed to directly instantiate an Enumerable is
+            // the enumerate function
+            friend Enumerable enumerate<Container>(Container &);
 
-        // Type of the Container::Iterator, but since the name of that 
-        // iterator can be anything, we have to grab it with this
-        using contained_iter_type =
-            decltype(std::declval<Container>().begin());
+            // Type of the Container::Iterator, but since the name of that 
+            // iterator can be anything, we have to grab it with this
+            using contained_iter_type =
+                decltype(container.begin());
 
-        // The type returned when dereferencing the Container::Iterator
-        using contained_iter_ret =
-            decltype(std::declval<contained_iter_type>().operator*());
+            // The type returned when dereferencing the Container::Iterator
+            using contained_iter_ret =
+                decltype(container.begin().operator*());
 
-        private:
-            Container & container;
             
             // Value constructor for use only in the enumerate function
             Enumerable(Container & container) : container(container) { }

From 440d8d0ad79bf9c978d3c268475bae31868bf668 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 7 Oct 2013 02:23:48 -0700
Subject: [PATCH 0055/1866] Shortens using in compress

---
 compress.hpp | 31 ++++++++++++++-----------------
 1 file changed, 14 insertions(+), 17 deletions(-)

diff --git a/compress.hpp b/compress.hpp
index 92761729..989c5983 100644
--- a/compress.hpp
+++ b/compress.hpp
@@ -17,27 +17,24 @@ namespace iter {
 
     template <typename Container, typename Selector>
     class Compressed {
-        // The only thing allowed to directly instantiate an Compressed is
-        // the compress function
-        friend Compressed compress<Container, Selector>(
-                Container &, Selector &);
+        private:
+            Container & container;
+            Selector & selectors;
 
-        // Type of the Container::Iterator, but since the name of that 
-        // iterator can be anything, we have to grab it with this
-        using contained_iter_type =
-            decltype(std::declval<Container>().begin());
+            // The only thing allowed to directly instantiate an Compressed is
+            // the compress function
+            friend Compressed compress<Container, Selector>(
+                    Container &, Selector &);
 
-        // The type returned when dereferencing the Container::Iterator
-        using contained_iter_ret =
-            decltype(std::declval<contained_iter_type>().operator*());
+            // Type of the Container::Iterator, but since the name of that 
+            // iterator can be anything, we have to grab it with this
+            using contained_iter_type = decltype(container.begin());
 
-        // Selector::Iterator type
-        using selector_iter_type =
-            decltype(std::declval<Selector>().begin());
+            // The type returned when dereferencing the Container::Iterator
+            using contained_iter_ret = decltype(container.begin().operator*());
 
-        private:
-            Container & container;
-            Selector & selectors;
+            // Selector::Iterator type
+            using selector_iter_type = decltype(selectors.begin());
             
             // Value constructor for use only in the compress function
             Compressed(Container & container, Selector & selectors) :

From 7e0621d366935cec7684325b3f038c17d8743a41 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 7 Oct 2013 02:25:14 -0700
Subject: [PATCH 0056/1866] Removes a comment from filter

---
 filter.hpp | 2 --
 1 file changed, 2 deletions(-)

diff --git a/filter.hpp b/filter.hpp
index 1a611bce..d0cb6246 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -144,8 +144,6 @@ namespace iter {
                     contained_iter_type sub_iter;
                     const contained_iter_type sub_end;
 
-                    // increment until the iterator points to is true on the 
-                    // predicate.  Called by constructor and operator++
                     void skip_failures() { 
                         while (this->sub_iter != this->sub_end
                                 && !(*this->sub_iter)) {

From 7d06b1eed2f42c0f9a2ff59c5a762a93041f4ca6 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 7 Oct 2013 02:27:58 -0700
Subject: [PATCH 0057/1866] Shortens usings in dropwhile

---
 dropwhile.hpp | 23 +++++++++++------------
 1 file changed, 11 insertions(+), 12 deletions(-)

diff --git a/dropwhile.hpp b/dropwhile.hpp
index 8b60da37..ffba1d16 100644
--- a/dropwhile.hpp
+++ b/dropwhile.hpp
@@ -14,21 +14,20 @@ namespace iter {
 
     template <typename FilterFunc, typename Container>
     class DropWhile {
-        friend DropWhile dropwhile<FilterFunc, Container>(
-                FilterFunc, Container &);
-
-        // Type of the Container::Iterator, but since the name of that 
-        // iterator can be anything, we have to grab it with this
-        using contained_iter_type =
-            decltype(std::declval<Container>().begin());
-
-        // The type returned when dereferencing the Container::Iterator
-        using contained_iter_ret =
-            decltype(std::declval<contained_iter_type>().operator*());
-
         private:
             Container & container;
             FilterFunc filter_func;
+
+            friend DropWhile dropwhile<FilterFunc, Container>(
+                    FilterFunc, Container &);
+
+            // Type of the Container::Iterator, but since the name of that 
+            // iterator can be anything, we have to grab it with this
+            using contained_iter_type = decltype(container.begin());
+
+            // The type returned when dereferencing the Container::Iterator
+            using contained_iter_ret = decltype(container.begin().operator*());
+
             
             // Value constructor for use only in the dropwhile function
             DropWhile(FilterFunc filter_func, Container & container) :

From 8645fc9cb8e08e3866c47abd9313fb9ec33b438e Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 7 Oct 2013 02:31:59 -0700
Subject: [PATCH 0058/1866] Shortens using in filter

---
 filter.hpp | 36 +++++++++++++++---------------------
 1 file changed, 15 insertions(+), 21 deletions(-)

diff --git a/filter.hpp b/filter.hpp
index 1a611bce..eca5e29e 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -14,22 +14,19 @@ namespace iter {
 
     template <typename FilterFunc, typename Container>
     class Filter {
-        // The filter function is the only thing allowed to create a Filter
-        friend Filter filter<FilterFunc, Container>(FilterFunc, Container &);
-
-        
         protected:
+            Container & container;
+            FilterFunc filter_func;
+
+            // The filter function is the only thing allowed to create a Filter
+            friend Filter filter<FilterFunc, Container>(FilterFunc,
+                    Container &);
             // Type of the Container::Iterator, but since the name of that 
             // iterator can be anything, we have to grab it with this
-            using contained_iter_type =
-                decltype(std::declval<Container>().begin());
+            using contained_iter_type = decltype(container.begin());
 
             // The type returned when dereferencing the Container::Iterator
-            using contained_iter_ret =
-                decltype(std::declval<contained_iter_type>().operator*());
-
-            Container & container;
-            FilterFunc filter_func;
+            using contained_iter_ret = decltype(container.begin().operator*());
             
             // Value constructor for use only in the filter function
             Filter(FilterFunc filter_func, Container & container) :
@@ -114,22 +111,19 @@ namespace iter {
 
     template <typename Container>
     class FilterDefault {
-        // The filter function is the only thing allowed to create a FilterDefault
-        friend FilterDefault filter<Container>(Container &);
-
-        
         protected:
+            Container & container;
+
+            // The filter function is the only thing allowed to create a
+            // FilterDefault
+            friend FilterDefault filter<Container>(Container &);
             // Type of the Container::Iterator, but since the name of that 
             // iterator can be anything, we have to grab it with this
-            using contained_iter_type =
-                decltype(std::declval<Container>().begin());
+            using contained_iter_type = decltype(container.begin());
 
             // The type returned when dereferencing the Container::Iterator
-            using contained_iter_ret =
-                decltype(std::declval<contained_iter_type>().operator*());
+            using contained_iter_ret = decltype(container.begin().operator*());
 
-            Container & container;
-            
             // Value constructor for use only in the filter function
             FilterDefault(Container & container) :
                 container(container)

From 3ff96a41beba5cb77cabe32566ae27d92287d76c Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 7 Oct 2013 02:37:55 -0700
Subject: [PATCH 0059/1866] Shortens usings in takewhile

---
 takewhile.hpp | 25 ++++++++++++-------------
 1 file changed, 12 insertions(+), 13 deletions(-)

diff --git a/takewhile.hpp b/takewhile.hpp
index bbb70d49..0a1e033d 100644
--- a/takewhile.hpp
+++ b/takewhile.hpp
@@ -14,27 +14,26 @@ namespace iter {
 
     template <typename FilterFunc, typename Container>
     class TakeWhile {
-        friend TakeWhile takewhile<FilterFunc, Container>(
-                FilterFunc, Container &);
-
-        // Type of the Container::Iterator, but since the name of that 
-        // iterator can be anything, we have to grab it with this
-        using contained_iter_type =
-            decltype(std::declval<Container>().begin());
-
-        // The type returned when dereferencing the Container::Iterator
-        using contained_iter_ret =
-            decltype(std::declval<contained_iter_type>().operator*());
-
         private:
             Container & container;
             FilterFunc filter_func;
-            
+
+            friend TakeWhile takewhile<FilterFunc, Container>(
+                    FilterFunc, Container &);
+
+            // Type of the Container::Iterator, but since the name of that 
+            // iterator can be anything, we have to grab it with this
+            using contained_iter_type = decltype(container.begin());
+
+            // The type returned when dereferencing the Container::Iterator
+            using contained_iter_ret = decltype(container.begin().operator*());
+
             // Value constructor for use only in the takewhile function
             TakeWhile(FilterFunc filter_func, Container & container) :
                 container(container),
                 filter_func(filter_func)
             { }
+
             TakeWhile () = delete;
             TakeWhile & operator=(const TakeWhile &) = delete;
             // Default copy constructor used

From 3f07249d11c956e9f9a146c959a2fee02dc0696a Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 7 Oct 2013 02:39:15 -0700
Subject: [PATCH 0060/1866] Adds imap test with different size vectors

---
 tests/testimap.cpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/tests/testimap.cpp b/tests/testimap.cpp
index 32ded424..60f8ede0 100644
--- a/tests/testimap.cpp
+++ b/tests/testimap.cpp
@@ -27,5 +27,10 @@ int main() {
         std::cout << i << '\n';
     }
 
+    std::vector<int> vec4{1, 2, 3};
+    for (auto i : imap([] (int a, int b) { return a + b; }, vec, vec4)) {
+        std::cout << i << '\n';
+    }
+
     return 0;
 }

From e7d959c6d5cf3495caca500866b062c0c2ebe977 Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Mon, 7 Oct 2013 23:55:26 -0400
Subject: [PATCH 0061/1866] added temp test to combinations

---
 tests/testcombinations.cpp | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/tests/testcombinations.cpp b/tests/testcombinations.cpp
index 194f77c0..422c088e 100644
--- a/tests/testcombinations.cpp
+++ b/tests/testcombinations.cpp
@@ -17,6 +17,13 @@ int main() {
         for (auto j : i ) std::cout << j << " ";
         std::cout<<std::endl;
     }
-
+    for (auto i : combinations(v,3)) {
+        for (auto j : i ) std::cout << j << " ";
+        std::cout<<std::endl;
+    }
+    for (auto i : combinations(std::vector<int>{1,2,3,4},3)) {
+        for (auto j : i ) std::cout << j << " ";
+        std::cout<<std::endl;
+    }
     return 0;
 }

From c6de57b0170ee310d321472ccffbf78fb3494123 Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Tue, 8 Oct 2013 00:16:57 -0400
Subject: [PATCH 0062/1866] added perfect forwarding to chain, all previous
 tests work fine, but funky behavior with temp vector

---
 chain.hpp             | 12 ++++++------
 tests/SConstruct      |  1 +
 tests/testchain.cpp   |  5 +++++
 tests/testgrouper.cpp |  9 +++++++++
 4 files changed, 21 insertions(+), 6 deletions(-)

diff --git a/chain.hpp b/chain.hpp
index a825e1d5..ad8e3226 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -16,7 +16,7 @@ namespace iter {
                 const Iterator end;//never really used but kept it for consistency
 
             public:
-                chain_iter(Container & container, bool is_end=false) :
+                chain_iter(Container && container, bool is_end=false) :
                     begin(container.begin()),end(container.end()) {
                         if(is_end) begin = container.end();
                     }
@@ -44,10 +44,10 @@ namespace iter {
                 chain_iter<Containers...> next_iter;
 
             public:
-                chain_iter(Container & container, Containers& ... rest, bool is_end=false) :
+                chain_iter(Container && container, Containers&& ... containers, bool is_end=false) :
                     begin(container.begin()),
                     end(container.end()),
-                    next_iter(rest...,is_end) {
+                    next_iter(std::forward<Containers>(containers)...,is_end) {
                         if(is_end)
                             begin = container.end();
                     }
@@ -79,12 +79,12 @@ namespace iter {
                 }
         };
     template <typename ... Containers>
-        iterator_range<chain_iter<Containers...>> chain(Containers& ... containers)
+        iterator_range<chain_iter<Containers...>> chain(Containers&& ... containers)
         {
             auto begin = 
-                chain_iter<Containers...>(containers...);
+                chain_iter<Containers...>(std::forward<Containers>(containers)...);
             auto end =
-                chain_iter<Containers...>(containers...,true);
+                chain_iter<Containers...>(std::forward<Containers>(containers)...,true);
             return 
                 iterator_range<chain_iter<Containers...>>(begin,end);
         }
diff --git a/tests/SConstruct b/tests/SConstruct
index 08eb17de..cd08614c 100644
--- a/tests/SConstruct
+++ b/tests/SConstruct
@@ -23,6 +23,7 @@ progs = Split( '''
         count
         filterfalse
         grouper
+        chain
         ''')
 
 cxx = 'c++'
diff --git a/tests/testchain.cpp b/tests/testchain.cpp
index d0b88062..79015907 100644
--- a/tests/testchain.cpp
+++ b/tests/testchain.cpp
@@ -41,6 +41,11 @@ int main() {
          for (auto i : iter::chain(vec1,arr1,arr2)) {
              std::cout << i << std::endl;
          }
+         //test only works with perfect forwarding
+         std::cout<<std::endl;
+         for (auto i : chain(std::vector<int>{1,2,3,4,5},std::array<int,4>{{6,7,8,9}},std::vector<int>(20))) {
+             std::cout << i << std::endl;
+         }
     }
     return 0;
 }
diff --git a/tests/testgrouper.cpp b/tests/testgrouper.cpp
index b98a1af5..50b18554 100644
--- a/tests/testgrouper.cpp
+++ b/tests/testgrouper.cpp
@@ -25,5 +25,14 @@ int main() {
             std::cout << i << " Shouldn't print\n";
         }
     }
+    //works when perfect forwarding implemented
+    /*
+    for (auto sec : grouper({1,2,3,4,5,6,7,8},3)) {
+        for (auto i : sec) {
+            std::cout << i << " ";
+        }
+        std::cout << std::endl;
+    }
+    */
     return 0;
 }

From 8fbf1706ac3ef38fe213250fa29f7a47140fd4ba Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Tue, 8 Oct 2013 00:45:51 -0400
Subject: [PATCH 0063/1866] added perfect forwarding with zip, still getting
 strange temp vector behavior

---
 tests/testchain.cpp | 4 +++-
 tests/testzip.cpp   | 8 ++++++++
 zip.hpp             | 3 ++-
 3 files changed, 13 insertions(+), 2 deletions(-)

diff --git a/tests/testchain.cpp b/tests/testchain.cpp
index 79015907..46ac02a3 100644
--- a/tests/testchain.cpp
+++ b/tests/testchain.cpp
@@ -4,8 +4,10 @@
 #include <string>
 #include <iostream>
 #include <array>
+#include <initializer_list>
 
 using iter::chain;
+using il = std::initializer_list<int>; 
 
 int main() {
     {
@@ -43,7 +45,7 @@ int main() {
          }
          //test only works with perfect forwarding
          std::cout<<std::endl;
-         for (auto i : chain(std::vector<int>{1,2,3,4,5},std::array<int,4>{{6,7,8,9}},std::vector<int>(20))) {
+         for (auto i : chain(il{1,2,3,4,5},il{6,7,8,9},il{10,11,12})) {
              std::cout << i << std::endl;
          }
     }
diff --git a/tests/testzip.cpp b/tests/testzip.cpp
index 6f635a97..32483d83 100644
--- a/tests/testzip.cpp
+++ b/tests/testzip.cpp
@@ -69,6 +69,14 @@ int main() {
                 << std::get<3>(e) << std::endl;
         }
         std::cout<<std::endl;
+        for (auto e : zip(std::vector<int>{1,2,3,4,5},
+                    std::initializer_list<std::string>{"asdfas","aaron","ryan"},
+                    std::initializer_list<double>{1.1,2.2,3.3,4.4})) { 
+
+            std::cout << std::get<0>(e) << " " 
+                << std::get<1>(e) << " " 
+                << std::get<2>(e) << std::endl;
+        }
     }
     return 0;
 }
diff --git a/zip.hpp b/zip.hpp
index 927f480d..1542f92b 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -8,7 +8,7 @@ namespace iter {
     template <typename ... Rest>
         struct zip_iter;
     template <typename ... Containers>
-        auto zip(Containers & ... containers) ->
+        auto zip(Containers && ... containers) ->
         iterator_range<zip_iter<decltype(containers.begin())...>>
         {
             auto begin = zip_iter<decltype(containers.begin())...>(containers.begin()...);
@@ -64,6 +64,7 @@ namespace iter {
                 return (this->iter1 != rhs.iter1) && (this->iter2 != rhs.iter2);
             }
         };*/
+    //this specialization commented out 
     template <typename First, typename ... Rest>
         struct zip_iter<First,Rest...> {
 

From d2940d7a24554e17c1d48da69825a1bc3e5bb6ef Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 7 Oct 2013 22:12:33 -0700
Subject: [PATCH 0064/1866] Shows filter and filter false without predicate in
 README

---
 README.md | 28 +++++++++++++++++++++++-----
 1 file changed, 23 insertions(+), 5 deletions(-)

diff --git a/README.md b/README.md
index 1ae99384..17498761 100644
--- a/README.md
+++ b/README.md
@@ -6,15 +6,15 @@ library.
 
 ##### Table of Contents
 [range](#range)<br />
+[enumerate](#enumerate)<br />
+[zip](#zip)<br />
+[imap](#imap)<br />
 [filter](#filter)<br />
 [filterfalse](#filterfalse)<br />
 [takewhile](#takewhile)<br />
 [dropwhile](#dropwhile)<br />
-[enumerate](#enumerate)<br />
 [cycle](#cycle)<br />
 [compress](#compress)<br />
-[zip](#zip)<br />
-[imap](#imap)<br />
 [chain](#chain)<br />
 [reverse](#reverse)<br />
 [slice](#slice)<br />
@@ -94,26 +94,44 @@ Called as `filter(predicate, iterable)`.  The predicate can be any callable.
 
 Prints values greater than 4:  `5 6 7 8`
 ```c++
-vector<int> vec{1, 5, 4, 6, 7, 3, 2, 8, 3, 2, 1};
+vector<int> vec{1, 5, 4, 0, 6, 7, 3, 0, 2, 8, 3, 2, 1};
 for (auto i : filter([] (int i) { return i > 4; }, vec)) {
     cout << i <<'\n';
 }
 
 ```
 
+If no predicate is passed, the elements themselves are tested for truth
+
+Prints only non-zero values.
+```c++
+for(auto i : filter(vec)) {
+    cout << i << '\n';
+}
+```
+
 filterfalse
 -----------
 Similar to filter, but only prints values that are false under the predicate.
 
 Prints values not greater than 4: `1 4 3 2 3 2 1 `
 ```c++
-vector<int> vec{1, 5, 4, 6, 7, 3, 2, 8, 3, 2, 1};
+vector<int> vec{1, 5, 4, 0, 6, 7, 3, 0, 2, 8, 3, 2, 1};
 for (auto i : filter([] (int i) { return i > 4; }, vec)) {
     cout << i <<'\n';
 }
 
 ```
 
+If no predicate is passed, the elements themselves are tested for truth.
+
+Prints only zero values.
+```c++
+for(auto i : filterfalse(vec)) {
+    cout << i << '\n';
+}
+```
+
 takewhile
 ---------
 Yields elements from an iterable until the first element that is false under

From a9b906e0752e00d55ec5fa0a858a543b96e8e0a6 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 7 Oct 2013 22:17:09 -0700
Subject: [PATCH 0065/1866] Update README.md

---
 README.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/README.md b/README.md
index 17498761..f6646077 100644
--- a/README.md
+++ b/README.md
@@ -4,6 +4,8 @@ CPPItertools
 range-based for loop add-ons inspired by the python builtins and itertools
 library.
 
+*Note*: Everthing is inside the `iter` namespace.
+
 ##### Table of Contents
 [range](#range)<br />
 [enumerate](#enumerate)<br />

From e0ff9278004949c7797c23d2f679dffa056849a2 Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Tue, 8 Oct 2013 01:19:01 -0400
Subject: [PATCH 0066/1866] Did perfect forwarding in zip_longest

---
 tests/testzip.cpp         |  3 ++-
 tests/testzip_longest.cpp | 11 +++++++++++
 zip_longest.hpp           | 12 ++++++------
 3 files changed, 19 insertions(+), 7 deletions(-)

diff --git a/tests/testzip.cpp b/tests/testzip.cpp
index 32483d83..25174673 100644
--- a/tests/testzip.cpp
+++ b/tests/testzip.cpp
@@ -69,9 +69,10 @@ int main() {
                 << std::get<3>(e) << std::endl;
         }
         std::cout<<std::endl;
+        const std::vector<double> constvector{1.1,2.2,3.3,4.4};
         for (auto e : zip(std::vector<int>{1,2,3,4,5},
                     std::initializer_list<std::string>{"asdfas","aaron","ryan"},
-                    std::initializer_list<double>{1.1,2.2,3.3,4.4})) { 
+                    constvector)) { 
 
             std::cout << std::get<0>(e) << " " 
                 << std::get<1>(e) << " " 
diff --git a/tests/testzip_longest.cpp b/tests/testzip_longest.cpp
index e2fb8aab..c6c0dc59 100644
--- a/tests/testzip_longest.cpp
+++ b/tests/testzip_longest.cpp
@@ -75,6 +75,17 @@ int main() {
                 << std::get<3>(e) << std::endl;
         }
         std::cout<<std::endl;
+        for (auto e : iter::zip_longest(std::initializer_list<int>{1,2,3,4,5,6},
+                    std::initializer_list<double>{1.1,2.2,3.3,4.4},
+                    std::initializer_list<double>{1.1,2.2,3.3,4.4},
+                    std::array<int,3>{{1,2,3}})) { 
+            std::cout << std::get<0>(e) 
+                << std::get<1>(e) 
+                << std::get<2>(e) 
+                << std::get<3>(e) << std::endl;
+        }
+        std::cout<<std::endl;
+
     }
     return 0;
 }
diff --git a/zip_longest.hpp b/zip_longest.hpp
index b546abe3..b2036dba 100644
--- a/zip_longest.hpp
+++ b/zip_longest.hpp
@@ -11,12 +11,12 @@ namespace iter {
         struct zip_longest_iter;
     template <typename ... Containers>
         iterator_range<zip_longest_iter<Containers...>>
-        zip_longest(Containers & ... containers)
+        zip_longest(Containers && ... containers)
         {
             auto begin = 
-                zip_longest_iter<Containers...>(containers...);
+                zip_longest_iter<Containers...>(std::forward<Containers>(containers)...);
             auto end = 
-                zip_longest_iter<Containers...>(containers...);
+                zip_longest_iter<Containers...>(std::forward<Containers>(containers)...);
             return iterator_range<decltype(begin)>(begin,end);
         }   
     /*
@@ -35,7 +35,7 @@ namespace iter {
             const Iterator end;
 
         public:
-            zip_longest_iter(Container & c) :
+            zip_longest_iter(Container && c) :
                 begin(c.begin()),end(c.end()) {}
 
             std::tuple<boost::optional<decltype(*std::declval<Iterator>())>> 
@@ -69,10 +69,10 @@ namespace iter {
                             std::tuple<boost::optional<Elem_t>>(),
                             *inner_iter));
 
-            zip_longest_iter(Container & c, Containers & ... containers) :
+            zip_longest_iter(Container && c, Containers && ... containers) :
                 begin(c.begin()),
                 end(c.end()),
-                inner_iter(containers...) {}
+                inner_iter(std::forward<Containers>(containers)...) {}
 
             //this is for returning a tuple of optional<iterator>
 

From 3693370054f1ab7b49ebc208b9af9da2a5114b16 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 8 Oct 2013 00:50:54 -0700
Subject: [PATCH 0067/1866] Adds = default for copyctor

---
 cycle.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cycle.hpp b/cycle.hpp
index 9a94921d..a47b87c2 100644
--- a/cycle.hpp
+++ b/cycle.hpp
@@ -35,9 +35,9 @@ namespace iter {
             Cycle(Container & container) : container(container) { }
             Cycle () = delete;
             Cycle & operator=(const Cycle &) = delete;
-            // Default copy constructor used
 
         public:
+            Cycle(const Cycle &) = default;
             class Iterator {
                 private:
                     contained_iter_type sub_iter;

From 09ddd92603d2974243944169c465b28593549970 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 8 Oct 2013 00:51:27 -0700
Subject: [PATCH 0068/1866] Adds = default for copyctor

---
 dropwhile.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dropwhile.hpp b/dropwhile.hpp
index ffba1d16..3151d4f6 100644
--- a/dropwhile.hpp
+++ b/dropwhile.hpp
@@ -36,9 +36,9 @@ namespace iter {
             { }
             DropWhile () = delete;
             DropWhile & operator=(const DropWhile &) = delete;
-            // Default copy constructor used
 
         public:
+            DropWhile(const Dropwhile &) = default;
             class Iterator {
                 private:
                     contained_iter_type sub_iter;

From d3306bbf992c951fe84feaaa96e795564a2607c6 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 8 Oct 2013 00:54:57 -0700
Subject: [PATCH 0069/1866] Adds = default for copy ctor

---
 dropwhile.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dropwhile.hpp b/dropwhile.hpp
index 3151d4f6..cf730f0c 100644
--- a/dropwhile.hpp
+++ b/dropwhile.hpp
@@ -38,7 +38,7 @@ namespace iter {
             DropWhile & operator=(const DropWhile &) = delete;
 
         public:
-            DropWhile(const Dropwhile &) = default;
+            DropWhile(const DropWhile &) = default;
             class Iterator {
                 private:
                     contained_iter_type sub_iter;

From ba245c3f5b850f2e8c5e1c051dd5e566cd8e87ef Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 8 Oct 2013 00:55:04 -0700
Subject: [PATCH 0070/1866] Adds = default for copy ctor

---
 enumerate.hpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index 2c3dad18..7f48a1d9 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -45,9 +45,10 @@ namespace iter {
             Enumerable(Container & container) : container(container) { }
             Enumerable () = delete;
             Enumerable & operator=(const Enumerable &) = delete;
-            // Default copy constructor used
 
         public:
+            Enumerable(const Enumerable &) = default;
+
             // "yielded" by the Enumerable::Iterator.  Has a .index, and a 
             // .element referencing the value yielded by the subiterator
             class IterYield {

From e8a2aca8675e34f8b273ec2dfb776c57397a0cd7 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 8 Oct 2013 00:55:18 -0700
Subject: [PATCH 0071/1866] Adds = default for copy ctor

---
 filter.hpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/filter.hpp b/filter.hpp
index 6e0e4df9..1dc32769 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -35,9 +35,10 @@ namespace iter {
             { }
             Filter () = delete;
             Filter & operator=(const Filter &) = delete;
-            // Default copy constructor used
 
         public:
+            Filter(const Filter &) = default;
+
             class Iterator {
                 protected:
                     contained_iter_type sub_iter;
@@ -130,9 +131,9 @@ namespace iter {
             { }
             FilterDefault () = delete;
             FilterDefault & operator=(const FilterDefault &) = delete;
-            // Default copy constructor used
 
         public:
+            FilterDefault(const FilterDefault &) = default;
             class Iterator {
                 protected:
                     contained_iter_type sub_iter;

From 7cdf5f62d4b4e65545008208b47d1b2c138c211c Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 8 Oct 2013 00:55:25 -0700
Subject: [PATCH 0072/1866] Adds = default for copy ctor

---
 takewhile.hpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/takewhile.hpp b/takewhile.hpp
index 0a1e033d..11123561 100644
--- a/takewhile.hpp
+++ b/takewhile.hpp
@@ -36,9 +36,10 @@ namespace iter {
 
             TakeWhile () = delete;
             TakeWhile & operator=(const TakeWhile &) = delete;
-            // Default copy constructor used
 
         public:
+            TakeWhile(const TakeWhile &) = default;
+
             class Iterator {
                 private:
                     contained_iter_type sub_iter;

From f9c967cbcba2c11cb750c8ec00662e3be56e2a72 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 8 Oct 2013 01:02:52 -0700
Subject: [PATCH 0073/1866] Adds case for only list passed to filterfalse

---
 tests/testfilterfalse.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/tests/testfilterfalse.cpp b/tests/testfilterfalse.cpp
index 2c1cd3f3..3d6816b9 100644
--- a/tests/testfilterfalse.cpp
+++ b/tests/testfilterfalse.cpp
@@ -42,5 +42,11 @@ int main() {
         std::cout << i << '\n';
     }
 
+    std::cout << "Nonzero ints filter(vec2)\n";
+    std::vector<int> vec2 {0, 1, 2, 0, 3, 0, 0, 0, 4, 5, 0};
+    for (auto i : filterfalse(vec2)) {
+        std::cout << i << '\n';
+    }
+
     return 0;
 }

From a56e8301e1ea33f5559999947f620be217ec7d54 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 8 Oct 2013 01:03:27 -0700
Subject: [PATCH 0074/1866] Updates filterfalse to work with no predicate

---
 filterfalse.hpp | 88 +++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 88 insertions(+)

diff --git a/filterfalse.hpp b/filterfalse.hpp
index 578b57c2..feaaab2f 100644
--- a/filterfalse.hpp
+++ b/filterfalse.hpp
@@ -84,6 +84,94 @@ namespace iter {
             Container & container) {
         return FilterFalse<FilterFunc, Container>(filter_func, container);
     }
+
+
+    //Forward declarations of filterfalseFalseDefault and filterfalse
+    template <typename Container>
+    class filterfalseFalseDefault;
+
+    template <typename Container>
+    filterfalseFalseDefault<Container> filterfalse(Container &);
+
+    template <typename Container>
+    class filterfalseFalseDefault {
+        protected:
+            Container & container;
+
+            // The filterfalse function is the only thing allowed to create a
+            // filterfalseFalseDefault
+            friend filterfalseFalseDefault filterfalse<Container>(Container &);
+            // Type of the Container::Iterator, but since the name of that 
+            // iterator can be anything, we have to grab it with this
+            using contained_iter_type = decltype(container.begin());
+
+            // The type returned when dereferencing the Container::Iterator
+            using contained_iter_ret = decltype(container.begin().operator*());
+
+            // Value constructor for use only in the filterfalse function
+            filterfalseFalseDefault(Container & container) :
+                container(container)
+            { }
+            filterfalseFalseDefault () = delete;
+            filterfalseFalseDefault & operator=(const filterfalseFalseDefault &) = delete;
+
+        public:
+            filterfalseFalseDefault(const filterfalseFalseDefault &) = default;
+            class Iterator {
+                protected:
+                    contained_iter_type sub_iter;
+                    const contained_iter_type sub_end;
+
+                    void skip_passes() { 
+                        while (this->sub_iter != this->sub_end
+                                && *this->sub_iter) {
+                            ++this->sub_iter;
+                        }
+                    }
+
+                public:
+                    Iterator (contained_iter_type iter,
+                            contained_iter_type end) :
+                        sub_iter(iter),
+                        sub_end(end)
+                    { 
+                        this->skip_passes();
+                    } 
+
+                    contained_iter_ret operator*() const {
+                        return *this->sub_iter;
+                    }
+
+                    Iterator & operator++() { 
+                        ++this->sub_iter;
+                        this->skip_passes();
+                        return *this;
+                    }
+
+                    bool operator!=(const Iterator & other) const {
+                        return this->sub_iter != other.sub_iter;
+                    }
+            };
+
+            Iterator begin() const {
+                return Iterator(
+                        this->container.begin(),
+                        this->container.end());
+            }
+
+            Iterator end() const {
+                return Iterator(
+                        this->container.end(),
+                        this->container.end());
+            }
+
+    };
+
+    // Helper function to instantiate a filterfalseFalseDefault
+    template <typename Container>
+    filterfalseFalseDefault<Container> filterfalse(Container & container) {
+        return filterfalseFalseDefault<Container>(container);
+    }
 }
 
 

From 36a97a0533767a0fd56e197f24fe68f6dbbb5e59 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 8 Oct 2013 15:47:42 -0700
Subject: [PATCH 0075/1866] Adds environment to SConstruct

This looks more like the right way to use scons.  Also preserves
highlighting from the compiler output to be
---
 tests/SConstruct | 29 ++++++++++++++++++-----------
 1 file changed, 18 insertions(+), 11 deletions(-)

diff --git a/tests/SConstruct b/tests/SConstruct
index 08eb17de..82f54829 100644
--- a/tests/SConstruct
+++ b/tests/SConstruct
@@ -1,4 +1,21 @@
 import platform
+import os
+
+env = Environment(
+    CXX='g++',
+    CXXFLAGS=' -Wall -Wextra -pedantic -std=c++11 -I/usr/local/include',
+    CPPPATH='..',
+    LINKFLAGS='-L/usr/local/lib')
+
+# allows highighting to print to terminal from compiler output
+env['ENV']['TERM'] = os.environ['TERM']
+
+# if on MAC, needs the linker flag for -stdlib=libc++
+if platform.system() == 'Darwin':
+    env['CXX'] += ' -stdlib=libc++ '
+    env['CXXFLAGS'] += ' -stdlib=libc++ '
+
+
 
 progs = Split( '''
 		cycle 
@@ -25,16 +42,6 @@ progs = Split( '''
         grouper
         ''')
 
-cxx = 'c++'
-cxx_flags = ' -Wall -Wextra -pedantic -std=c++11 -I/usr/local/include'
-ldflags = ' -L/usr/local/lib'
-
-# if on MAC, needs the linker flag for -stdlib=libc++
-if platform.system() == 'Darwin':
-    ldflags += ' -stdlib=libc++ '
-    cxx_flags += ' -stdlib=libc++ '
 
 for p in progs:
-    Program(source='test{0}.cpp'.format(p),
-            CXXFLAGS=cxx_flags, CPPPATH='..', CXX=cxx,
-            LINKFLAGS=ldflags)
+    env.Program('test{0}.cpp'.format(p))

From 277653eea0e75a656ce3c2bd528758d101026cc9 Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Thu, 10 Oct 2013 16:03:37 -0400
Subject: [PATCH 0076/1866] perfect forwarding in slice

---
 slice.hpp         |  4 ++--
 tests/testzip.cpp | 10 ++++++----
 2 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/slice.hpp b/slice.hpp
index 408645d1..5b65a8a4 100644
--- a/slice.hpp
+++ b/slice.hpp
@@ -10,7 +10,7 @@
 namespace iter {
     template <typename Container>
         auto slice(
-                Container & container,
+                Container && container,
                 typename std::iterator_traits<decltype(container.begin())>::difference_type begin,
                 typename std::iterator_traits<decltype(container.begin())>::difference_type end,
                 typename std::iterator_traits<decltype(container.begin())>::difference_type step = 1
@@ -39,7 +39,7 @@ namespace iter {
     //only give the end as an arg and assume step  is 1 and begin is 0
     template <typename Container>
         auto slice(
-                Container & container,
+                Container && container,
                 typename std::iterator_traits<decltype(container.begin())>::difference_type end
                 ) -> iterator_range<wrap_iter<decltype(container.begin())>>
         {
diff --git a/tests/testzip.cpp b/tests/testzip.cpp
index 25174673..8b168dfa 100644
--- a/tests/testzip.cpp
+++ b/tests/testzip.cpp
@@ -1,4 +1,5 @@
 #include <zip.hpp>
+#include <chain.hpp>
 
 #include <vector>
 #include <string>
@@ -70,11 +71,12 @@ int main() {
         }
         std::cout<<std::endl;
         const std::vector<double> constvector{1.1,2.2,3.3,4.4};
-        for (auto e : zip(std::vector<int>{1,2,3,4,5},
-                    std::initializer_list<std::string>{"asdfas","aaron","ryan"},
-                    constvector)) { 
+        for (auto e : zip(iter::chain(std::vector<int>{1,5},std::array<int,2>{{1,2}}),
+                    std::initializer_list<std::string>{"asdfas","aaron","ryan","apple","juice"},
+                    constvector)) 
+        { 
 
-            std::cout << std::get<0>(e) << " " 
+            std::cout << (std::get<0>(e)=5) << " " 
                 << std::get<1>(e) << " " 
                 << std::get<2>(e) << std::endl;
         }

From 38490c814ccaa2c5863a6abb203c2524c67638f3 Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Thu, 10 Oct 2013 16:08:09 -0400
Subject: [PATCH 0077/1866] perfect forwarding in moving_section and reverse

---
 moving_section.hpp | 13 +++++++------
 reverse.hpp        |  2 +-
 2 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/moving_section.hpp b/moving_section.hpp
index 35b940bf..e21c2dc8 100644
--- a/moving_section.hpp
+++ b/moving_section.hpp
@@ -6,30 +6,31 @@
 #include <algorithm>
 #include <functional>
 #include <type_traits>
+#include <utility>
 
 namespace iter {
     template <typename Container>
         struct moving_section_iter;
     template <typename Container>
         iterator_range<moving_section_iter<Container>>
-        moving_section(Container & container, size_t s) {
-            auto begin = moving_section_iter<Container>(container,s);
-            auto end = moving_section_iter<Container>(container);
+        moving_section(Container && container, size_t s) {
+            auto begin = moving_section_iter<Container>(std::forward<Container>(container),s);
+            auto end = moving_section_iter<Container>(std::forward<Container>(container));
             return iterator_range<moving_section_iter<Container>>(begin,end);
         }
 
     template <typename Container>
         struct moving_section_iter {
-            Container & container;
+            Container && container;
             using Iterator = decltype(container.begin());
             std::vector<Iterator> section;
             size_t section_size = 0;
-            moving_section_iter(Container & c, size_t s) :
+            moving_section_iter(Container && c, size_t s) :
                 container(c),section_size(s) {
                     for (size_t i = 0; i < section_size; ++i) 
                         section.push_back(container.begin()+i);
                 }
-            moving_section_iter(Container & c) : container(c)
+            moving_section_iter(Container && c) : container(c)
             //creates the end iterator
             {
                 section.push_back(container.end());
diff --git a/reverse.hpp b/reverse.hpp
index fdd8507f..14e8352c 100644
--- a/reverse.hpp
+++ b/reverse.hpp
@@ -5,7 +5,7 @@
 
 namespace iter {
     template <typename Container>
-       auto reverse(Container & container) -> iterator_range<decltype(container.rbegin())>
+       auto reverse(Container && container) -> iterator_range<decltype(container.rbegin())>
        {
            return 
                iterator_range<decltype(container.rbegin())>(container.rbegin(),container.rend());

From 9998d67b87bf939b8fd4fb663d39cc5ebcd9bb10 Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Thu, 10 Oct 2013 16:30:01 -0400
Subject: [PATCH 0078/1866] all perfect forwarding added for aarons functions

---
 grouper.hpp        | 17 +++++++++--------
 moving_section.hpp |  4 ++--
 2 files changed, 11 insertions(+), 10 deletions(-)

diff --git a/grouper.hpp b/grouper.hpp
index 94273260..e8761647 100644
--- a/grouper.hpp
+++ b/grouper.hpp
@@ -6,6 +6,7 @@
 #include <algorithm>
 #include <functional>
 #include <type_traits>
+#include <utility>
 
 namespace iter {
     template <typename Container>
@@ -13,16 +14,16 @@ namespace iter {
 
     template <typename Container>
     iterator_range<grouper_iter<Container>> grouper(
-            Container & container, size_t s) {
-        auto begin = grouper_iter<Container>(container, s);
-        auto end = grouper_iter<Container>(container);
+            Container && container, size_t s) {
+        auto begin = grouper_iter<Container>(std::forward<Container>(container), s);
+        auto end = grouper_iter<Container>(std::forward<Container>(container));
         return iterator_range<grouper_iter<Container>>(begin, end);
     }
 
     template <typename Container>
     class grouper_iter {
         private:
-            Container & container;
+            Container && container;
             using Iterator = decltype(container.begin());
             using Deref_type =
                 std::vector<
@@ -37,8 +38,8 @@ namespace iter {
             bool not_done = true;
 
         public: 
-            grouper_iter(Container & c, size_t s) :
-                container(c),group_size(s) 
+            grouper_iter(Container && c, size_t s) :
+                container(std::forward<Container>(c)),group_size(s) 
             {
                 // if the group size is 0 or the container is empty produce
                 // nothing
@@ -52,8 +53,8 @@ namespace iter {
             }
 
             //seems like conclassor is same as moving_section_iter
-            grouper_iter(Container & c) :
-                container(c)
+            grouper_iter(Container && c) :
+                container(std::forward<Container>(c))
             {
                 //creates the end iterator
                 group.push_back(container.end());
diff --git a/moving_section.hpp b/moving_section.hpp
index e21c2dc8..f22cc80d 100644
--- a/moving_section.hpp
+++ b/moving_section.hpp
@@ -26,11 +26,11 @@ namespace iter {
             std::vector<Iterator> section;
             size_t section_size = 0;
             moving_section_iter(Container && c, size_t s) :
-                container(c),section_size(s) {
+                container(std::forward<Container>(c)),section_size(s) {
                     for (size_t i = 0; i < section_size; ++i) 
                         section.push_back(container.begin()+i);
                 }
-            moving_section_iter(Container && c) : container(c)
+            moving_section_iter(Container && c) : container(std::forward<Container>(c))
             //creates the end iterator
             {
                 section.push_back(container.end());

From 3d1610e1345583e9cc165b4caa99eb1303aaf3b2 Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Thu, 10 Oct 2013 16:45:42 -0400
Subject: [PATCH 0079/1866] Added file for testing chaining of itertools
 functions

---
 tests/.gitignore             |  1 +
 tests/SConstruct             |  1 +
 tests/testcommand_chains.cpp | 34 ++++++++++++++++++++++++++++++++++
 3 files changed, 36 insertions(+)
 create mode 100644 tests/testcommand_chains.cpp

diff --git a/tests/.gitignore b/tests/.gitignore
index 450ff7b2..28a3d478 100644
--- a/tests/.gitignore
+++ b/tests/.gitignore
@@ -22,4 +22,5 @@ testimap
 testfilterfalse
 testcount
 testgrouper
+testcommand_chains
 .sconsign.dblite
diff --git a/tests/SConstruct b/tests/SConstruct
index 4b61d7fc..57c088cf 100644
--- a/tests/SConstruct
+++ b/tests/SConstruct
@@ -41,6 +41,7 @@ progs = Split( '''
         filterfalse
         grouper
         chain
+        command_chains
         ''')
 
 
diff --git a/tests/testcommand_chains.cpp b/tests/testcommand_chains.cpp
new file mode 100644
index 00000000..7e59ca62
--- /dev/null
+++ b/tests/testcommand_chains.cpp
@@ -0,0 +1,34 @@
+#include <itertools.hpp>
+
+#include <vector>
+#include <tuple>
+#include <array>
+#include <iostream>
+#include <string>
+
+using namespace iter;
+
+template <typename T>
+std::ostream & operator<<(std::ostream & o, const boost::optional<T> & opt) {
+    if (opt) {
+        std::cout << *opt; 
+    }
+    else {
+        std::cout << "Object disengaged of type " << typeid(T).name();
+    }
+    return o;
+}
+
+int main() {
+    {
+        std::vector<int> vec1{1,2,3,4,5,6};
+        std::vector<int> vec2{1,2,3,4,5};
+        std::vector<std::string> strvec
+        {"his","name","was","robert","paulson","his","name","was","robert","paulson"};
+        for (auto t : zip_longest(chain(vec1,vec2),strvec)) {
+            std::cout << std::get<0>(t) << " "
+                << std::get<1>(t) << std::endl;
+        }
+    }
+    return 0;
+}

From 4c5e187c35ac739275510c6bd056f7688a625d46 Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Thu, 10 Oct 2013 17:22:50 -0400
Subject: [PATCH 0080/1866] added another command chaining test

---
 chain.hpp                    |  6 +++---
 slice.hpp                    |  2 +-
 tests/testcommand_chains.cpp | 11 +++++++++++
 wrap_iter.hpp                |  8 +++++++-
 4 files changed, 22 insertions(+), 5 deletions(-)

diff --git a/chain.hpp b/chain.hpp
index ad8e3226..4ac309c2 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -53,7 +53,7 @@ namespace iter {
                     }
                 chain_iter & operator++()
                 {
-                    if (begin == end) {
+                    if (!(begin != end)) {
                         ++next_iter;
                     }
                     else {
@@ -63,7 +63,7 @@ namespace iter {
                 }
                 auto operator*()->decltype(*begin)
                 {
-                    if (begin == end) {
+                    if (!(begin != end)) {
                         return *next_iter;
                     }
                     else {
@@ -71,7 +71,7 @@ namespace iter {
                     }
                 }   
                 bool operator !=(const chain_iter & rhs) const {
-                    if (begin == end) {
+                    if (!(begin != end)) {
                         return this->next_iter != rhs.next_iter;
                     }
                     else
diff --git a/slice.hpp b/slice.hpp
index 5b65a8a4..6fb37949 100644
--- a/slice.hpp
+++ b/slice.hpp
@@ -43,7 +43,7 @@ namespace iter {
                 typename std::iterator_traits<decltype(container.begin())>::difference_type end
                 ) -> iterator_range<wrap_iter<decltype(container.begin())>>
         {
-            return slice(container,0,end);
+            return slice(std::forward<Container>(container),0,end);
         }
 
 }
diff --git a/tests/testcommand_chains.cpp b/tests/testcommand_chains.cpp
index 7e59ca62..98c6f1ea 100644
--- a/tests/testcommand_chains.cpp
+++ b/tests/testcommand_chains.cpp
@@ -30,5 +30,16 @@ int main() {
                 << std::get<1>(t) << std::endl;
         }
     }
+    std::cout << std::endl;
+    {
+        std::vector<int> vec1{1,2,3,4,5,6};
+        std::vector<int> vec2{7,8,9,10};
+        std::vector<std::string> strvec
+        {"We're","done","when","I","say","we're","done"};
+        for (auto t : zip(strvec,chain(slice(vec1,2,6),slice(vec2,1,4)))) {
+            std::cout << std::get<0>(t) << " "
+                << std::get<1>(t) << std::endl;
+        }
+    }
     return 0;
 }
diff --git a/wrap_iter.hpp b/wrap_iter.hpp
index 2477753b..31bc899b 100644
--- a/wrap_iter.hpp
+++ b/wrap_iter.hpp
@@ -11,6 +11,7 @@ namespace iter {
             typename std::iterator_traits<Iterator>::difference_type step;
 
         public:
+            //using difference_type = typename std::iterator_traits<Iterator>::difference_type;
             wrap_iter(const Iterator & iter,
                     typename std::iterator_traits<Iterator>::difference_type step) : 
                 iter(iter),
@@ -37,6 +38,11 @@ namespace iter {
             typename std::iterator_traits<Iterator>::difference_type step) {
         return wrap_iter<Iterator>(iter,step);
     }
+    
 }
-
+template <typename Iterator>
+    struct std::iterator_traits<iter::wrap_iter<Iterator>> {
+        using difference_type = typename std::iterator_traits<Iterator>::difference_type;
+        //should add the rest later for a more usable class
+    };
 #endif //WRAP_ITER_HPP__

From a6db8280d41edf22812cc25a0f37fa3613de7271 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 10 Oct 2013 22:42:40 -0700
Subject: [PATCH 0081/1866] Adds test for groupby

---
 tests/testgroupby.cpp | 36 ++++++++++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 tests/testgroupby.cpp

diff --git a/tests/testgroupby.cpp b/tests/testgroupby.cpp
new file mode 100644
index 00000000..17443343
--- /dev/null
+++ b/tests/testgroupby.cpp
@@ -0,0 +1,36 @@
+#include <groupby.hpp>
+
+#include <vector>
+#include <iostream>
+#include <string>
+
+using iter::groupby;
+
+
+int length(std::string s)
+{
+    return s.length();
+}
+
+int main()
+{
+    std::vector<std::string> vec = {
+        "hi", "ab", "ho",
+        "abc", "def",
+        "abcde", "efghi"
+    };
+
+    for (auto gb : groupby(vec, &length)) {
+        std::cout << "key: " << gb.first << '\n';
+        std::cout << "content: ";
+        for (auto s : gb.second) {
+            std::cout << s << "  ";
+        }
+        std::cout << '\n';
+    }
+
+
+    return 0;
+}
+
+    

From a4eb068cfbd0a13af130b582f1c5759198a6a0fa Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 10 Oct 2013 22:43:04 -0700
Subject: [PATCH 0082/1866] Adds groupby

---
 groupby.hpp | 183 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 183 insertions(+)
 create mode 100644 groupby.hpp

diff --git a/groupby.hpp b/groupby.hpp
new file mode 100644
index 00000000..e21ea30b
--- /dev/null
+++ b/groupby.hpp
@@ -0,0 +1,183 @@
+#ifndef GROUP__BY__HPP
+#define GROUP__BY__HPP
+
+
+#include <utility>
+
+
+namespace iter {
+
+    template <typename Container, typename KeyFunc>
+    class GroupBy;
+
+    template <typename Container, typename KeyFunc>
+    GroupBy<Container, KeyFunc> groupby(Container &, KeyFunc);
+
+    template <typename Container, typename KeyFunc>
+    class GroupBy {
+        private:
+            Container & container;
+            KeyFunc key_func;
+
+            // The filter function is the only thing allowed to create a Filter
+            friend GroupBy groupby<Container, KeyFunc>(Container &, KeyFunc);
+
+            // Type of the Container::Iterator, but since the name of that 
+            // iterator can be anything, we have to grab it with this
+            using contained_iter_type = decltype(container.begin());
+
+            // The type returned when dereferencing the Container::Iterator
+            using contained_iter_ret = decltype(container.begin().operator*());
+
+            using key_func_ret =
+                decltype(std::declval<KeyFunc>()(
+                            std::declval<contained_iter_ret>()));
+
+            GroupBy(Container & container, KeyFunc key_func) :
+                container(container),
+                key_func(key_func)
+            { }
+            GroupBy () = delete;
+            GroupBy & operator=(const GroupBy &) = delete;
+
+        public:
+            GroupBy(const GroupBy &) = default;
+
+            class Iterator;
+            class Group;
+
+            class Iterator {
+                private:
+                    contained_iter_type sub_iter;
+                    contained_iter_type sub_iter_peek;
+                    const contained_iter_type sub_end;
+                    KeyFunc key_func;
+
+                    using KeyGroupPair =
+                        std::pair<key_func_ret, Group>;
+
+                public:
+                    Iterator (contained_iter_type si,
+                              contained_iter_type end,
+                              KeyFunc key_func) :
+                        sub_iter(si),
+                        sub_end(end),
+                        key_func(key_func)
+                    { }
+
+                    KeyGroupPair operator*() {
+                        return KeyGroupPair(
+                                this->key_func(*this->sub_iter),
+                                Group(
+                                    this, 
+                                    this->key_func(*this->sub_iter)));
+                    }
+
+                    Iterator & operator++() { 
+                        return *this;
+                    }
+
+                    bool operator!=(const Iterator &) const {
+                        return !this->exhausted();
+                    }
+
+                    void increment_iterator() {
+                        if (this->sub_iter != this->sub_end) {
+                            ++this->sub_iter;
+                        }
+                    }
+
+                    bool exhausted() const {
+                        return this->sub_iter == this->sub_end;
+                    }
+
+                    contained_iter_ret current() const {
+                        return *this->sub_iter;
+                    }
+
+                    key_func_ret next_key() const {
+                        return this->key_func(*this->sub_iter);
+                    }
+            };
+
+
+            class Group {
+                private:
+                    friend Iterator;
+                    Iterator *owner;
+                    key_func_ret key;
+
+                    Group(Iterator *owner, key_func_ret key) :
+                        owner(owner),
+                        key(key)
+                    { }
+
+
+                    Group () = delete;
+                public:
+                    Group (const Group &) = default;
+
+                    class GroupIterator {
+                        private:
+                            Iterator * owner;
+                            const key_func_ret key;
+
+                        public:
+                            GroupIterator(Iterator * owner, key_func_ret key) :
+                                owner(owner),
+                                key(key)
+                            { }
+
+                            GroupIterator(const GroupIterator &) = default;
+
+                            bool operator!=(const GroupIterator &) const {
+                                return !this->owner->exhausted() &&
+                                    this->owner->next_key() == this->key;
+                            }
+
+                            GroupIterator & operator++() {
+                                this->owner->increment_iterator();
+                                return *this;
+                            }
+
+                            contained_iter_ret operator*() const {
+                                return this->owner->current();
+                            }
+                    };
+
+                    GroupIterator begin() const {
+                        return GroupIterator(this->owner, key);
+                    }
+
+                    GroupIterator end() const {
+                        return GroupIterator(this->owner, key);
+                    }
+
+            };
+
+
+            Iterator begin() const {
+                return Iterator(
+                        this->container.begin(),
+                        this->container.end(),
+                        this->key_func);
+            }
+
+            Iterator end() const {
+                return Iterator(
+                        this->container.end(),
+                        this->container.end(),
+                        this->key_func);
+            }
+
+    };
+
+    template <typename Container, typename KeyFunc>
+    GroupBy<Container, KeyFunc> groupby(
+            Container & container, KeyFunc key_func) {
+        return GroupBy<Container, KeyFunc>(container, key_func);
+    }
+}
+
+
+#endif //#ifndef GROUP__BY__HPP

From 4fbcf61048f3f2344cb63439d6771ac49d48d8a5 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 10 Oct 2013 22:43:33 -0700
Subject: [PATCH 0083/1866] Adds groupby to SConstruct

---
 tests/SConstruct | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tests/SConstruct b/tests/SConstruct
index 4b61d7fc..54aa597e 100644
--- a/tests/SConstruct
+++ b/tests/SConstruct
@@ -3,7 +3,7 @@ import os
 
 env = Environment(
     CXX='g++',
-    CXXFLAGS=' -Wall -Wextra -pedantic -std=c++11 -I/usr/local/include',
+    CXXFLAGS=' -g -Wall -Wextra -pedantic -std=c++11 -I/usr/local/include',
     CPPPATH='..',
     LINKFLAGS='-L/usr/local/lib')
 
@@ -41,6 +41,7 @@ progs = Split( '''
         filterfalse
         grouper
         chain
+        groupby
         ''')
 
 

From 98cde0779147f94431fb14a85afd135edd00c2be Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 10 Oct 2013 22:44:14 -0700
Subject: [PATCH 0084/1866] Adds testgroupby to .gitignore

---
 tests/.gitignore | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tests/.gitignore b/tests/.gitignore
index 450ff7b2..15ef90c6 100644
--- a/tests/.gitignore
+++ b/tests/.gitignore
@@ -22,4 +22,5 @@ testimap
 testfilterfalse
 testcount
 testgrouper
+testgroupby
 .sconsign.dblite

From b625318c8a1b0742bb69bcc18a075d6f08951e50 Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Fri, 11 Oct 2013 14:02:50 -0400
Subject: [PATCH 0085/1866] increased command chaining ability of
 moving_section

---
 moving_section.hpp           | 14 +++++++++++---
 tests/testcommand_chains.cpp | 11 +++++++++++
 2 files changed, 22 insertions(+), 3 deletions(-)

diff --git a/moving_section.hpp b/moving_section.hpp
index f22cc80d..d99c2bc6 100644
--- a/moving_section.hpp
+++ b/moving_section.hpp
@@ -21,14 +21,22 @@ namespace iter {
 
     template <typename Container>
         struct moving_section_iter {
-            Container && container;
+            typename 
+                std::conditional<std::is_lvalue_reference<Container>::value,
+                Container&,
+                const Container &>::type container;
+            //Container && container;
             using Iterator = decltype(container.begin());
             std::vector<Iterator> section;
             size_t section_size = 0;
             moving_section_iter(Container && c, size_t s) :
                 container(std::forward<Container>(c)),section_size(s) {
-                    for (size_t i = 0; i < section_size; ++i) 
-                        section.push_back(container.begin()+i);
+                    size_t i = 0;
+                    for (auto iter = container.begin(); i < section_size;++iter,++i) {
+                        section.push_back(iter);
+                    }
+                    //for (size_t i = 0; i < section_size; ++i) 
+                      //  section.push_back(container.begin()+i);
                 }
             moving_section_iter(Container && c) : container(std::forward<Container>(c))
             //creates the end iterator
diff --git a/tests/testcommand_chains.cpp b/tests/testcommand_chains.cpp
index 98c6f1ea..eaeeb9eb 100644
--- a/tests/testcommand_chains.cpp
+++ b/tests/testcommand_chains.cpp
@@ -41,5 +41,16 @@ int main() {
                 << std::get<1>(t) << std::endl;
         }
     }
+    std::cout << std::endl;
+    {
+        std::vector<int> vec1{1,2,3,4,5,6};
+        std::vector<int> vec2{7,8,9,10};
+        std::vector<std::string> strvec
+        {"We're","done","when","I","say","we're","done"};
+        for (auto s : moving_section(chain(vec1,vec2),4)) {
+            for (auto i : s) std::cout << i << " ";
+            std::cout<<std::endl;
+        }
+    }
     return 0;
 }

From 6d6e35246bcd589e62ebdbc26f98078f00bec298 Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Fri, 11 Oct 2013 17:40:24 -0400
Subject: [PATCH 0086/1866] added increased chainability to grouper

---
 grouper.hpp                  | 27 ++++++++++++++++++++++-----
 itertools.hpp                |  1 +
 tests/testcommand_chains.cpp | 11 +++++++++--
 3 files changed, 32 insertions(+), 7 deletions(-)

diff --git a/grouper.hpp b/grouper.hpp
index e8761647..5dc7aab6 100644
--- a/grouper.hpp
+++ b/grouper.hpp
@@ -23,7 +23,11 @@ namespace iter {
     template <typename Container>
     class grouper_iter {
         private:
-            Container && container;
+            typename 
+                std::conditional<std::is_lvalue_reference<Container>::value,
+                Container&,
+                const Container &>::type container;
+            //Container && container;
             using Iterator = decltype(container.begin());
             using Deref_type =
                 std::vector<
@@ -48,8 +52,12 @@ namespace iter {
                     this->not_done = false;
                     return;
                 }
-                for (size_t i = 0; i < this->group_size; ++i) 
-                    this->group.push_back(this->container.begin() + i);
+                size_t i = 0;
+                for (auto iter = container.begin(); i < group_size;++i,++iter) {
+                    group.push_back(iter);
+                }
+                //for (size_t i = 0; i < this->group_size; ++i) 
+                  //  this->group.push_back(this->container.begin() + i);
             }
 
             //seems like conclassor is same as moving_section_iter
@@ -60,13 +68,22 @@ namespace iter {
                 group.push_back(container.end());
             }
 
+            //plan to conditionally check for existence of +=
+            /*
+            template<typename> struct int_{typedef int type;};dd
+            template <typename int_<decltype(Iterator::operator+=)>::type = 0>
             grouper_iter & operator++() {
                 for (auto & iter : this->group) {
                     iter += this->group_size;
                 }
                 return *this;
+            }*/
+            grouper_iter & operator++() {
+                for (auto & iter : this->group) {
+                    for(size_t i = 0; i < group_size;++i,++iter);
+                }
+                return *this;
             }
-
             bool operator!=(const grouper_iter &) const {
                 return this->not_done;
             }
@@ -74,7 +91,7 @@ namespace iter {
             Deref_type operator*() {
                 Deref_type vec;
                 for (auto i : this->group) {
-                    if(i == this->container.end()) {
+                    if(!(i != this->container.end())) {
                         this->not_done = false;
                         break;
                     } 
diff --git a/itertools.hpp b/itertools.hpp
index fe40a3e3..e0214b96 100644
--- a/itertools.hpp
+++ b/itertools.hpp
@@ -25,6 +25,7 @@
 #include "zip_longest.hpp"
 #include "powerset.hpp"
 #include "moving_section.hpp"
+#include "grouper.hpp"
 
 //not sure if should include "iterator_range.hpp"
 //since it's already in everything
diff --git a/tests/testcommand_chains.cpp b/tests/testcommand_chains.cpp
index eaeeb9eb..7bc48d2d 100644
--- a/tests/testcommand_chains.cpp
+++ b/tests/testcommand_chains.cpp
@@ -45,12 +45,19 @@ int main() {
     {
         std::vector<int> vec1{1,2,3,4,5,6};
         std::vector<int> vec2{7,8,9,10};
-        std::vector<std::string> strvec
-        {"We're","done","when","I","say","we're","done"};
         for (auto s : moving_section(chain(vec1,vec2),4)) {
             for (auto i : s) std::cout << i << " ";
             std::cout<<std::endl;
         }
     }
+    std::cout << std::endl;
+    {
+        std::vector<int> vec1{1,2,3,4,5,6};
+        std::vector<int> vec2{7,8,9,10};
+        for (auto s : grouper(chain(vec1,vec2),3)) {
+            for (auto i : s) std::cout << i << " ";
+            std::cout<<std::endl;
+        }
+    }
     return 0;
 }

From 7fdba3fe9651512483a655743cc05a14e4d67784 Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Sat, 12 Oct 2013 16:13:17 -0400
Subject: [PATCH 0087/1866] updated iter_ideas

---
 iter_ideas.txt | 34 ++++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/iter_ideas.txt b/iter_ideas.txt
index be6d2b9c..465fe336 100644
--- a/iter_ideas.txt
+++ b/iter_ideas.txt
@@ -20,3 +20,37 @@ useful if a lot of the containers are of different sizes. may want to write
 a different zip_get that works better with optional
 
 Might be a good idea to do a powerset function
+
+Recipes: 
+Not all of the recipes are useful, IMO here are the ones I think we should do
+
+------------------------------------------------------------------------------
+take(n, range)
+
+takes first n items from range and turns it into its own list
+
+------------------------------------------------------------------------------
+quantify(range,predicate)
+
+return amount of times predicate is true
+
+------------------------------------------------------------------------------
+def flatten(listoflists)
+
+flattens one level of nesting
+would be tricky in c++ but kinda useful
+
+------------------------------------------------------------------------------
+roundrobin(Containers ... containers)
+    
+takes the first element off in sequence
+
+------------------------------------------------------------------------------
+unique_everseen(range)
+
+only shows unique elements
+
+------------------------------------------------------------------------------
+unique_justseen(range)
+
+if multiple are the same in a row only display the first one

From 3c3b915dbd8991383ebd9515de46b2f9a77d7f81 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 13 Oct 2013 18:40:40 -0700
Subject: [PATCH 0088/1866] Complete rewrite of filterfalse

Tosses the new classes in favor of wrapper function and extra classes to
build filterfalse() ontop of filter()
---
 filterfalse.hpp | 226 ++++++++++++++----------------------------------
 1 file changed, 64 insertions(+), 162 deletions(-)

diff --git a/filterfalse.hpp b/filterfalse.hpp
index feaaab2f..e24ab9dc 100644
--- a/filterfalse.hpp
+++ b/filterfalse.hpp
@@ -1,179 +1,81 @@
-#ifndef FILTERFALSE__H__
-#define FILTERFALSE__H__
+#ifndef FILTER_FALSE__HPP__
+#define FILTER_FALSE__HPP__
 
 #include "filter.hpp"
 
 namespace iter {
 
-    //Forward declarations of FilterFalse and filterfalse
-    template <typename FilterFunc, typename Container>
-    class FilterFalse;
+    namespace detail {
 
-    template <typename FilterFunc, typename Container>
-    FilterFalse<FilterFunc, Container> filterfalse(FilterFunc, Container &);
+        // Callable object that reverses the boolean result of another
+        // callable, taking the object in a Container's iterator
+        template <typename FilterFunc, typename Container>
+        class PredicateFlipper {
+            private:
+                FilterFunc filter_func;
 
-    template <typename FilterFunc, typename Container>
-    class FilterFalse : public Filter<FilterFunc, Container> {
-        // The filterfalse function is the only thing allowed to
-        // create a FilterFalse
-        friend FilterFalse filterfalse<FilterFunc, Container>(
-                FilterFunc, Container &);
-        using Base = Filter<FilterFunc, Container>;
-
-        public:
-            using Filter<FilterFunc, Container>::Filter;
-
-            class Iterator {
-                protected:
-                    typename Base::contained_iter_type sub_iter;
-                    const typename Base::contained_iter_type sub_end;
-                    FilterFunc filter_func;
-
-                    // skip every element that is true ender the predicate
-                    void skip_passes() { 
-                        while (this->sub_iter != this->sub_end
-                                && this->filter_func(*this->sub_iter)) {
-                            ++this->sub_iter;
-                        }
-                    }
-
-                public:
-                    Iterator (typename Base::contained_iter_type iter,
-                            typename Base::contained_iter_type end,
-                            FilterFunc filter_func) :
-                        sub_iter(iter),
-                        sub_end(end),
-                        filter_func(filter_func)
-                    { 
-                        this->skip_passes();
-                    } 
-
-                    typename Base::contained_iter_ret operator*() const {
-                        return *this->sub_iter;
-                    }
-
-                    Iterator & operator++() { 
-                        ++this->sub_iter;
-                        this->skip_passes();
-                        return *this;
-                    }
-
-                    bool operator!=(const Iterator & other) const {
-                        return this->sub_iter != other.sub_iter;
-                    }
-            };
-
-            Iterator begin() const {
-                return Iterator(
-                        this->container.begin(),
-                        this->container.end(),
-                        this->filter_func);
-            }
-
-            Iterator end() const {
-                return Iterator(
-                        this->container.end(),
-                        this->container.end(),
-                        this->filter_func);
-            }
-    };
+                using contained_iter_type =
+                    decltype(std::declval<Container>().begin());
 
+                using contained_iter_ret =
+                    decltype(std::declval<contained_iter_type>().operator*());
 
-    template <typename FilterFunc, typename Container>
-    FilterFalse<FilterFunc, Container> filterfalse(FilterFunc filter_func,
-            Container & container) {
-        return FilterFalse<FilterFunc, Container>(filter_func, container);
-    }
+            public:
+                PredicateFlipper(FilterFunc filter_func) :
+                    filter_func(filter_func)
+                { }
 
+                PredicateFlipper() = delete;
+                PredicateFlipper(const PredicateFlipper &) = default;
 
-    //Forward declarations of filterfalseFalseDefault and filterfalse
-    template <typename Container>
-    class filterfalseFalseDefault;
+                // Calls the filter_func 
+                bool operator() (const contained_iter_ret item) const {
+                    return !bool(filter_func(item));
+                }
+        };
+
+        // Reverses the bool() conversion result of anything that supports a
+        // bool conversion
+        template <typename Container>
+        class BoolFlipper {
+            private:
+                using contained_iter_type =
+                    decltype(std::declval<Container>().begin());
+
+                using contained_iter_ret =
+                    decltype(std::declval<contained_iter_type>().operator*());
+
+            public:
+                BoolFlipper() = default;
+                BoolFlipper(const BoolFlipper &) = default;
+                bool operator() (const contained_iter_ret item) const {
+                    return !bool(item);
+                }
+        };
 
-    template <typename Container>
-    filterfalseFalseDefault<Container> filterfalse(Container &);
 
-    template <typename Container>
-    class filterfalseFalseDefault {
-        protected:
-            Container & container;
-
-            // The filterfalse function is the only thing allowed to create a
-            // filterfalseFalseDefault
-            friend filterfalseFalseDefault filterfalse<Container>(Container &);
-            // Type of the Container::Iterator, but since the name of that 
-            // iterator can be anything, we have to grab it with this
-            using contained_iter_type = decltype(container.begin());
-
-            // The type returned when dereferencing the Container::Iterator
-            using contained_iter_ret = decltype(container.begin().operator*());
-
-            // Value constructor for use only in the filterfalse function
-            filterfalseFalseDefault(Container & container) :
-                container(container)
-            { }
-            filterfalseFalseDefault () = delete;
-            filterfalseFalseDefault & operator=(const filterfalseFalseDefault &) = delete;
-
-        public:
-            filterfalseFalseDefault(const filterfalseFalseDefault &) = default;
-            class Iterator {
-                protected:
-                    contained_iter_type sub_iter;
-                    const contained_iter_type sub_end;
-
-                    void skip_passes() { 
-                        while (this->sub_iter != this->sub_end
-                                && *this->sub_iter) {
-                            ++this->sub_iter;
-                        }
-                    }
-
-                public:
-                    Iterator (contained_iter_type iter,
-                            contained_iter_type end) :
-                        sub_iter(iter),
-                        sub_end(end)
-                    { 
-                        this->skip_passes();
-                    } 
-
-                    contained_iter_ret operator*() const {
-                        return *this->sub_iter;
-                    }
-
-                    Iterator & operator++() { 
-                        ++this->sub_iter;
-                        this->skip_passes();
-                        return *this;
-                    }
-
-                    bool operator!=(const Iterator & other) const {
-                        return this->sub_iter != other.sub_iter;
-                    }
-            };
-
-            Iterator begin() const {
-                return Iterator(
-                        this->container.begin(),
-                        this->container.end());
-            }
-
-            Iterator end() const {
-                return Iterator(
-                        this->container.end(),
-                        this->container.end());
-            }
-
-    };
-
-    // Helper function to instantiate a filterfalseFalseDefault
-    template <typename Container>
-    filterfalseFalseDefault<Container> filterfalse(Container & container) {
-        return filterfalseFalseDefault<Container>(container);
     }
-}
 
+    // Creates a PredicateFlipper for the predicate function, which reverses
+    // the bool result of the function.  The PredicateFlipper is then passed
+    // to the normal filter() function
+    template <typename FilterFunc, typename Container>
+    auto filterfalse(FilterFunc filter_func, Container & container) ->
+            decltype(filter(detail::PredicateFlipper<FilterFunc, Container>(
+                            filter_func), container)) {
+        return filter(
+                detail::PredicateFlipper<FilterFunc, Container>(filter_func),
+                container);
+    }
 
+    // Single argument version, uses a BoolFlipper to reverse the truthiness
+    // of an object
+    template <typename Container>
+    auto filterfalse(Container & container) ->
+            decltype(filter(detail::BoolFlipper<Container>(), container)) {
+        return filter(detail::BoolFlipper<Container>(), container);
+    }
+
+}
 
-#endif //ifndef FILTERFALSE__H__
+#endif //#ifndef FILTER_FALSE__HPP__

From a43fa50761b2a3d6836dc982574fb2cd5e815de6 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 13 Oct 2013 18:47:08 -0700
Subject: [PATCH 0089/1866] Additional filterfalse tests

---
 tests/testfilterfalse.cpp | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/tests/testfilterfalse.cpp b/tests/testfilterfalse.cpp
index 3d6816b9..73a8e5eb 100644
--- a/tests/testfilterfalse.cpp
+++ b/tests/testfilterfalse.cpp
@@ -17,7 +17,7 @@ class LessThanValue {
         LessThanValue() = delete;
         LessThanValue(int v) : compare_val(v) { }
         
-        bool operator() (int i) {
+        bool operator() (int i) const {
             return i < this->compare_val;
         }
 };
@@ -42,11 +42,21 @@ int main() {
         std::cout << i << '\n';
     }
 
-    std::cout << "Nonzero ints filter(vec2)\n";
+    std::cout << "zero ints filter(vec2)\n";
     std::vector<int> vec2 {0, 1, 2, 0, 3, 0, 0, 0, 4, 5, 0};
     for (auto i : filterfalse(vec2)) {
         std::cout << i << '\n';
     }
 
+    std::cout << "Constness tests\n";
+    const std::vector<int> cvec(vec);
+    for (auto i : filterfalse(greater_than_four, cvec)) {
+        std::cout << i << '\n';
+    }
+
+    for (auto i : filterfalse([] (const int & i) { return i < 4; }, cvec)) {
+        std::cout << i << '\n';
+    }
+
     return 0;
 }

From a5941aeb57238327134fa4b1248d706ebf17fe81 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 13 Oct 2013 21:08:11 -0700
Subject: [PATCH 0090/1866] Removes FilterDefault, replaces with BoolTester

A callable BoolTester class is passed to the regular Filter class which
is just a wrapper to a bool cast.  This shortens filter.hpp's logic and
duplication greatly.
---
 filter.hpp | 101 +++++++++++------------------------------------------
 1 file changed, 21 insertions(+), 80 deletions(-)

diff --git a/filter.hpp b/filter.hpp
index 1dc32769..d41012d4 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -96,99 +96,40 @@ namespace iter {
 
     };
 
-    // Helper function to instantiate a FilterDefault
+    // Helper function to instantiate a Filter
     template <typename FilterFunc, typename Container>
     Filter<FilterFunc, Container> filter(
             FilterFunc filter_func, Container & container) {
         return Filter<FilterFunc, Container>(filter_func, container);
     }
 
-    //Forward declarations of FilterDefault and filter
-    template <typename Container>
-    class FilterDefault;
-
-    template <typename Container>
-    FilterDefault<Container> filter(Container &);
-
-    template <typename Container>
-    class FilterDefault {
-        protected:
-            Container & container;
-
-            // The filter function is the only thing allowed to create a
-            // FilterDefault
-            friend FilterDefault filter<Container>(Container &);
-            // Type of the Container::Iterator, but since the name of that 
-            // iterator can be anything, we have to grab it with this
-            using contained_iter_type = decltype(container.begin());
+    namespace detail {
 
-            // The type returned when dereferencing the Container::Iterator
-            using contained_iter_ret = decltype(container.begin().operator*());
+        template <typename T>
+        bool boolean_cast(const T & t) {
+            return bool(t);
+        }
 
-            // Value constructor for use only in the filter function
-            FilterDefault(Container & container) :
-                container(container)
-            { }
-            FilterDefault () = delete;
-            FilterDefault & operator=(const FilterDefault &) = delete;
+        template <typename Container>
+        class BoolTester {
+            private:
+                using contained_iter_ret =
+                    decltype(std::declval<Container>().begin().operator*());
 
-        public:
-            FilterDefault(const FilterDefault &) = default;
-            class Iterator {
-                protected:
-                    contained_iter_type sub_iter;
-                    const contained_iter_type sub_end;
-
-                    void skip_failures() { 
-                        while (this->sub_iter != this->sub_end
-                                && !(*this->sub_iter)) {
-                            ++this->sub_iter;
-                        }
-                    }
-
-                public:
-                    Iterator (contained_iter_type iter,
-                            contained_iter_type end) :
-                        sub_iter(iter),
-                        sub_end(end)
-                    { 
-                        this->skip_failures();
-                    } 
-
-                    contained_iter_ret operator*() const {
-                        return *this->sub_iter;
-                    }
-
-                    Iterator & operator++() { 
-                        ++this->sub_iter;
-                        this->skip_failures();
-                        return *this;
-                    }
-
-                    bool operator!=(const Iterator & other) const {
-                        return this->sub_iter != other.sub_iter;
-                    }
-            };
-
-            Iterator begin() const {
-                return Iterator(
-                        this->container.begin(),
-                        this->container.end());
-            }
-
-            Iterator end() const {
-                return Iterator(
-                        this->container.end(),
-                        this->container.end());
-            }
+            public:
+                bool operator() (const contained_iter_ret item) const {
+                    return bool(item);
+                }
+        };
+    }
 
-    };
 
-    // Helper function to instantiate a FilterDefault
     template <typename Container>
-    FilterDefault<Container> filter(Container & container) {
-        return FilterDefault<Container>(container);
+    auto filter(Container & container) ->
+            decltype(filter(detail::BoolTester<Container>(), container)) {
+        return filter(detail::BoolTester<Container>(), container);
     }
+
 }
 
 #endif //ifndef FILTER__H__

From 50a8015f7dadda4bb88f07784dcd8bca34f4e43d Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 13 Oct 2013 22:23:15 -0700
Subject: [PATCH 0091/1866] Makes BoolFlipper a subclass of BoolTester

In filter.hpp, to remove the repetitive 'using' in the similar classes
---
 filter.hpp      |  2 +-
 filterfalse.hpp | 11 +++--------
 2 files changed, 4 insertions(+), 9 deletions(-)

diff --git a/filter.hpp b/filter.hpp
index d41012d4..270678e9 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -112,7 +112,7 @@ namespace iter {
 
         template <typename Container>
         class BoolTester {
-            private:
+            protected:
                 using contained_iter_ret =
                     decltype(std::declval<Container>().begin().operator*());
 
diff --git a/filterfalse.hpp b/filterfalse.hpp
index e24ab9dc..65b3179c 100644
--- a/filterfalse.hpp
+++ b/filterfalse.hpp
@@ -37,17 +37,12 @@ namespace iter {
         // Reverses the bool() conversion result of anything that supports a
         // bool conversion
         template <typename Container>
-        class BoolFlipper {
+        class BoolFlipper : public BoolTester<Container> {
             private:
-                using contained_iter_type =
-                    decltype(std::declval<Container>().begin());
-
-                using contained_iter_ret =
-                    decltype(std::declval<contained_iter_type>().operator*());
+                using contained_iter_ret = 
+                    typename BoolTester<Container>::contained_iter_ret;
 
             public:
-                BoolFlipper() = default;
-                BoolFlipper(const BoolFlipper &) = default;
                 bool operator() (const contained_iter_ret item) const {
                     return !bool(item);
                 }

From 900528d74161d3559e7464012381d9cad06b9c9a Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 14 Oct 2013 00:31:05 -0700
Subject: [PATCH 0092/1866] Shortens using-decltype in PredicateFlipper

---
 filterfalse.hpp | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/filterfalse.hpp b/filterfalse.hpp
index 65b3179c..34b16180 100644
--- a/filterfalse.hpp
+++ b/filterfalse.hpp
@@ -14,11 +14,8 @@ namespace iter {
             private:
                 FilterFunc filter_func;
 
-                using contained_iter_type =
-                    decltype(std::declval<Container>().begin());
-
                 using contained_iter_ret =
-                    decltype(std::declval<contained_iter_type>().operator*());
+                    decltype(std::declval<Container>().begin().operator*());
 
             public:
                 PredicateFlipper(FilterFunc filter_func) :

From 0bf5c7b40426775793da55c3e64293517f9f959d Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 14 Oct 2013 00:47:27 -0700
Subject: [PATCH 0093/1866] Chanes private to protected in Filter

Since it's not being subclassed anymore.
---
 filter.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/filter.hpp b/filter.hpp
index 270678e9..0b201383 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -14,7 +14,7 @@ namespace iter {
 
     template <typename FilterFunc, typename Container>
     class Filter {
-        protected:
+        private:
             Container & container;
             FilterFunc filter_func;
 

From 3f8cfb3f2a19a1d9eebbbe9bd7378008b7e4817c Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 14 Oct 2013 23:00:11 -0700
Subject: [PATCH 0094/1866] Initial version of sorted

Yields iterators rather than references.
---
 sorted.hpp | 61 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 61 insertions(+)
 create mode 100644 sorted.hpp

diff --git a/sorted.hpp b/sorted.hpp
new file mode 100644
index 00000000..807ec516
--- /dev/null
+++ b/sorted.hpp
@@ -0,0 +1,61 @@
+#ifndef SORTED__HPP__
+#define SORTED__HPP__
+
+#include <algorithm>
+#include <vector>
+
+namespace iter {
+
+    template <typename Container>
+    class Sorted;
+
+    template <typename Container>
+    Sorted<Container> sorted(Container &);
+
+    template <typename Container>
+    class Sorted {
+        private:
+            friend Sorted sorted<Container>(Container &);
+
+            using contained_iter_type =
+                decltype(std::declval<Container>().begin());
+
+            std::vector<contained_iter_type> sorted_iters;
+
+            Sorted() = delete;
+            Sorted & operator=(const Sorted &) = delete;
+
+            Sorted(Container & container) {
+                for (auto iter = container.begin();
+                        iter != container.end();
+                        ++iter) {
+                    sorted_iters.push_back(iter);
+                }
+                std::sort(sorted_iters.begin(), sorted_iters.end(),
+                        [] (const contained_iter_type & it1,
+                            const contained_iter_type & it2)
+                        { return *it1 < *it2; });
+            }
+
+
+        public:
+            Sorted(const Sorted &) = default;
+            auto begin() const -> decltype(sorted_iters.begin()) {
+                return sorted_iters.begin();
+            }
+            auto end() const -> decltype(sorted_iters.end()) {
+                return sorted_iters.end();
+            }
+
+    };
+
+    template <typename Container>
+    Sorted<Container> sorted(Container & container) { 
+        return Sorted<Container>(container);
+    }
+
+}
+
+
+
+#endif //#ifndef SORTED__HPP__

From 981eeab405d92a8e747e017e88b6b04cb9d928d0 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 15 Oct 2013 00:47:29 -0700
Subject: [PATCH 0095/1866] Reworks sorted to yield from *iterator

Rather than the iterator itself, a wrapper class dereferences the
iterator.
---
 sorted.hpp | 41 ++++++++++++++++++++++++++++++++---------
 1 file changed, 32 insertions(+), 9 deletions(-)

diff --git a/sorted.hpp b/sorted.hpp
index 807ec516..08a3a91d 100644
--- a/sorted.hpp
+++ b/sorted.hpp
@@ -5,7 +5,6 @@
 #include <vector>
 
 namespace iter {
-
     template <typename Container>
     class Sorted;
 
@@ -22,31 +21,57 @@ namespace iter {
 
             std::vector<contained_iter_type> sorted_iters;
 
+            using sorted_iter_type = decltype(sorted_iters.begin());
+            using contained_iter_ret = 
+                decltype(sorted_iters.begin().operator*().operator*());
+
             Sorted() = delete;
             Sorted & operator=(const Sorted &) = delete;
 
             Sorted(Container & container) {
+                // Fill the sorted_iters vector with an iterator to each
+                // element in the container
                 for (auto iter = container.begin();
                         iter != container.end();
                         ++iter) {
                     sorted_iters.push_back(iter);
                 }
+
+                // sort by comparing the elements that the iterators point to
                 std::sort(sorted_iters.begin(), sorted_iters.end(),
                         [] (const contained_iter_type & it1,
                             const contained_iter_type & it2)
                         { return *it1 < *it2; });
             }
 
-
         public:
+
+            // Iterates over a series of Iterators, automatically dereferencing
+            // them when accessed with operator *
+            class IteratorIterator : public sorted_iter_type {
+                public:
+                    IteratorIterator(sorted_iter_type iter) :
+                        sorted_iter_type(iter)
+                    { }
+                    IteratorIterator(const IteratorIterator &) = default;
+
+                    // Dereference the current iterator before returning
+                    contained_iter_ret operator*() {
+                        return *sorted_iter_type::operator*();
+                    }
+            };
+
             Sorted(const Sorted &) = default;
-            auto begin() const -> decltype(sorted_iters.begin()) {
-                return sorted_iters.begin();
-            }
-            auto end() const -> decltype(sorted_iters.end()) {
-                return sorted_iters.end();
+
+            IteratorIterator begin() {
+                IteratorIterator iteriter(sorted_iters.begin());
+                return iteriter;
             }
 
+            IteratorIterator end() {
+                IteratorIterator iteriter(sorted_iters.end());
+                return iteriter;
+            }
     };
 
     template <typename Container>
@@ -56,6 +81,4 @@ namespace iter {
 
 }
 
-
-
 #endif //#ifndef SORTED__HPP__

From 87e3215cdf00c1b75816207a45a8bf1d9ceac66c Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 15 Oct 2013 00:54:25 -0700
Subject: [PATCH 0096/1866] Adds testsorted

---
 tests/testsorted.cpp | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 tests/testsorted.cpp

diff --git a/tests/testsorted.cpp b/tests/testsorted.cpp
new file mode 100644
index 00000000..07d1e7cf
--- /dev/null
+++ b/tests/testsorted.cpp
@@ -0,0 +1,21 @@
+#include <sorted.hpp>
+
+#include <iostream>
+#include <vector>
+
+using iter::sorted;
+
+int main()
+{
+    std::vector<int> vec = {19, 3, 45, 32, 10, 0, 90, 15, 1, 7, 5, 6, 69};
+    for (auto i : sorted(vec)) {
+        std::cout << i << '\n';
+    }
+
+    const std::vector<int> cvec(vec);
+    for (auto i : sorted(cvec)) {
+        std::cout << i << '\n';
+    }
+
+    return 0;
+}

From 0fc122a10b9c1ca991e0ebb7d41b7df92baf115d Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 15 Oct 2013 00:54:55 -0700
Subject: [PATCH 0097/1866] Adds testsorted to gitignore

---
 tests/.gitignore | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tests/.gitignore b/tests/.gitignore
index 1a5a4160..323a4686 100644
--- a/tests/.gitignore
+++ b/tests/.gitignore
@@ -24,4 +24,6 @@ testcount
 testgrouper
 testcommand_chains
 testgroupby
+testsorted
 .sconsign.dblite
+

From 2f6ed312e8530029a153ea5ca7207a66a0e21541 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 15 Oct 2013 00:55:33 -0700
Subject: [PATCH 0098/1866] Adds testsorted to SConstruct

---
 tests/SConstruct | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tests/SConstruct b/tests/SConstruct
index e2cd1986..91a52b9e 100644
--- a/tests/SConstruct
+++ b/tests/SConstruct
@@ -43,6 +43,7 @@ progs = Split( '''
         chain
         command_chains
         groupby
+        sorted
         ''')
 
 

From e99af983118f494f6ee1947ff746dce9f02652f4 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 17 Oct 2013 02:20:00 -0700
Subject: [PATCH 0099/1866] Replaces g++ with c++

---
 tests/SConstruct | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/SConstruct b/tests/SConstruct
index 91a52b9e..90ffa6cf 100644
--- a/tests/SConstruct
+++ b/tests/SConstruct
@@ -2,7 +2,7 @@ import platform
 import os
 
 env = Environment(
-    CXX='g++',
+    CXX='c++',
     CXXFLAGS=' -g -Wall -Wextra -pedantic -std=c++11 -I/usr/local/include',
     CPPPATH='..',
     LINKFLAGS='-L/usr/local/lib')

From 485e9e894f70bd3c601bf26f120d6a1a67c811e2 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 17 Oct 2013 02:22:58 -0700
Subject: [PATCH 0100/1866] Formats zip.hpp

---
 zip.hpp | 53 ++++++++++++++++++++++++++++++++---------------------
 1 file changed, 32 insertions(+), 21 deletions(-)

diff --git a/zip.hpp b/zip.hpp
index 1542f92b..5b3374aa 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -1,28 +1,35 @@
 #ifndef ZIP_HPP
 #define ZIP_HPP
 
-#include <tuple>
 #include "iterator_range.hpp"
 
+#include <tuple>
+
 namespace iter {
     template <typename ... Rest>
-        struct zip_iter;
+    class zip_iter;
+
     template <typename ... Containers>
-        auto zip(Containers && ... containers) ->
-        iterator_range<zip_iter<decltype(containers.begin())...>>
-        {
-            auto begin = zip_iter<decltype(containers.begin())...>(containers.begin()...);
-            auto end = zip_iter<decltype(containers.end())...>(containers.end()...);
-            return iterator_range<decltype(begin)>(begin,end);
-        }
-    template <typename Iterator>
-        struct zip_iter<Iterator> {
+    auto zip(Containers && ... containers) ->
+            iterator_range<zip_iter<decltype(containers.begin())...>>
+    {
+        auto begin =
+            zip_iter<decltype(containers.begin())...>(containers.begin()...);
+
+        auto end =
+            zip_iter<decltype(containers.end())...>(containers.end()...);
+
+        return iterator_range<decltype(begin)>(begin,end);
+    }
 
+
+    template <typename Iterator>
+    class zip_iter<Iterator> {
         private:
             Iterator iter;
 
         public:
-            using Elem_t = decltype(*iter);
+            using elem_type = decltype(*iter);
             zip_iter(const Iterator & i) :
                 iter(i){ }
 
@@ -37,7 +44,8 @@ namespace iter {
             bool operator!=(const zip_iter & rhs) const {
                 return (this->iter != rhs.iter);
             }
-        };  /* 
+    };
+#if 0
     template <typename First, typename Second>
         struct zip_iter<First,Second> {
 
@@ -63,18 +71,18 @@ namespace iter {
             bool operator!=(const zip_iter & rhs) const {
                 return (this->iter1 != rhs.iter1) && (this->iter2 != rhs.iter2);
             }
-        };*/
+        };
+#endif
     //this specialization commented out 
     template <typename First, typename ... Rest>
-        struct zip_iter<First,Rest...> {
-
+    class zip_iter<First,Rest...> {
         private:
             First iter;
             zip_iter<Rest...> inner_iter;
             
         public:
-            using Elem_t = decltype(*iter);
-            using tuple_t = 
+            using elem_type = decltype(*iter);
+            using tuple_type = 
                 decltype(std::tuple_cat(std::tie(*iter),*inner_iter));
 
             zip_iter(const First & f, const Rest & ... rest) :
@@ -82,19 +90,22 @@ namespace iter {
                 inner_iter(rest...) {}
 
 
-            tuple_t operator*()
+            tuple_type operator*()
             {
                 return std::tuple_cat(std::tie(*iter),*inner_iter);
             }
+
             zip_iter & operator++() {
                 ++iter;
                 ++inner_iter;
                 return *this;
             }
+
             bool operator!=(const zip_iter & rhs) const {
-                return (this->iter != rhs.iter) && (this->inner_iter != rhs.inner_iter);
+                return (this->iter != rhs.iter) &&
+                    (this->inner_iter != rhs.inner_iter);
             }
-        };
+    };
 }
 
 #endif //ZIP_HPP

From 4487fa8ee1ef9a8597c1d9641b0cf430bd78d293 Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Sat, 19 Oct 2013 14:58:42 -0400
Subject: [PATCH 0101/1866] added unique_justseen having some trouble creating
 the return type

---
 tests/.gitignore              |  1 +
 tests/SConstruct              |  1 +
 tests/testunique_justseen.cpp | 14 ++++++++++++++
 unique_justseen.hpp           | 28 ++++++++++++++++++++++++++++
 4 files changed, 44 insertions(+)
 create mode 100644 tests/testunique_justseen.cpp
 create mode 100644 unique_justseen.hpp

diff --git a/tests/.gitignore b/tests/.gitignore
index 323a4686..4a4246b2 100644
--- a/tests/.gitignore
+++ b/tests/.gitignore
@@ -25,5 +25,6 @@ testgrouper
 testcommand_chains
 testgroupby
 testsorted
+testunique_justseen
 .sconsign.dblite
 
diff --git a/tests/SConstruct b/tests/SConstruct
index 90ffa6cf..59c81627 100644
--- a/tests/SConstruct
+++ b/tests/SConstruct
@@ -44,6 +44,7 @@ progs = Split( '''
         command_chains
         groupby
         sorted
+        unique_justseen
         ''')
 
 
diff --git a/tests/testunique_justseen.cpp b/tests/testunique_justseen.cpp
new file mode 100644
index 00000000..23587aa6
--- /dev/null
+++ b/tests/testunique_justseen.cpp
@@ -0,0 +1,14 @@
+#include <unique_justseen.hpp>
+
+#include <vector>
+#include <iostream>
+
+using iter::unique_justseen;
+
+int main() {
+    std::vector<int> v {1,1,1,2,2,4,4,5,6,7,8,8,8,8,9,9};
+    for (auto & i : unique_justseen(v)) {
+        std::cout << i << " ";
+    }std::cout << std::endl;
+    return 0;
+}
diff --git a/unique_justseen.hpp b/unique_justseen.hpp
new file mode 100644
index 00000000..d7fa6ea0
--- /dev/null
+++ b/unique_justseen.hpp
@@ -0,0 +1,28 @@
+#ifndef UNIQUE_JUSTSEEN_HPP
+#define UNIQUE_JUSTSEEN_HPP
+
+#include "filter.hpp"
+#include <type_traits>
+#include <functional>
+
+namespace iter 
+{
+    //this should be self evident but unique_justseen places the requirement 
+    //on the elements in the container have the != operator overloaded
+    template <typename Container>
+    auto unique_justseen(Container && container) 
+    -> decltype(filter(std::function<bool(decltype(container.front))>(),container))
+    {
+        using elem_t = decltype(container.front());
+        auto last = container.begin();
+        std::function<bool(elem_t)> func = [&last,container](elem_t e) 
+                {
+                    if (last == container.begin())return true;
+                    else return *(++last) != e;
+                };
+        return filter(func, container);
+    }
+}
+
+#endif //UNIQUE_JUSTSEEN_HPP
+    

From 72950f9f6b36748f9218481f4afd142f6898c295 Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Sat, 19 Oct 2013 15:01:35 -0400
Subject: [PATCH 0102/1866] modified git ignore

---
 tests/.gitignore | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tests/.gitignore b/tests/.gitignore
index 4a4246b2..0609433f 100644
--- a/tests/.gitignore
+++ b/tests/.gitignore
@@ -1,4 +1,5 @@
 *.o
+.*.swp
 testchain
 testcycle
 testenumerate

From 9e141c6e343501ac79165c46dbf1946465da6c9e Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Sat, 19 Oct 2013 16:44:33 -0400
Subject: [PATCH 0103/1866] Finished unique_justseen

---
 tests/.gitignore              |  2 +-
 tests/testunique_justseen.cpp |  4 ++--
 unique_justseen.hpp           | 16 +++++++++++-----
 3 files changed, 14 insertions(+), 8 deletions(-)

diff --git a/tests/.gitignore b/tests/.gitignore
index 0609433f..3d258104 100644
--- a/tests/.gitignore
+++ b/tests/.gitignore
@@ -1,5 +1,5 @@
 *.o
-.*.swp
+*.swp
 testchain
 testcycle
 testenumerate
diff --git a/tests/testunique_justseen.cpp b/tests/testunique_justseen.cpp
index 23587aa6..7c1dc44e 100644
--- a/tests/testunique_justseen.cpp
+++ b/tests/testunique_justseen.cpp
@@ -1,13 +1,13 @@
-#include <unique_justseen.hpp>
 
 #include <vector>
 #include <iostream>
 
+#include <unique_justseen.hpp>
 using iter::unique_justseen;
 
 int main() {
     std::vector<int> v {1,1,1,2,2,4,4,5,6,7,8,8,8,8,9,9};
-    for (auto & i : unique_justseen(v)) {
+    for (auto i : unique_justseen(v)) {
         std::cout << i << " ";
     }std::cout << std::endl;
     return 0;
diff --git a/unique_justseen.hpp b/unique_justseen.hpp
index d7fa6ea0..c50ba1e0 100644
--- a/unique_justseen.hpp
+++ b/unique_justseen.hpp
@@ -4,6 +4,7 @@
 #include "filter.hpp"
 #include <type_traits>
 #include <functional>
+#include <utility>
 
 namespace iter 
 {
@@ -11,16 +12,21 @@ namespace iter
     //on the elements in the container have the != operator overloaded
     template <typename Container>
     auto unique_justseen(Container && container) 
-    -> decltype(filter(std::function<bool(decltype(container.front))>(),container))
+    -> Filter<std::function<bool(decltype(container.front()))>,Container>
     {
         using elem_t = decltype(container.front());
         auto last = container.begin();
-        std::function<bool(elem_t)> func = [&last,container](elem_t e) 
+        std::function<bool(elem_t)> func = [last,container] (elem_t e) mutable 
                 {
-                    if (last == container.begin())return true;
-                    else return *(++last) != e;
+                    if (last == container.begin()) {
+                        return true;
+                    }
+                    else { 
+                        return *(++last) != e;
+                    }
                 };
-        return filter(func, container);
+        //return filter(func,std::forward<Container>(container));
+        return filter<decltype(func),Container>(func,std::forward<Container>(container));
     }
 }
 

From c30138938df39e7d8f50ed197af2183fe043d082 Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Sat, 19 Oct 2013 17:44:59 -0400
Subject: [PATCH 0104/1866] Did unique everseen

---
 tests/SConstruct              |  1 +
 tests/testunique_everseen.cpp | 29 +++++++++++++++++++++++++++++
 unique_everseen.hpp           | 33 +++++++++++++++++++++++++++++++++
 3 files changed, 63 insertions(+)
 create mode 100644 tests/testunique_everseen.cpp
 create mode 100644 unique_everseen.hpp

diff --git a/tests/SConstruct b/tests/SConstruct
index 59c81627..d8a46d34 100644
--- a/tests/SConstruct
+++ b/tests/SConstruct
@@ -45,6 +45,7 @@ progs = Split( '''
         groupby
         sorted
         unique_justseen
+        unique_everseen
         ''')
 
 
diff --git a/tests/testunique_everseen.cpp b/tests/testunique_everseen.cpp
new file mode 100644
index 00000000..0c77a9f7
--- /dev/null
+++ b/tests/testunique_everseen.cpp
@@ -0,0 +1,29 @@
+
+#include <vector>
+#include <iostream>
+
+#include <unique_everseen.hpp>
+using iter::unique_everseen;
+
+int main() {
+    {
+        //should work same as justseen here
+        std::vector<int> v {1,1,1,2,2,3,4,4,5,6,7,8,8,8,8,9,9};
+        for (auto i : unique_everseen(v)) {
+            std::cout << i << " ";
+        }std::cout << std::endl;
+    }
+    {
+        //should work same as justseen here
+        std::vector<int> v {1,2,3,4,3,2,1,5,6,7,7,8,9,8,9,6};
+        for (auto i : unique_everseen(v)) {
+            std::cout << i << " ";
+        }std::cout << std::endl;
+        std::unordered_map<int,bool> map;
+        [&map]() {
+            map[70]=true;
+            std::cout << map[60];
+        }();
+    }
+    return 0;
+}
diff --git a/unique_everseen.hpp b/unique_everseen.hpp
new file mode 100644
index 00000000..5e99c9fb
--- /dev/null
+++ b/unique_everseen.hpp
@@ -0,0 +1,33 @@
+#ifndef UNIQUE_EVERSEEN_HPP
+#define UNIQUE_EVERSEEN_HPP
+
+#include "filter.hpp"
+#include <type_traits>
+#include <functional>
+#include <utility>
+#include <unordered_map>
+
+namespace iter 
+{
+    //the container type must be usable in an unordered_map to achieve constant
+    //performance checking if it has ever been seen
+    template <typename Container>
+    auto unique_everseen(Container && container) 
+    -> Filter<std::function<bool(decltype(container.front()))>,Container>
+    {
+        using elem_t = decltype(container.front());
+        std::unordered_map<typename std::remove_reference<elem_t>::type,bool> elem_seen;
+        std::function<bool(elem_t)> func = [elem_seen](elem_t e) mutable
+        //not sure why but elem seen has to be captured by value
+                {
+                    if(!elem_seen[e]) {
+                        elem_seen[e] = true;
+                        return true;
+                    }
+                    else return false;
+                };
+        return filter<decltype(func),Container>(func,std::forward<Container>(container));
+    }
+}
+
+#endif //UNIQUE_EVERSEEN_HPP

From 8e8ee2ca4884d744386506af42235626a6557c91 Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Sun, 20 Oct 2013 00:40:03 -0400
Subject: [PATCH 0105/1866] Fixed comment in unique_everseen

---
 tests/.gitignore              | 1 +
 tests/testunique_everseen.cpp | 5 -----
 unique_everseen.hpp           | 3 ++-
 3 files changed, 3 insertions(+), 6 deletions(-)

diff --git a/tests/.gitignore b/tests/.gitignore
index 3d258104..3daf97d6 100644
--- a/tests/.gitignore
+++ b/tests/.gitignore
@@ -27,5 +27,6 @@ testcommand_chains
 testgroupby
 testsorted
 testunique_justseen
+testunique_everseen
 .sconsign.dblite
 
diff --git a/tests/testunique_everseen.cpp b/tests/testunique_everseen.cpp
index 0c77a9f7..e373a8a3 100644
--- a/tests/testunique_everseen.cpp
+++ b/tests/testunique_everseen.cpp
@@ -19,11 +19,6 @@ int main() {
         for (auto i : unique_everseen(v)) {
             std::cout << i << " ";
         }std::cout << std::endl;
-        std::unordered_map<int,bool> map;
-        [&map]() {
-            map[70]=true;
-            std::cout << map[60];
-        }();
     }
     return 0;
 }
diff --git a/unique_everseen.hpp b/unique_everseen.hpp
index 5e99c9fb..52632636 100644
--- a/unique_everseen.hpp
+++ b/unique_everseen.hpp
@@ -18,7 +18,8 @@ namespace iter
         using elem_t = decltype(container.front());
         std::unordered_map<typename std::remove_reference<elem_t>::type,bool> elem_seen;
         std::function<bool(elem_t)> func = [elem_seen](elem_t e) mutable
-        //not sure why but elem seen has to be captured by value
+        //has to be captured by value because it goes out of scope when the 
+        //function returns
                 {
                     if(!elem_seen[e]) {
                         elem_seen[e] = true;

From 73c10d2a078beb11dcd958ca960a59a4f97ee116 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 22 Oct 2013 15:19:02 -0700
Subject: [PATCH 0106/1866] Adds test with compare function to testsorted

---
 tests/testsorted.cpp | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/tests/testsorted.cpp b/tests/testsorted.cpp
index 07d1e7cf..7abdafc6 100644
--- a/tests/testsorted.cpp
+++ b/tests/testsorted.cpp
@@ -2,6 +2,7 @@
 
 #include <iostream>
 #include <vector>
+#include <string>
 
 using iter::sorted;
 
@@ -17,5 +18,14 @@ int main()
         std::cout << i << '\n';
     }
 
+    std::vector<std::string> svec = {"hello", "everyone", "thanks", "for",
+                                     "having", "me", "here", "today"};
+    for (auto s : sorted(svec,
+                [] (const std::string & s1, const std::string & s2) {
+                    return s1[1] < s2[1]; })) {
+        std::cout << s << '\n';
+    }
+        
+
     return 0;
 }

From f219bf63a4d55947b9c3777ee2013a5f25f7dbb5 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 22 Oct 2013 15:26:39 -0700
Subject: [PATCH 0107/1866] Adds comparison function option to sorted

It was a tough decision to make between a comparison function and a
key_function.  I decided on a comparison function since it's so much
more common in c++.  Ideally I could support both, but for now I'm
setting it as comparison function.
---
 sorted.hpp | 41 +++++++++++++++++++++++++++++------------
 1 file changed, 29 insertions(+), 12 deletions(-)

diff --git a/sorted.hpp b/sorted.hpp
index 08a3a91d..b684ddfe 100644
--- a/sorted.hpp
+++ b/sorted.hpp
@@ -5,16 +5,17 @@
 #include <vector>
 
 namespace iter {
-    template <typename Container>
+    template <typename Container, typename CompareFunc>
     class Sorted;
 
-    template <typename Container>
-    Sorted<Container> sorted(Container &);
+    template <typename Container, typename CompareFunc>
+    Sorted<Container, CompareFunc> sorted(Container &, CompareFunc);
 
-    template <typename Container>
+    template <typename Container, typename CompareFunc>
     class Sorted {
         private:
-            friend Sorted sorted<Container>(Container &);
+            friend Sorted
+                sorted<Container, CompareFunc>(Container &, CompareFunc);
 
             using contained_iter_type =
                 decltype(std::declval<Container>().begin());
@@ -28,7 +29,7 @@ namespace iter {
             Sorted() = delete;
             Sorted & operator=(const Sorted &) = delete;
 
-            Sorted(Container & container) {
+            Sorted(Container & container, CompareFunc compare_func) {
                 // Fill the sorted_iters vector with an iterator to each
                 // element in the container
                 for (auto iter = container.begin();
@@ -39,13 +40,15 @@ namespace iter {
 
                 // sort by comparing the elements that the iterators point to
                 std::sort(sorted_iters.begin(), sorted_iters.end(),
-                        [] (const contained_iter_type & it1,
+                        [&] (const contained_iter_type & it1,
                             const contained_iter_type & it2)
-                        { return *it1 < *it2; });
+                        { return compare_func(*it1, *it2); });
             }
 
         public:
 
+            Sorted(const Sorted &) = default;
+
             // Iterates over a series of Iterators, automatically dereferencing
             // them when accessed with operator *
             class IteratorIterator : public sorted_iter_type {
@@ -61,8 +64,6 @@ namespace iter {
                     }
             };
 
-            Sorted(const Sorted &) = default;
-
             IteratorIterator begin() {
                 IteratorIterator iteriter(sorted_iters.begin());
                 return iteriter;
@@ -74,9 +75,25 @@ namespace iter {
             }
     };
 
+    template <typename Container, typename CompareFunc>
+    Sorted<Container, CompareFunc> sorted(
+            Container & container, CompareFunc compare_func) {
+        return Sorted<Container, CompareFunc>(container, compare_func);
+    }
+
     template <typename Container>
-    Sorted<Container> sorted(Container & container) { 
-        return Sorted<Container>(container);
+    auto sorted(Container & container) ->
+             decltype(sorted(
+                         container,
+                         std::less<decltype(
+                             std::declval<Container>().begin().operator*())>()
+                         ))
+     {
+         return sorted(
+                 container,
+                 std::less<decltype(
+                     std::declval<Container>().begin().operator*())>()
+                 );
     }
 
 }

From 505823fcea46936a8bdd444e7674743d11a481c7 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 22 Oct 2013 17:04:25 -0700
Subject: [PATCH 0108/1866] Adds default test for groupby

---
 tests/testgroupby.cpp | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/tests/testgroupby.cpp b/tests/testgroupby.cpp
index 17443343..d499e8e8 100644
--- a/tests/testgroupby.cpp
+++ b/tests/testgroupby.cpp
@@ -29,6 +29,16 @@ int main()
         std::cout << '\n';
     }
 
+    std::vector<int> ivec = {5, 5, 6, 6, 19, 19, 19, 19, 69, 0, 10, 10};
+    for (auto gb : groupby(ivec)) {
+        std::cout << "key: " << gb.first << '\n';
+        std::cout << "content: ";
+        for (auto s : gb.second) {
+            std::cout << s << "  ";
+        }
+        std::cout << '\n';
+    }
+
 
     return 0;
 }

From 1069dc558184a00daa49d74ffb6eece6362a436c Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 22 Oct 2013 17:04:34 -0700
Subject: [PATCH 0109/1866] Adds default groupby(container)

Default creates groups by equivalence of the objects themselves rather
than the keys.
---
 groupby.hpp | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/groupby.hpp b/groupby.hpp
index e21ea30b..c468d83d 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -177,6 +177,25 @@ namespace iter {
             Container & container, KeyFunc key_func) {
         return GroupBy<Container, KeyFunc>(container, key_func);
     }
+
+    template <typename Container>
+    class ItemReturner {
+        private:
+            using contained_iter_ret =
+                decltype(std::declval<Container>().begin().operator*());
+        public:
+            ItemReturner() = default;
+            contained_iter_ret operator() (contained_iter_ret item) const {
+                return item;
+            }
+    };
+
+    template <typename Container>
+    auto groupby(Container & container) ->
+            decltype(groupby(container, ItemReturner<Container>())) {
+        return groupby(container, ItemReturner<Container>());
+    }
+
 }
 
 

From a5598cfacb8836c984b31880b0a7eea272b070ab Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 23 Oct 2013 12:20:45 -0700
Subject: [PATCH 0110/1866] Adds -Weffc++ flag to compilation flags

---
 tests/SConstruct | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/tests/SConstruct b/tests/SConstruct
index d8a46d34..c3c57fa9 100644
--- a/tests/SConstruct
+++ b/tests/SConstruct
@@ -3,7 +3,9 @@ import os
 
 env = Environment(
     CXX='c++',
-    CXXFLAGS=' -g -Wall -Wextra -pedantic -std=c++11 -I/usr/local/include',
+    CXXFLAGS= ['-g',  '-Wall', '-Wextra',  '-Weffc++',
+               '-pedantic', '-std=c++11',
+               '-I/usr/local/include'],
     CPPPATH='..',
     LINKFLAGS='-L/usr/local/lib')
 
@@ -12,8 +14,8 @@ env['ENV']['TERM'] = os.environ['TERM']
 
 # if on MAC, needs the linker flag for -stdlib=libc++
 if platform.system() == 'Darwin':
-    env['CXX'] += ' -stdlib=libc++ '
-    env['CXXFLAGS'] += ' -stdlib=libc++ '
+    env['CXX'] += '-stdlib=libc++'
+    env['CXXFLAGS'].append('-stdlib=libc++')
 
 
 

From 4c8dab34631e9e705fa8f903982325cc1498e415 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 6 Nov 2013 10:49:24 -0500
Subject: [PATCH 0111/1866] Adds iterbase for the common using=s

---
 iterbase.hpp | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 iterbase.hpp

diff --git a/iterbase.hpp b/iterbase.hpp
new file mode 100644
index 00000000..bc499e09
--- /dev/null
+++ b/iterbase.hpp
@@ -0,0 +1,26 @@
+#ifndef ITERBASE__HPP__
+#define ITERBASE__HPP__
+
+#include <utility>
+#include <iterator>
+
+namespace iter {
+    template <typename Iterable>
+    class IterBase{
+        protected:
+            // Type of the Container::Iterator, but since the name of that 
+            // iterator can be anything, we have to grab it with this
+            using contained_iter_type =
+                decltype(std::begin(std::declval<Iterable&>()));
+
+            // The type returned when dereferencing the Container::Iterator
+            using contained_iter_ret =
+                decltype(std::declval<contained_iter_type&>().operator*());
+            
+            IterBase() = default;
+            IterBase(const IterBase &) = default;
+            IterBase & operator=(const IterBase &) = delete;
+    };
+}
+
+#endif // #ifndef ITERBASE__HPP__

From 5968509b39ca303b9604e17b23a855939e852bdd Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 6 Nov 2013 10:50:01 -0500
Subject: [PATCH 0112/1866] Enumerable inherits from IterBase

---
 enumerate.hpp | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index 7f48a1d9..3fdf3631 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -1,6 +1,8 @@
 #ifndef ENUMERABLE__H__
 #define ENUMERABLE__H__
 
+#include "iterbase.hpp"
+
 #include <utility>
 
 
@@ -24,21 +26,28 @@ namespace iter {
 
 
     template <typename Container>
-    class Enumerable {
+    class Enumerable : public IterBase<Container>{
         private:
             Container & container;
             // The only thing allowed to directly instantiate an Enumerable is
             // the enumerate function
             friend Enumerable enumerate<Container>(Container &);
 
+            using contained_iter_type =
+                typename IterBase<Container>::contained_iter_type;
+
+            using contained_iter_ret =
+                typename IterBase<Container>::contained_iter_ret;
+#if 0
             // Type of the Container::Iterator, but since the name of that 
             // iterator can be anything, we have to grab it with this
-            using contained_iter_type =
+            //using contained_iter_type =
                 decltype(container.begin());
 
             // The type returned when dereferencing the Container::Iterator
             using contained_iter_ret =
                 decltype(container.begin().operator*());
+#endif
 
             
             // Value constructor for use only in the enumerate function

From 7920666a72c61ec3cf15a66e1249fe63c50cc5b1 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 6 Nov 2013 10:59:28 -0500
Subject: [PATCH 0113/1866] Switches .operator* for * to work with pointers

Where there was something like decltype(t.operator*()), there is now
decltype(*t).  This is for working with static arrays where the iterator
is a pointer rather than an iterator object.
---
 iterbase.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/iterbase.hpp b/iterbase.hpp
index bc499e09..69cfe0c6 100644
--- a/iterbase.hpp
+++ b/iterbase.hpp
@@ -15,7 +15,7 @@ namespace iter {
 
             // The type returned when dereferencing the Container::Iterator
             using contained_iter_ret =
-                decltype(std::declval<contained_iter_type&>().operator*());
+                decltype(*std::declval<contained_iter_type&>());
             
             IterBase() = default;
             IterBase(const IterBase &) = default;

From feaff39d3fed6b20517377d7b5a6441be9e9a577 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 6 Nov 2013 11:03:10 -0500
Subject: [PATCH 0114/1866] Switches .begin()/.end() with std::begin/std::end

---
 enumerate.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index 3fdf3631..f2875167 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -98,11 +98,11 @@ namespace iter {
             };
 
             Iterator begin() const {
-                return Iterator(this->container.begin());
+                return Iterator(std::begin(this->container));
             }
 
             Iterator end() const {
-                return Iterator(this->container.end());
+                return Iterator(std::end(this->container));
             }
 
     };

From b9a3122b42e6a6fdfaee4cac5159b219fd8dcd80 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 6 Nov 2013 11:09:48 -0500
Subject: [PATCH 0115/1866] Removes old usings, replaced with base class usings

---
 enumerate.hpp | 10 ----------
 1 file changed, 10 deletions(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index f2875167..cec188f7 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -38,16 +38,6 @@ namespace iter {
 
             using contained_iter_ret =
                 typename IterBase<Container>::contained_iter_ret;
-#if 0
-            // Type of the Container::Iterator, but since the name of that 
-            // iterator can be anything, we have to grab it with this
-            //using contained_iter_type =
-                decltype(container.begin());
-
-            // The type returned when dereferencing the Container::Iterator
-            using contained_iter_ret =
-                decltype(container.begin().operator*());
-#endif
 
             
             // Value constructor for use only in the enumerate function

From 260316f8f1a1f67794e519ea0b953a7a34efb83d Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 6 Nov 2013 11:18:45 -0500
Subject: [PATCH 0116/1866] Counts in testcycle to only loop 100 times

---
 tests/testcycle.cpp | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/tests/testcycle.cpp b/tests/testcycle.cpp
index dc375d8d..0e38a5ae 100644
--- a/tests/testcycle.cpp
+++ b/tests/testcycle.cpp
@@ -6,13 +6,15 @@
 using iter::cycle;
 
 int main() {
-    std::vector<int> vec;
-    vec.push_back(2);
-    vec.push_back(4);
-    vec.push_back(6);
+    std::vector<int> vec = {2, 4, 6};
 
+    size_t count = 0;
     for (auto i : cycle(vec)) {
         std::cout << i << '\n';
+        if (count == 100) {
+            break;
+        }
+        ++count;
     }
 
     return 0;

From 05a63104731f38e3084bdc9cc212420578ae13c3 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 6 Nov 2013 11:20:22 -0500
Subject: [PATCH 0117/1866] Adds static array test for enumerate

---
 tests/testenumerate.cpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/tests/testenumerate.cpp b/tests/testenumerate.cpp
index d8f4f34c..faebd71f 100644
--- a/tests/testenumerate.cpp
+++ b/tests/testenumerate.cpp
@@ -26,5 +26,10 @@ int main() {
         std::cout << e.index << ": " << e.element << std::endl;
     }
 
+    int array[] = {1, 9, 8, 11};
+    for (auto e : enumerate(array)) {
+        std::cout << e.index << ": " << e.element << '\n';
+    }
+
     return 0;
 }

From cdbdafc3d3bd928c7419d571f042b0c888763a25 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 6 Nov 2013 11:20:52 -0500
Subject: [PATCH 0118/1866] Adds static array test for cycle

---
 tests/testcycle.cpp | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/tests/testcycle.cpp b/tests/testcycle.cpp
index 0e38a5ae..bd4e2d0b 100644
--- a/tests/testcycle.cpp
+++ b/tests/testcycle.cpp
@@ -17,5 +17,15 @@ int main() {
         ++count;
     }
 
+    count = 0;
+    int array[] = {68, 69, 70};
+    for (auto i : cycle(array)) {
+        std::cout << i << '\n';
+        if (count == 100) {
+            break;
+        }
+        ++count;
+    }
+
     return 0;
 }

From dbdff7ae2b02c59fb02ecf70d52f8e19ab7af6da Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 6 Nov 2013 11:21:59 -0500
Subject: [PATCH 0119/1866] Updates cycle for static arrays

---
 cycle.hpp | 29 ++++++++++++++---------------
 1 file changed, 14 insertions(+), 15 deletions(-)

diff --git a/cycle.hpp b/cycle.hpp
index a47b87c2..0ed0e72c 100644
--- a/cycle.hpp
+++ b/cycle.hpp
@@ -1,6 +1,8 @@
 #ifndef CYCLE__H__
 #define CYCLE__H__
 
+#include "iterbase.hpp"
+
 #include <utility>
 
 namespace iter {
@@ -14,21 +16,17 @@ namespace iter {
 
 
     template <typename Container>
-    class Cycle {
-        // The cycle function is the only thing allowed to create a Cycle
-        friend Cycle cycle<Container>(Container &);
-
+    class Cycle : public IterBase<Container>{
+        private:
+            // The cycle function is the only thing allowed to create a Cycle
+            friend Cycle cycle<Container>(Container &);
 
-        // Type of the Container::Iterator, but since the name of that 
-        // iterator can be anything, we have to grab it with this
-        using contained_iter_type =
-            decltype(std::declval<Container>().begin());
+            using contained_iter_type =
+                typename IterBase<Container>::contained_iter_type;
 
-        // The type returned when dereferencing the Container::Iterator
-        using contained_iter_ret =
-            decltype(std::declval<contained_iter_type>().operator*());
+            using contained_iter_ret =
+                typename IterBase<Container>::contained_iter_ret;
 
-        private:
             Container & container;
             
             // Value constructor for use only in the cycle function
@@ -70,12 +68,13 @@ namespace iter {
             };
 
             Iterator begin() const {
-                return Iterator(this->container.begin(),
-                        this->container.end());
+                return Iterator(std::begin(this->container),
+                        std::end(this->container));
             }
 
             Iterator end() const {
-                return Iterator(this->container.end(), this->container.end());
+                return Iterator(std::end(this->container),
+                    std::end(this->container));
             }
 
     };

From 483bb266f9287141e9ad82ed3939028a8e38dfa6 Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Wed, 6 Nov 2013 17:33:52 -0500
Subject: [PATCH 0120/1866] std::begin and std::end support

---
 chain.hpp        | 17 ++++++++++-------
 tests/SConstruct |  4 +++-
 2 files changed, 13 insertions(+), 8 deletions(-)

diff --git a/chain.hpp b/chain.hpp
index 4ac309c2..669e695b 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -3,6 +3,7 @@
 
 #include "iterator_range.hpp"
 #include <utility>
+#include <iterator>
 
 namespace iter {
     template <typename ... Containers>
@@ -11,14 +12,15 @@ namespace iter {
         struct chain_iter<Container> {
 
             private:
-                using Iterator = decltype(std::declval<Container>().begin());
+                //using Iterator = decltype(std::declval<Container>().begin());
+                using Iterator = decltype(std::begin(std::declval<Container>()));
                 Iterator begin;
                 const Iterator end;//never really used but kept it for consistency
 
             public:
                 chain_iter(Container && container, bool is_end=false) :
-                    begin(container.begin()),end(container.end()) {
-                        if(is_end) begin = container.end();
+                    begin(std::begin(container)),end(std::end(container)) {
+                        if(is_end) begin = std::end(container);
                     }
                 chain_iter & operator++()
                 {
@@ -37,7 +39,8 @@ namespace iter {
         struct chain_iter<Container,Containers...>
         {
             private:
-                using Iterator = decltype(std::declval<Container>().begin());
+                //using Iterator = decltype(std::declval<Container>().begin());
+                using Iterator = decltype(std::begin(std::declval<Container>()));
                 Iterator begin;
                 const Iterator end;
                 bool end_reached = false;
@@ -45,11 +48,11 @@ namespace iter {
 
             public:
                 chain_iter(Container && container, Containers&& ... containers, bool is_end=false) :
-                    begin(container.begin()),
-                    end(container.end()),
+                    begin(std::begin(container)),
+                    end(std::end(container)),
                     next_iter(std::forward<Containers>(containers)...,is_end) {
                         if(is_end)
-                            begin = container.end();
+                            begin = std::end(container);
                     }
                 chain_iter & operator++()
                 {
diff --git a/tests/SConstruct b/tests/SConstruct
index c3c57fa9..8c300998 100644
--- a/tests/SConstruct
+++ b/tests/SConstruct
@@ -13,9 +13,11 @@ env = Environment(
 env['ENV']['TERM'] = os.environ['TERM']
 
 # if on MAC, needs the linker flag for -stdlib=libc++
-if platform.system() == 'Darwin':
+# obselete with mavericks
+""" if platform.system() == 'Darwin':
     env['CXX'] += '-stdlib=libc++'
     env['CXXFLAGS'].append('-stdlib=libc++')
+"""
 
 
 

From 49f1ce0d1e7eb22a42e25f7ce2652c61332679e0 Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Wed, 6 Nov 2013 17:42:59 -0500
Subject: [PATCH 0121/1866] moving section updated for std::begin and std::end

---
 moving_section.hpp | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/moving_section.hpp b/moving_section.hpp
index d99c2bc6..36ce2906 100644
--- a/moving_section.hpp
+++ b/moving_section.hpp
@@ -7,6 +7,7 @@
 #include <functional>
 #include <type_traits>
 #include <utility>
+#include <iterator>
 
 namespace iter {
     template <typename Container>
@@ -26,13 +27,14 @@ namespace iter {
                 Container&,
                 const Container &>::type container;
             //Container && container;
-            using Iterator = decltype(container.begin());
+            //using Iterator = decltype(container.begin());
+            using Iterator = decltype(std::begin(container));
             std::vector<Iterator> section;
             size_t section_size = 0;
             moving_section_iter(Container && c, size_t s) :
                 container(std::forward<Container>(c)),section_size(s) {
                     size_t i = 0;
-                    for (auto iter = container.begin(); i < section_size;++iter,++i) {
+                    for (auto iter = std::begin(container); i < section_size;++iter,++i) {
                         section.push_back(iter);
                     }
                     //for (size_t i = 0; i < section_size; ++i) 
@@ -41,7 +43,7 @@ namespace iter {
             moving_section_iter(Container && c) : container(std::forward<Container>(c))
             //creates the end iterator
             {
-                section.push_back(container.end());
+                section.push_back(std::end(container));
             }
 
             moving_section_iter & operator++() {

From 01128fc77fb9eb1836b6ea3498438f9fc4eef4c4 Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Wed, 6 Nov 2013 17:49:27 -0500
Subject: [PATCH 0122/1866] zip and zip_longest updated for std::begin and
 std::end

---
 tests/testzip.cpp |  2 +-
 zip.hpp           |  7 ++++---
 zip_longest.hpp   | 11 ++++++-----
 3 files changed, 11 insertions(+), 9 deletions(-)

diff --git a/tests/testzip.cpp b/tests/testzip.cpp
index 8b168dfa..ea30599a 100644
--- a/tests/testzip.cpp
+++ b/tests/testzip.cpp
@@ -76,7 +76,7 @@ int main() {
                     constvector)) 
         { 
 
-            std::cout << (std::get<0>(e)=5) << " " 
+            std::cout << std::get<0>(e) << " " 
                 << std::get<1>(e) << " " 
                 << std::get<2>(e) << std::endl;
         }
diff --git a/zip.hpp b/zip.hpp
index 5b3374aa..0f1bff07 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -4,6 +4,7 @@
 #include "iterator_range.hpp"
 
 #include <tuple>
+#include <iterator>
 
 namespace iter {
     template <typename ... Rest>
@@ -11,13 +12,13 @@ namespace iter {
 
     template <typename ... Containers>
     auto zip(Containers && ... containers) ->
-            iterator_range<zip_iter<decltype(containers.begin())...>>
+            iterator_range<zip_iter<decltype(std::begin(containers))...>>
     {
         auto begin =
-            zip_iter<decltype(containers.begin())...>(containers.begin()...);
+            zip_iter<decltype(containers.begin())...>(std::begin(containers)...);
 
         auto end =
-            zip_iter<decltype(containers.end())...>(containers.end()...);
+            zip_iter<decltype(containers.end())...>(std::end(containers)...);
 
         return iterator_range<decltype(begin)>(begin,end);
     }
diff --git a/zip_longest.hpp b/zip_longest.hpp
index b2036dba..1ee30fff 100644
--- a/zip_longest.hpp
+++ b/zip_longest.hpp
@@ -4,6 +4,7 @@
 #include <boost/optional.hpp>
 #include <tuple>
 #include <utility>
+#include <iterator>
 #include "iterator_range.hpp"
 
 namespace iter {
@@ -29,14 +30,14 @@ namespace iter {
     template <typename Container>
         struct zip_longest_iter<Container> {
         public:
-            using Iterator = decltype(std::declval<Container>().begin());
+            using Iterator = decltype(std::begin(std::declval<Container>()));
         private:
             Iterator begin;
             const Iterator end;
 
         public:
             zip_longest_iter(Container && c) :
-                begin(c.begin()),end(c.end()) {}
+                begin(std::begin(c)),end(std::end(c)) {}
 
             std::tuple<boost::optional<decltype(*std::declval<Iterator>())>> 
             operator*()     
@@ -56,7 +57,7 @@ namespace iter {
     template <typename Container, typename ... Containers>
         struct zip_longest_iter<Container,Containers...> {
         public:
-            using Iterator = decltype(std::declval<Container>().begin());
+            using Iterator = decltype(std::begin(std::declval<Container>()));
         private:
             Iterator begin;
             const Iterator end;
@@ -70,8 +71,8 @@ namespace iter {
                             *inner_iter));
 
             zip_longest_iter(Container && c, Containers && ... containers) :
-                begin(c.begin()),
-                end(c.end()),
+                begin(std::begin(c)),
+                end(std::end(c)),
                 inner_iter(std::forward<Containers>(containers)...) {}
 
             //this is for returning a tuple of optional<iterator>

From f49484697e38a5c741e57adff5c2a723d6e5bcb4 Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Wed, 6 Nov 2013 20:33:51 -0500
Subject: [PATCH 0123/1866] updated grouper to support std::begin and std::end

---
 grouper.hpp | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/grouper.hpp b/grouper.hpp
index 5dc7aab6..ce9e4871 100644
--- a/grouper.hpp
+++ b/grouper.hpp
@@ -7,6 +7,7 @@
 #include <functional>
 #include <type_traits>
 #include <utility>
+#include <iterator>
 
 namespace iter {
     template <typename Container>
@@ -28,7 +29,8 @@ namespace iter {
                 Container&,
                 const Container &>::type container;
             //Container && container;
-            using Iterator = decltype(container.begin());
+            //using Iterator = decltype(container.begin());
+            using Iterator = decltype(std::begin(container));
             using Deref_type =
                 std::vector<
                     std::reference_wrapper<
@@ -48,12 +50,12 @@ namespace iter {
                 // if the group size is 0 or the container is empty produce
                 // nothing
                 if (this->group_size == 0 ||
-                        !(this->container.begin() != this->container.end())) {
+                        !(std::begin(this->container) != std::end(this->container))) {
                     this->not_done = false;
                     return;
                 }
                 size_t i = 0;
-                for (auto iter = container.begin(); i < group_size;++i,++iter) {
+                for (auto iter = std::begin(container); i < group_size;++i,++iter) {
                     group.push_back(iter);
                 }
                 //for (size_t i = 0; i < this->group_size; ++i) 
@@ -65,7 +67,7 @@ namespace iter {
                 container(std::forward<Container>(c))
             {
                 //creates the end iterator
-                group.push_back(container.end());
+                group.push_back(std::end(container));
             }
 
             //plan to conditionally check for existence of +=
@@ -91,7 +93,7 @@ namespace iter {
             Deref_type operator*() {
                 Deref_type vec;
                 for (auto i : this->group) {
-                    if(!(i != this->container.end())) {
+                    if(!(i != std::end(this->container))) {
                         this->not_done = false;
                         break;
                     } 

From fc3661520527921d5425ada8656ab20fdc12bd0f Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 6 Nov 2013 22:16:22 -0500
Subject: [PATCH 0124/1866] Shortens using baseclass type

---
 enumerate.hpp | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index cec188f7..9bd871e9 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -33,11 +33,9 @@ namespace iter {
             // the enumerate function
             friend Enumerable enumerate<Container>(Container &);
 
-            using contained_iter_type =
-                typename IterBase<Container>::contained_iter_type;
+            using typename IterBase<Container>::contained_iter_type;
 
-            using contained_iter_ret =
-                typename IterBase<Container>::contained_iter_ret;
+            using typename IterBase<Container>::contained_iter_ret;
 
             
             // Value constructor for use only in the enumerate function

From 25063a4b79632c65bc7f6060c49d320bfec6d0f7 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 6 Nov 2013 22:19:32 -0500
Subject: [PATCH 0125/1866] Shortens using baseclass type

---
 cycle.hpp | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/cycle.hpp b/cycle.hpp
index 0ed0e72c..6a8eb713 100644
--- a/cycle.hpp
+++ b/cycle.hpp
@@ -21,11 +21,9 @@ namespace iter {
             // The cycle function is the only thing allowed to create a Cycle
             friend Cycle cycle<Container>(Container &);
 
-            using contained_iter_type =
-                typename IterBase<Container>::contained_iter_type;
+            using typename IterBase<Container>::contained_iter_type;
 
-            using contained_iter_ret =
-                typename IterBase<Container>::contained_iter_ret;
+            using typename IterBase<Container>::contained_iter_ret;
 
             Container & container;
             

From 727940a1396fb44670e1127b1c9c917426d7a1d8 Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Wed, 6 Nov 2013 23:25:19 -0500
Subject: [PATCH 0126/1866] used std::advance to make functions more versatile

---
 grouper.hpp                  | 9 ++++-----
 tests/testcommand_chains.cpp | 2 ++
 wrap_iter.hpp                | 2 +-
 3 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/grouper.hpp b/grouper.hpp
index ce9e4871..5e57b2c8 100644
--- a/grouper.hpp
+++ b/grouper.hpp
@@ -71,21 +71,20 @@ namespace iter {
             }
 
             //plan to conditionally check for existence of +=
-            /*
-            template<typename> struct int_{typedef int type;};dd
-            template <typename int_<decltype(Iterator::operator+=)>::type = 0>
             grouper_iter & operator++() {
                 for (auto & iter : this->group) {
-                    iter += this->group_size;
+                    std::advance(iter,this->group_size);
                 }
                 return *this;
-            }*/
+            }
+            /*
             grouper_iter & operator++() {
                 for (auto & iter : this->group) {
                     for(size_t i = 0; i < group_size;++i,++iter);
                 }
                 return *this;
             }
+            */
             bool operator!=(const grouper_iter &) const {
                 return this->not_done;
             }
diff --git a/tests/testcommand_chains.cpp b/tests/testcommand_chains.cpp
index 7bc48d2d..e5c5ece6 100644
--- a/tests/testcommand_chains.cpp
+++ b/tests/testcommand_chains.cpp
@@ -50,6 +50,7 @@ int main() {
             std::cout<<std::endl;
         }
     }
+    /*
     std::cout << std::endl;
     {
         std::vector<int> vec1{1,2,3,4,5,6};
@@ -59,5 +60,6 @@ int main() {
             std::cout<<std::endl;
         }
     }
+    */
     return 0;
 }
diff --git a/wrap_iter.hpp b/wrap_iter.hpp
index 31bc899b..f21edbb9 100644
--- a/wrap_iter.hpp
+++ b/wrap_iter.hpp
@@ -19,7 +19,7 @@ namespace iter {
             { }
 
             wrap_iter & operator++() {
-                iter += step;
+                std::advance(iter,step);
                 return *this;
             }
 

From 7cbc1dd0c1d2a80a8b80887af35a7db3c0ece0d7 Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Thu, 7 Nov 2013 01:28:09 -0500
Subject: [PATCH 0127/1866] big fix on slice, uses std::begin and uses
 std::advance

---
 slice.hpp | 39 +++++++++++++++++++++++++--------------
 1 file changed, 25 insertions(+), 14 deletions(-)

diff --git a/slice.hpp b/slice.hpp
index 6fb37949..f0f2dcf6 100644
--- a/slice.hpp
+++ b/slice.hpp
@@ -11,28 +11,39 @@ namespace iter {
     template <typename Container>
         auto slice(
                 Container && container,
-                typename std::iterator_traits<decltype(container.begin())>::difference_type begin,
-                typename std::iterator_traits<decltype(container.begin())>::difference_type end,
-                typename std::iterator_traits<decltype(container.begin())>::difference_type step = 1
-                ) -> iterator_range<wrap_iter<decltype(container.begin())>>
+                typename std::iterator_traits<decltype(std::begin(container))>::difference_type begin,
+                typename std::iterator_traits<decltype(std::begin(container))>::difference_type end,
+                typename std::iterator_traits<decltype(std::begin(container))>::difference_type step = 1
+                ) -> iterator_range<wrap_iter<decltype(std::begin(container))>>
         {
             //it seems like you can handle negative and positive ranges the same
+            //kept both checks to make checking for invalid slice more readable
             if (begin > end && step < 0) {
-                typename std::iterator_traits<decltype(container.begin())>::difference_type new_end = end - ((end - begin) % step);
-                return iterator_range<wrap_iter<decltype(container.begin())>>(
-                        make_wrap_iter(container.begin()+begin,step),
-                        make_wrap_iter(container.begin()+new_end,step));
+                typename std::iterator_traits<decltype(std::begin(container))>::difference_type new_end = end - ((end - begin) % step);
+                auto begin_iter = std::begin(container);
+                std::advance(begin_iter,begin);
+                auto end_iter = std::begin(container);
+                std::advance(end_iter,new_end);
+                return iterator_range<wrap_iter<decltype(std::begin(container))>>(
+                        make_wrap_iter(begin_iter,step),
+                        make_wrap_iter(end_iter,step));
             }
             else if (begin <= end && step > 0) {
                 typename std::iterator_traits<decltype(container.begin())>::difference_type new_end = end - ((end - begin) % step);
+                auto begin_iter = std::begin(container);
+                std::advance(begin_iter,begin);
+                auto end_iter = std::begin(container);
+                std::advance(end_iter,new_end);
                 return iterator_range<wrap_iter<decltype(container.begin())>>(
-                        make_wrap_iter(container.begin()+begin,step),
-                        make_wrap_iter(container.begin()+new_end,step));
+                        make_wrap_iter(begin_iter,step),
+                        make_wrap_iter(end_iter,step));
             }
             else {//return an empty range for invalid slice
+                auto empty = std::begin(container);
+                std::advance(empty,begin);
                 return iterator_range<wrap_iter<decltype(container.begin())>>(
-                        make_wrap_iter(container.begin()+begin,step),
-                        make_wrap_iter(container.begin()+begin,step));
+                        make_wrap_iter(empty,step),
+                        make_wrap_iter(empty,step));
             }
 
         }
@@ -40,8 +51,8 @@ namespace iter {
     template <typename Container>
         auto slice(
                 Container && container,
-                typename std::iterator_traits<decltype(container.begin())>::difference_type end
-                ) -> iterator_range<wrap_iter<decltype(container.begin())>>
+                typename std::iterator_traits<decltype(std::begin(container))>::difference_type end
+                ) -> iterator_range<wrap_iter<decltype(std::begin(container))>>
         {
             return slice(std::forward<Container>(container),0,end);
         }

From d6948c38fec0e66728edc20f86566dccfa35225d Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Thu, 7 Nov 2013 02:26:43 -0500
Subject: [PATCH 0128/1866] added iterator_traits specialization for chain
 (could very well be illegal c++ IDC)

---
 chain.hpp                    | 7 ++++++-
 tests/testcommand_chains.cpp | 2 --
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/chain.hpp b/chain.hpp
index 669e695b..b360485a 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -81,6 +81,7 @@ namespace iter {
                         return this->begin != rhs.begin;
                 }
         };
+    
     template <typename ... Containers>
         iterator_range<chain_iter<Containers...>> chain(Containers&& ... containers)
         {
@@ -92,5 +93,9 @@ namespace iter {
                 iterator_range<chain_iter<Containers...>>(begin,end);
         }
 }
-
+template <typename ... Containers>
+struct std::iterator_traits<iter::chain_iter<Containers...>> {
+    using difference_type = std::ptrdiff_t;
+    using iterator_category = std::input_iterator_tag;
+};
 #endif //CHAIN_HPP
diff --git a/tests/testcommand_chains.cpp b/tests/testcommand_chains.cpp
index e5c5ece6..7bc48d2d 100644
--- a/tests/testcommand_chains.cpp
+++ b/tests/testcommand_chains.cpp
@@ -50,7 +50,6 @@ int main() {
             std::cout<<std::endl;
         }
     }
-    /*
     std::cout << std::endl;
     {
         std::vector<int> vec1{1,2,3,4,5,6};
@@ -60,6 +59,5 @@ int main() {
             std::cout<<std::endl;
         }
     }
-    */
     return 0;
 }

From 190758d86525b668a998d4c2d0aed392e07f6e89 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 7 Nov 2013 10:14:54 -0500
Subject: [PATCH 0129/1866] Replaces a few .begin()s with std::begin

---
 slice.hpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/slice.hpp b/slice.hpp
index f0f2dcf6..b3494bd7 100644
--- a/slice.hpp
+++ b/slice.hpp
@@ -29,19 +29,19 @@ namespace iter {
                         make_wrap_iter(end_iter,step));
             }
             else if (begin <= end && step > 0) {
-                typename std::iterator_traits<decltype(container.begin())>::difference_type new_end = end - ((end - begin) % step);
+                typename std::iterator_traits<decltype(std::begin(container))>::difference_type new_end = end - ((end - begin) % step);
                 auto begin_iter = std::begin(container);
                 std::advance(begin_iter,begin);
                 auto end_iter = std::begin(container);
                 std::advance(end_iter,new_end);
-                return iterator_range<wrap_iter<decltype(container.begin())>>(
+                return iterator_range<wrap_iter<decltype(std::begin(container))>>(
                         make_wrap_iter(begin_iter,step),
                         make_wrap_iter(end_iter,step));
             }
             else {//return an empty range for invalid slice
                 auto empty = std::begin(container);
                 std::advance(empty,begin);
-                return iterator_range<wrap_iter<decltype(container.begin())>>(
+                return iterator_range<wrap_iter<decltype(std::begin(container)>>(
                         make_wrap_iter(empty,step),
                         make_wrap_iter(empty,step));
             }

From 5e5c4b0423053c16df5c01a724be1621805ae1ff Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 7 Nov 2013 10:15:40 -0500
Subject: [PATCH 0130/1866] Error missing ) in last commit

---
 slice.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/slice.hpp b/slice.hpp
index b3494bd7..d6d41e74 100644
--- a/slice.hpp
+++ b/slice.hpp
@@ -41,7 +41,7 @@ namespace iter {
             else {//return an empty range for invalid slice
                 auto empty = std::begin(container);
                 std::advance(empty,begin);
-                return iterator_range<wrap_iter<decltype(std::begin(container)>>(
+                return iterator_range<wrap_iter<decltype(std::begin(container))>>(
                         make_wrap_iter(empty,step),
                         make_wrap_iter(empty,step));
             }

From f1af4f4d8d805f9ebe2c5d460cb0903659f7e989 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 7 Nov 2013 10:16:26 -0500
Subject: [PATCH 0131/1866] Replaces assert.h with cassert

---
 slice.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/slice.hpp b/slice.hpp
index d6d41e74..f2f8b81e 100644
--- a/slice.hpp
+++ b/slice.hpp
@@ -5,7 +5,7 @@
 #include "wrap_iter.hpp"
 
 #include <iterator>
-#include <assert.h>
+#include <cassert>
 
 namespace iter {
     template <typename Container>

From b946cf0794f5076820f6549758fdfb08d04d9f97 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 7 Nov 2013 10:30:26 -0500
Subject: [PATCH 0132/1866] Indetation adjustments

---
 slice.hpp | 88 +++++++++++++++++++++++++++----------------------------
 1 file changed, 44 insertions(+), 44 deletions(-)

diff --git a/slice.hpp b/slice.hpp
index f2f8b81e..9131cbf0 100644
--- a/slice.hpp
+++ b/slice.hpp
@@ -9,53 +9,53 @@
 
 namespace iter {
     template <typename Container>
-        auto slice(
-                Container && container,
-                typename std::iterator_traits<decltype(std::begin(container))>::difference_type begin,
-                typename std::iterator_traits<decltype(std::begin(container))>::difference_type end,
-                typename std::iterator_traits<decltype(std::begin(container))>::difference_type step = 1
-                ) -> iterator_range<wrap_iter<decltype(std::begin(container))>>
-        {
-            //it seems like you can handle negative and positive ranges the same
-            //kept both checks to make checking for invalid slice more readable
-            if (begin > end && step < 0) {
-                typename std::iterator_traits<decltype(std::begin(container))>::difference_type new_end = end - ((end - begin) % step);
-                auto begin_iter = std::begin(container);
-                std::advance(begin_iter,begin);
-                auto end_iter = std::begin(container);
-                std::advance(end_iter,new_end);
-                return iterator_range<wrap_iter<decltype(std::begin(container))>>(
-                        make_wrap_iter(begin_iter,step),
-                        make_wrap_iter(end_iter,step));
-            }
-            else if (begin <= end && step > 0) {
-                typename std::iterator_traits<decltype(std::begin(container))>::difference_type new_end = end - ((end - begin) % step);
-                auto begin_iter = std::begin(container);
-                std::advance(begin_iter,begin);
-                auto end_iter = std::begin(container);
-                std::advance(end_iter,new_end);
-                return iterator_range<wrap_iter<decltype(std::begin(container))>>(
-                        make_wrap_iter(begin_iter,step),
-                        make_wrap_iter(end_iter,step));
-            }
-            else {//return an empty range for invalid slice
-                auto empty = std::begin(container);
-                std::advance(empty,begin);
-                return iterator_range<wrap_iter<decltype(std::begin(container))>>(
-                        make_wrap_iter(empty,step),
-                        make_wrap_iter(empty,step));
-            }
-
+    auto slice(
+            Container && container,
+            typename std::iterator_traits<decltype(std::begin(container))>::difference_type begin,
+            typename std::iterator_traits<decltype(std::begin(container))>::difference_type end,
+            typename std::iterator_traits<decltype(std::begin(container))>::difference_type step = 1
+            ) -> iterator_range<wrap_iter<decltype(std::begin(container))>>
+    {
+        //it seems like you can handle negative and positive ranges the same
+        //kept both checks to make checking for invalid slice more readable
+        if (begin > end && step < 0) {
+            typename std::iterator_traits<decltype(std::begin(container))>::difference_type new_end = end - ((end - begin) % step);
+            auto begin_iter = std::begin(container);
+            std::advance(begin_iter,begin);
+            auto end_iter = std::begin(container);
+            std::advance(end_iter,new_end);
+            return iterator_range<wrap_iter<decltype(std::begin(container))>>(
+                    make_wrap_iter(begin_iter,step),
+                    make_wrap_iter(end_iter,step));
+        }
+        else if (begin <= end && step > 0) {
+            typename std::iterator_traits<decltype(std::begin(container))>::difference_type new_end = end - ((end - begin) % step);
+            auto begin_iter = std::begin(container);
+            std::advance(begin_iter,begin);
+            auto end_iter = std::begin(container);
+            std::advance(end_iter,new_end);
+            return iterator_range<wrap_iter<decltype(std::begin(container))>>(
+                    make_wrap_iter(begin_iter,step),
+                    make_wrap_iter(end_iter,step));
+        }
+        else {//return an empty range for invalid slice
+            auto empty = std::begin(container);
+            std::advance(empty,begin);
+            return iterator_range<wrap_iter<decltype(std::begin(container))>>(
+                    make_wrap_iter(empty,step),
+                    make_wrap_iter(empty,step));
         }
+
+    }
     //only give the end as an arg and assume step  is 1 and begin is 0
     template <typename Container>
-        auto slice(
-                Container && container,
-                typename std::iterator_traits<decltype(std::begin(container))>::difference_type end
-                ) -> iterator_range<wrap_iter<decltype(std::begin(container))>>
-        {
-            return slice(std::forward<Container>(container),0,end);
-        }
+    auto slice(
+            Container && container,
+            typename std::iterator_traits<decltype(std::begin(container))>::difference_type end
+            ) -> iterator_range<wrap_iter<decltype(std::begin(container))>>
+    {
+        return slice(std::forward<Container>(container),0,end);
+    }
 
 }
 

From 72b277ff917fb971b352a2d0e338e4bf4438a5b9 Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Thu, 7 Nov 2013 15:01:45 -0500
Subject: [PATCH 0133/1866] iterator_traits fix in wrap_iter

---
 slice.hpp     | 2 ++
 wrap_iter.hpp | 1 +
 2 files changed, 3 insertions(+)

diff --git a/slice.hpp b/slice.hpp
index 9131cbf0..403450e2 100644
--- a/slice.hpp
+++ b/slice.hpp
@@ -41,6 +41,8 @@ namespace iter {
         else {//return an empty range for invalid slice
             auto empty = std::begin(container);
             std::advance(empty,begin);
+            //just in case it gets dereferenced it will be the first element had 
+            //the range been valid
             return iterator_range<wrap_iter<decltype(std::begin(container))>>(
                     make_wrap_iter(empty,step),
                     make_wrap_iter(empty,step));
diff --git a/wrap_iter.hpp b/wrap_iter.hpp
index f21edbb9..1161a393 100644
--- a/wrap_iter.hpp
+++ b/wrap_iter.hpp
@@ -43,6 +43,7 @@ namespace iter {
 template <typename Iterator>
     struct std::iterator_traits<iter::wrap_iter<Iterator>> {
         using difference_type = typename std::iterator_traits<Iterator>::difference_type;
+        using iterator_category = typename std::iterator_traits<Iterator>::iterator_category;
         //should add the rest later for a more usable class
     };
 #endif //WRAP_ITER_HPP__

From ff1db0c4af079ac94f97dc91cb15791b341e383b Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 7 Nov 2013 15:04:23 -0500
Subject: [PATCH 0134/1866] Changes difference type to a template Argument

---
 slice.hpp | 19 +++++++++----------
 1 file changed, 9 insertions(+), 10 deletions(-)

diff --git a/slice.hpp b/slice.hpp
index 9131cbf0..0aa1e15c 100644
--- a/slice.hpp
+++ b/slice.hpp
@@ -8,18 +8,17 @@
 #include <cassert>
 
 namespace iter {
-    template <typename Container>
-    auto slice(
-            Container && container,
-            typename std::iterator_traits<decltype(std::begin(container))>::difference_type begin,
-            typename std::iterator_traits<decltype(std::begin(container))>::difference_type end,
-            typename std::iterator_traits<decltype(std::begin(container))>::difference_type step = 1
+    template <typename Container, typename DifferenceType>
+    auto slice( Container && container,
+            DifferenceType begin,
+            DifferenceType end,
+            DifferenceType step = 1
             ) -> iterator_range<wrap_iter<decltype(std::begin(container))>>
     {
         //it seems like you can handle negative and positive ranges the same
         //kept both checks to make checking for invalid slice more readable
         if (begin > end && step < 0) {
-            typename std::iterator_traits<decltype(std::begin(container))>::difference_type new_end = end - ((end - begin) % step);
+            DifferenceType new_end = end - ((end - begin) % step);
             auto begin_iter = std::begin(container);
             std::advance(begin_iter,begin);
             auto end_iter = std::begin(container);
@@ -29,7 +28,7 @@ namespace iter {
                     make_wrap_iter(end_iter,step));
         }
         else if (begin <= end && step > 0) {
-            typename std::iterator_traits<decltype(std::begin(container))>::difference_type new_end = end - ((end - begin) % step);
+            DifferenceType new_end = end - ((end - begin) % step);
             auto begin_iter = std::begin(container);
             std::advance(begin_iter,begin);
             auto end_iter = std::begin(container);
@@ -48,10 +47,10 @@ namespace iter {
 
     }
     //only give the end as an arg and assume step  is 1 and begin is 0
-    template <typename Container>
+    template <typename Container, typename DifferenceType>
     auto slice(
             Container && container,
-            typename std::iterator_traits<decltype(std::begin(container))>::difference_type end
+            DifferenceType end
             ) -> iterator_range<wrap_iter<decltype(std::begin(container))>>
     {
         return slice(std::forward<Container>(container),0,end);

From c3c909e92728a870670ee4ad838434ec415cee73 Mon Sep 17 00:00:00 2001
From: Jared Schmitz <jared@cs.columbia.edu>
Date: Thu, 7 Nov 2013 16:58:07 -0500
Subject: [PATCH 0135/1866] Refactor slice

---
 slice.hpp | 45 ++++++++++++++++-----------------------------
 1 file changed, 16 insertions(+), 29 deletions(-)

diff --git a/slice.hpp b/slice.hpp
index 9ec4e59f..aea7d1ce 100644
--- a/slice.hpp
+++ b/slice.hpp
@@ -15,37 +15,24 @@ namespace iter {
             DifferenceType step = 1
             ) -> iterator_range<wrap_iter<decltype(std::begin(container))>>
     {
-        //it seems like you can handle negative and positive ranges the same
-        //kept both checks to make checking for invalid slice more readable
-        if (begin > end && step < 0) {
-            DifferenceType new_end = end - ((end - begin) % step);
-            auto begin_iter = std::begin(container);
-            std::advance(begin_iter,begin);
-            auto end_iter = std::begin(container);
-            std::advance(end_iter,new_end);
+        // Check for an invalid slice. The sign of step must be equal to the
+        // sign of (end - begin). Since we don't force DifferenceType to be a
+        // primitive, just compare.
+        if (!(begin > end && step < 0) && !(begin <= end && step > 0)) {
+            // Just in case it gets dereferenced it will be the first element
+            // had the range been valid. This handles zero-length slices.
+            auto empty = std::next(std::begin(container), begin);
             return iterator_range<wrap_iter<decltype(std::begin(container))>>(
-                    make_wrap_iter(begin_iter,step),
-                    make_wrap_iter(end_iter,step));
-        }
-        else if (begin <= end && step > 0) {
-            DifferenceType new_end = end - ((end - begin) % step);
-            auto begin_iter = std::begin(container);
-            std::advance(begin_iter,begin);
-            auto end_iter = std::begin(container);
-            std::advance(end_iter,new_end);
-            return iterator_range<wrap_iter<decltype(std::begin(container))>>(
-                    make_wrap_iter(begin_iter,step),
-                    make_wrap_iter(end_iter,step));
-        }
-        else {//return an empty range for invalid slice
-            auto empty = std::begin(container);
-            std::advance(empty,begin);
-            //just in case it gets dereferenced it will be the first element had 
-            //the range been valid
-            return iterator_range<wrap_iter<decltype(std::begin(container))>>(
-                    make_wrap_iter(empty,step),
-                    make_wrap_iter(empty,step));
+                    make_wrap_iter(empty, step),
+                    make_wrap_iter(empty, step));
         }
+        // Return the iterator range
+        DifferenceType new_end = end - ((end - begin) % step);
+        auto begin_iter = std::next(std::begin(container), begin);
+        auto end_iter = std::next(std::begin(container), new_end);
+        return iterator_range<wrap_iter<decltype(std::begin(container))>>(
+                make_wrap_iter(begin_iter,step),
+                make_wrap_iter(end_iter,step));
 
     }
     //only give the end as an arg and assume step  is 1 and begin is 0

From 39e19238dc896614550833388e4a5a804728a575 Mon Sep 17 00:00:00 2001
From: Jared Schmitz <jared@cs.columbia.edu>
Date: Thu, 7 Nov 2013 17:07:41 -0500
Subject: [PATCH 0136/1866] Move specializations of iterator_traits into std

---
 chain.hpp     | 8 +++++---
 wrap_iter.hpp | 8 +++++---
 2 files changed, 10 insertions(+), 6 deletions(-)

diff --git a/chain.hpp b/chain.hpp
index b360485a..36dfe7c0 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -93,9 +93,11 @@ namespace iter {
                 iterator_range<chain_iter<Containers...>>(begin,end);
         }
 }
+namespace std {
 template <typename ... Containers>
-struct std::iterator_traits<iter::chain_iter<Containers...>> {
-    using difference_type = std::ptrdiff_t;
-    using iterator_category = std::input_iterator_tag;
+struct iterator_traits<iter::chain_iter<Containers...>> {
+    using difference_type = ptrdiff_t;
+    using iterator_category = input_iterator_tag;
 };
+}
 #endif //CHAIN_HPP
diff --git a/wrap_iter.hpp b/wrap_iter.hpp
index 1161a393..70017b4b 100644
--- a/wrap_iter.hpp
+++ b/wrap_iter.hpp
@@ -40,10 +40,12 @@ namespace iter {
     }
     
 }
+namespace std {
 template <typename Iterator>
-    struct std::iterator_traits<iter::wrap_iter<Iterator>> {
-        using difference_type = typename std::iterator_traits<Iterator>::difference_type;
-        using iterator_category = typename std::iterator_traits<Iterator>::iterator_category;
+    struct iterator_traits<iter::wrap_iter<Iterator>> {
+        using difference_type = typename iterator_traits<Iterator>::difference_type;
+        using iterator_category = typename iterator_traits<Iterator>::iterator_category;
         //should add the rest later for a more usable class
     };
+}
 #endif //WRAP_ITER_HPP__

From 67a5967c7bb09e9318e1de721084be05ea750dfc Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 7 Nov 2013 17:37:52 -0500
Subject: [PATCH 0137/1866] Updates compress to use IterBase

---
 compress.hpp | 16 +++++++---------
 1 file changed, 7 insertions(+), 9 deletions(-)

diff --git a/compress.hpp b/compress.hpp
index 989c5983..11ba7c12 100644
--- a/compress.hpp
+++ b/compress.hpp
@@ -1,9 +1,10 @@
 #ifndef COMPRESS__H__
 #define COMPRESS__H__
 
-#include <utility>
+#include <iterbase.hpp>
+
 
-// TODO everything in here
+#include <utility>
 
 namespace iter {
 
@@ -16,7 +17,7 @@ namespace iter {
 
 
     template <typename Container, typename Selector>
-    class Compressed {
+    class Compressed : public IterBase<Container> {
         private:
             Container & container;
             Selector & selectors;
@@ -26,15 +27,12 @@ namespace iter {
             friend Compressed compress<Container, Selector>(
                     Container &, Selector &);
 
-            // Type of the Container::Iterator, but since the name of that 
-            // iterator can be anything, we have to grab it with this
-            using contained_iter_type = decltype(container.begin());
+            using typename IterBase<Container>::contained_iter_type;
 
-            // The type returned when dereferencing the Container::Iterator
-            using contained_iter_ret = decltype(container.begin().operator*());
+            using typename IterBase<Container>::contained_iter_ret;
 
             // Selector::Iterator type
-            using selector_iter_type = decltype(selectors.begin());
+            using selector_iter_type = decltype(std::begin(selectors));
             
             // Value constructor for use only in the compress function
             Compressed(Container & container, Selector & selectors) :

From 3111fedd1d00698578535d78597cc54f82ffb731 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 7 Nov 2013 17:41:26 -0500
Subject: [PATCH 0138/1866] Replaces .begin/.end with std::begin/end

---
 compress.hpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/compress.hpp b/compress.hpp
index 11ba7c12..ff64bb9d 100644
--- a/compress.hpp
+++ b/compress.hpp
@@ -96,14 +96,14 @@ namespace iter {
 
             Iterator begin() const {
                 return Iterator(
-                        this->container.begin(), this->container.end(),
-                        this->selectors.begin(), this->selectors.end());
+                        std::begin(this->container), std::end(this->container),
+                        std::begin(this->selectors), std::end(this->selectors));
             }
 
             Iterator end() const {
                 return Iterator(
-                        this->container.end(), this->container.end(),
-                        this->selectors.end(), this->selectors.end());
+                        std::end(this->container), std::end(this->container),
+                        std::end(this->selectors), std::end(this->selectors));
             }
 
     };

From 0e4600e6c24558418267d2270309ae5a20c1ad06 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 7 Nov 2013 17:45:05 -0500
Subject: [PATCH 0139/1866] Updates to use Iterbase and std::begin/std::end

---
 dropwhile.hpp | 19 +++++++++----------
 1 file changed, 9 insertions(+), 10 deletions(-)

diff --git a/dropwhile.hpp b/dropwhile.hpp
index cf730f0c..9ac899de 100644
--- a/dropwhile.hpp
+++ b/dropwhile.hpp
@@ -1,6 +1,8 @@
 #ifndef DROPWHILE__H__
 #define DROPWHILE__H__
 
+#include <iterbase.hpp>
+
 #include <utility>
 
 namespace iter {
@@ -13,7 +15,7 @@ namespace iter {
     DropWhile<FilterFunc, Container> dropwhile(FilterFunc, Container &);
 
     template <typename FilterFunc, typename Container>
-    class DropWhile {
+    class DropWhile : IterBase<Container> {
         private:
             Container & container;
             FilterFunc filter_func;
@@ -21,12 +23,9 @@ namespace iter {
             friend DropWhile dropwhile<FilterFunc, Container>(
                     FilterFunc, Container &);
 
-            // Type of the Container::Iterator, but since the name of that 
-            // iterator can be anything, we have to grab it with this
-            using contained_iter_type = decltype(container.begin());
+            using typename IterBase<Container>::contained_iter_type;
 
-            // The type returned when dereferencing the Container::Iterator
-            using contained_iter_ret = decltype(container.begin().operator*());
+            using typename IterBase<Container>::contained_iter_ret;
 
             
             // Value constructor for use only in the dropwhile function
@@ -80,15 +79,15 @@ namespace iter {
 
             Iterator begin() const {
                 return Iterator(
-                        this->container.begin(),
-                        this->container.end(),
+                        std::begin(this->container),
+                        std::end(this->container),
                         this->filter_func);
             }
 
             Iterator end() const {
                 return Iterator(
-                        this->container.end(),
-                        this->container.end(),
+                        std::end(this->container),
+                        std::end(this->container),
                         this->filter_func);
             }
 

From afe1511e7faec7421d60f3841f572163adb8c611 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 7 Nov 2013 17:47:02 -0500
Subject: [PATCH 0140/1866] Exposes iterbase type aliases publicly

---
 iterbase.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/iterbase.hpp b/iterbase.hpp
index 69cfe0c6..55936753 100644
--- a/iterbase.hpp
+++ b/iterbase.hpp
@@ -7,7 +7,7 @@
 namespace iter {
     template <typename Iterable>
     class IterBase{
-        protected:
+        public:
             // Type of the Container::Iterator, but since the name of that 
             // iterator can be anything, we have to grab it with this
             using contained_iter_type =

From cab3f5fd3e247d5d3aafb3fefc1042fda20f9a19 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 7 Nov 2013 17:48:53 -0500
Subject: [PATCH 0141/1866] Use iterbase type aliases

---
 filterfalse.hpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/filterfalse.hpp b/filterfalse.hpp
index 34b16180..b18cca5c 100644
--- a/filterfalse.hpp
+++ b/filterfalse.hpp
@@ -1,7 +1,8 @@
 #ifndef FILTER_FALSE__HPP__
 #define FILTER_FALSE__HPP__
 
-#include "filter.hpp"
+#include <iterbase.hpp>
+#include <filter.hpp>
 
 namespace iter {
 
@@ -15,7 +16,7 @@ namespace iter {
                 FilterFunc filter_func;
 
                 using contained_iter_ret =
-                    decltype(std::declval<Container>().begin().operator*());
+                    typename IterBase<Container>::contained_iter_ret;
 
             public:
                 PredicateFlipper(FilterFunc filter_func) :

From b99b66e9f26eea47c43e74cd225840f7b82087d1 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 7 Nov 2013 17:51:55 -0500
Subject: [PATCH 0142/1866] Updates to use IterBase and std::begin/end

---
 filter.hpp | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/filter.hpp b/filter.hpp
index 0b201383..3ed8e7c4 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -1,6 +1,8 @@
 #ifndef FILTER__H__
 #define FILTER__H__
 
+#include <iterbase.hpp>
+
 #include <utility>
 
 namespace iter {
@@ -13,7 +15,7 @@ namespace iter {
     Filter<FilterFunc, Container> filter(FilterFunc, Container &);
 
     template <typename FilterFunc, typename Container>
-    class Filter {
+    class Filter : IterBase<Container>{
         private:
             Container & container;
             FilterFunc filter_func;
@@ -21,12 +23,10 @@ namespace iter {
             // The filter function is the only thing allowed to create a Filter
             friend Filter filter<FilterFunc, Container>(FilterFunc,
                     Container &);
-            // Type of the Container::Iterator, but since the name of that 
-            // iterator can be anything, we have to grab it with this
-            using contained_iter_type = decltype(container.begin());
 
-            // The type returned when dereferencing the Container::Iterator
-            using contained_iter_ret = decltype(container.begin().operator*());
+            using typename IterBase<Container>::contained_iter_type;
+
+            using typename IterBase<Container>::contained_iter_ret;
             
             // Value constructor for use only in the filter function
             Filter(FilterFunc filter_func, Container & container) :
@@ -82,15 +82,15 @@ namespace iter {
 
             Iterator begin() const {
                 return Iterator(
-                        this->container.begin(),
-                        this->container.end(),
+                        std::begin(this->container),
+                        std::end(this->container),
                         this->filter_func);
             }
 
             Iterator end() const {
                 return Iterator(
-                        this->container.end(),
-                        this->container.end(),
+                        std::end(this->container),
+                        std::end(this->container),
                         this->filter_func);
             }
 
@@ -114,7 +114,7 @@ namespace iter {
         class BoolTester {
             protected:
                 using contained_iter_ret =
-                    decltype(std::declval<Container>().begin().operator*());
+                    typename IterBase<Container>::contained_iter_ret;
 
             public:
                 bool operator() (const contained_iter_ret item) const {

From f8904b7a1f4bef21f92c849d5e83e60abb9d3921 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 7 Nov 2013 17:55:42 -0500
Subject: [PATCH 0143/1866] Updates to use IterBase and std::begin/end

---
 groupby.hpp | 21 ++++++++++-----------
 1 file changed, 10 insertions(+), 11 deletions(-)

diff --git a/groupby.hpp b/groupby.hpp
index c468d83d..15d98eaf 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -1,8 +1,10 @@
 #ifndef GROUP__BY__HPP
 #define GROUP__BY__HPP
 
+#include <iterbase.hpp>
 
 #include <utility>
+#include <iterator>
 
 
 namespace iter {
@@ -14,7 +16,7 @@ namespace iter {
     GroupBy<Container, KeyFunc> groupby(Container &, KeyFunc);
 
     template <typename Container, typename KeyFunc>
-    class GroupBy {
+    class GroupBy : IterBase<Container> {
         private:
             Container & container;
             KeyFunc key_func;
@@ -22,12 +24,9 @@ namespace iter {
             // The filter function is the only thing allowed to create a Filter
             friend GroupBy groupby<Container, KeyFunc>(Container &, KeyFunc);
 
-            // Type of the Container::Iterator, but since the name of that 
-            // iterator can be anything, we have to grab it with this
-            using contained_iter_type = decltype(container.begin());
+            using typename IterBase<Container>::contained_iter_type;
 
-            // The type returned when dereferencing the Container::Iterator
-            using contained_iter_ret = decltype(container.begin().operator*());
+            using typename IterBase<Container>::contained_iter_ret;
 
             using key_func_ret =
                 decltype(std::declval<KeyFunc>()(
@@ -158,15 +157,15 @@ namespace iter {
 
             Iterator begin() const {
                 return Iterator(
-                        this->container.begin(),
-                        this->container.end(),
+                        std::begin(this->container),
+                        std::end(this->container),
                         this->key_func);
             }
 
             Iterator end() const {
                 return Iterator(
-                        this->container.end(),
-                        this->container.end(),
+                        std::end(this->container),
+                        std::end(this->container),
                         this->key_func);
             }
 
@@ -182,7 +181,7 @@ namespace iter {
     class ItemReturner {
         private:
             using contained_iter_ret =
-                decltype(std::declval<Container>().begin().operator*());
+                typename IterBase<Container>::contained_iter_ret;
         public:
             ItemReturner() = default;
             contained_iter_ret operator() (contained_iter_ret item) const {

From 382bb63ecf513e0c1e82565726f784f9ba5a1f74 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 7 Nov 2013 17:58:49 -0500
Subject: [PATCH 0144/1866] Tweaks #includes

---
 cycle.hpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/cycle.hpp b/cycle.hpp
index 6a8eb713..a6aaa029 100644
--- a/cycle.hpp
+++ b/cycle.hpp
@@ -1,9 +1,10 @@
 #ifndef CYCLE__H__
 #define CYCLE__H__
 
-#include "iterbase.hpp"
+#include <iterbase.hpp>
 
 #include <utility>
+#include <iterator>
 
 namespace iter {
 

From 620237670855b2fd2ec2376e229c922da10f4cc1 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 7 Nov 2013 17:58:53 -0500
Subject: [PATCH 0145/1866] Tweaks #includes

---
 dropwhile.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/dropwhile.hpp b/dropwhile.hpp
index 9ac899de..ab9dccdf 100644
--- a/dropwhile.hpp
+++ b/dropwhile.hpp
@@ -4,6 +4,7 @@
 #include <iterbase.hpp>
 
 #include <utility>
+#include <iterator>
 
 namespace iter {
 

From f5089e52736359b749e056d757791b704818e0b7 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 7 Nov 2013 17:58:57 -0500
Subject: [PATCH 0146/1866] Tweaks #includes

---
 enumerate.hpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index 9bd871e9..620b8c7e 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -1,9 +1,10 @@
 #ifndef ENUMERABLE__H__
 #define ENUMERABLE__H__
 
-#include "iterbase.hpp"
+#include <iterbase.hpp>
 
 #include <utility>
+#include <iterator>
 
 
 // enumerate functionality for python-style for-each enumerate loops

From 6785425ca6775f67e321ab1ffd65bd9eac0d40c8 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 7 Nov 2013 17:59:03 -0500
Subject: [PATCH 0147/1866] Tweaks #includes

---
 filter.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/filter.hpp b/filter.hpp
index 3ed8e7c4..0af88a29 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -4,6 +4,7 @@
 #include <iterbase.hpp>
 
 #include <utility>
+#include <iterator>
 
 namespace iter {
 

From 70bdfa16eed3ef597261d7c6cc69398ae2c52a51 Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Thu, 7 Nov 2013 18:02:31 -0500
Subject: [PATCH 0148/1866] added iterator_traits specializations to a bunch of
 iterators

---
 chain.hpp                         | 10 +++++-----
 combinations.hpp                  |  8 +++++++-
 combinations_with_replacement.hpp |  8 +++++++-
 grouper.hpp                       |  8 +++++++-
 moving_section.hpp                |  8 +++++++-
 permutations.hpp                  |  8 +++++++-
 powerset.hpp                      |  8 +++++++-
 product.hpp                       |  9 ++++++++-
 zip.hpp                           |  7 +++++++
 zip_longest.hpp                   | 10 +++++++++-
 10 files changed, 71 insertions(+), 13 deletions(-)

diff --git a/chain.hpp b/chain.hpp
index 36dfe7c0..2c536a27 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -94,10 +94,10 @@ namespace iter {
         }
 }
 namespace std {
-template <typename ... Containers>
-struct iterator_traits<iter::chain_iter<Containers...>> {
-    using difference_type = ptrdiff_t;
-    using iterator_category = input_iterator_tag;
-};
+    template <typename ... Containers>
+        struct iterator_traits<iter::chain_iter<Containers...>> {
+            using difference_type = ptrdiff_t;
+            using iterator_category = input_iterator_tag;
+        };
 }
 #endif //CHAIN_HPP
diff --git a/combinations.hpp b/combinations.hpp
index fab96317..8ef8939b 100644
--- a/combinations.hpp
+++ b/combinations.hpp
@@ -107,5 +107,11 @@ namespace iter {
             }
         };
 }
-
+namespace std {
+    template <typename Container>
+        struct iterator_traits<iter::combinations_iter<Container>> {
+            using difference_type = ptrdiff_t;
+            using iterator_category = input_iterator_tag;
+        };
+}
 #endif //COMBINATIONS_HPP
diff --git a/combinations_with_replacement.hpp b/combinations_with_replacement.hpp
index 4196a491..043e0cf2 100644
--- a/combinations_with_replacement.hpp
+++ b/combinations_with_replacement.hpp
@@ -90,5 +90,11 @@ namespace iter {
             }
         };
 }
-
+namespace std {
+    template <typename Container>
+        struct iterator_traits<iter::combinations_with_replacement_iter<Container>> {
+            using difference_type = ptrdiff_t;
+            using iterator_category = input_iterator_tag;
+        };
+}
 #endif //COMBINATIONS_WITH_REPLACEMENT_HPP
diff --git a/grouper.hpp b/grouper.hpp
index 5e57b2c8..b359ba7c 100644
--- a/grouper.hpp
+++ b/grouper.hpp
@@ -105,5 +105,11 @@ namespace iter {
             }
     };
 }
-
+namespace std {
+    template <typename Container>
+        struct iterator_traits<iter::grouper_iter<Container>> {
+            using difference_type = ptrdiff_t;
+            using iterator_category = input_iterator_tag;
+        };
+}
 #endif // ifndef GROUPER_HPP
diff --git a/moving_section.hpp b/moving_section.hpp
index 36ce2906..d4dc52f4 100644
--- a/moving_section.hpp
+++ b/moving_section.hpp
@@ -67,5 +67,11 @@ namespace iter {
             }
         };
 }
-
+namespace std {
+    template <typename Container>
+        struct iterator_traits<iter::moving_section_iter<Container>> {
+            using difference_type = ptrdiff_t;
+            using iterator_category = input_iterator_tag;
+        };
+}
 #endif //MOVING_SECTION_HPP
diff --git a/permutations.hpp b/permutations.hpp
index cd94269c..839452c9 100644
--- a/permutations.hpp
+++ b/permutations.hpp
@@ -40,6 +40,12 @@ namespace iter {
             }
         };
 }
-
+namespace std {
+    template <typename Container>
+        struct iterator_traits<iter::permutation_iter<Container>> {
+            using difference_type = ptrdiff_t;
+            using iterator_category = input_iterator_tag;
+        };
+}
 #endif //PERMUTATIONS_HPP
 
diff --git a/powerset.hpp b/powerset.hpp
index 7884f778..52398325 100644
--- a/powerset.hpp
+++ b/powerset.hpp
@@ -54,5 +54,11 @@ namespace iter {
             }
         }; 
 }
-
+namespace std {
+    template <typename Container>
+        struct iterator_traits<iter::powerset_iter<Container>> {
+            using difference_type = ptrdiff_t;
+            using iterator_category = input_iterator_tag;
+        };
+}
 #endif //POWERSET_HPP
diff --git a/product.hpp b/product.hpp
index 676dad9a..6b47cfd2 100644
--- a/product.hpp
+++ b/product.hpp
@@ -2,6 +2,7 @@
 #define PRODUCT_HPP
 #include <tuple>
 #include <utility>
+#include <iterator>
 #include "iterator_range.hpp"
 
 namespace iter {
@@ -108,7 +109,13 @@ namespace iter {
                 //since != only checks the first one
         };
 }
-
+namespace std {
+    template <typename ... Containers>
+        struct iterator_traits<iter::product_iter<Containers...>> {
+            using difference_type = ptrdiff_t;
+            using iterator_category = input_iterator_tag;
+        };
+}
 #endif //PRODUCT_HPP
                     
                     
diff --git a/zip.hpp b/zip.hpp
index 0f1bff07..909e03f4 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -109,4 +109,11 @@ namespace iter {
     };
 }
 
+namespace std {
+    template <typename ... Containers>
+        struct iterator_traits<iter::zip_iter<Containers...>> {
+            using difference_type = ptrdiff_t;
+            using iterator_category = input_iterator_tag;
+        };
+}
 #endif //ZIP_HPP
diff --git a/zip_longest.hpp b/zip_longest.hpp
index 1ee30fff..56d67e90 100644
--- a/zip_longest.hpp
+++ b/zip_longest.hpp
@@ -95,5 +95,13 @@ namespace iter {
 }
 //should add reset after the end of a range is reached, just in case someone 
 //tries to use it again
-//this means it's only safe to use the range ONCE
+//this means it's only safe to use the range ONCE, which is fine because of
+//the input_iterator_tag
+namespace std {
+    template <typename ... Containers>
+        struct iterator_traits<iter::zip_longest_iter<Containers...>> {
+            using difference_type = ptrdiff_t;
+            using iterator_category = input_iterator_tag;
+        };
+}
 #endif //ZIP_LONGEST_HPP

From 50685116e7e9bd9be627bfd963fe395d5fbd99e7 Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Thu, 7 Nov 2013 18:20:48 -0500
Subject: [PATCH 0149/1866] updated itertools.hpp to include everything '

---
 itertools.hpp | 57 ++++++++++++++++++++++++++++-----------------------
 1 file changed, 31 insertions(+), 26 deletions(-)

diff --git a/itertools.hpp b/itertools.hpp
index e0214b96..4aecb577 100644
--- a/itertools.hpp
+++ b/itertools.hpp
@@ -1,34 +1,39 @@
 #ifndef ITERTOOLS_HPP
 #define ITERTOOLS_HPP
 
-#include "zip.hpp"
-#include "reverse.hpp"
-#include "slice.hpp"
-#include "chain.hpp"
-#include "combinations_with_replacement.hpp"
-#include "combinations.hpp"
-#include "compress.hpp"
-#include "cycle.hpp"
-#include "dropwhile.hpp"
-#include "enumerate.hpp"
-#include "filter.hpp"
-#include "iterator_range.hpp"
-#include "permutations.hpp"
-#include "product.hpp"
-#include "range.hpp"
-#include "repeat.hpp"
-#include "reverse.hpp"
-#include "slice.hpp"
-#include "takewhile.hpp"
-#include "wrap_iter.hpp"
-#include "zip.hpp"
-#include "zip_longest.hpp"
-#include "powerset.hpp"
-#include "moving_section.hpp"
-#include "grouper.hpp"
-
+#include <chain.hpp>
+#include <combinations.hpp>
+#include <combinations_with_replacement.hpp>
+#include <compress.hpp>
+#include <count.hpp>
+#include <cycle.hpp>
+#include <dropwhile.hpp>
+#include <enumerate.hpp>
+#include <filter.hpp>
+#include <filterfalse.hpp>
+#include <groupby.hpp>
+#include <grouper.hpp>
+#include <imap.hpp>
+#include <iterator_range.hpp>
+#include <iterbase.hpp>
+#include <moving_section.hpp>
+#include <permutations.hpp>
+#include <powerset.hpp>
+#include <product.hpp>
+#include <range.hpp>
+#include <repeat.hpp>
+#include <reverse.hpp>
+#include <slice.hpp>
+#include <sorted.hpp>
+#include <takewhile.hpp>
+#include <unique_everseen.hpp>
+#include <unique_justseen.hpp>
+#include <wrap_iter.hpp>
+#include <zip.hpp>
+#include <zip_longest.hpp>
 //not sure if should include "iterator_range.hpp"
 //since it's already in everything
 
 #endif
 
+

From 882fd74606648ef8d3e912b87d8a61d4f7e4a084 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 7 Nov 2013 19:34:20 -0500
Subject: [PATCH 0150/1866] Tweaks includes

---
 imap.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/imap.hpp b/imap.hpp
index 5e156ff3..781679a9 100644
--- a/imap.hpp
+++ b/imap.hpp
@@ -1,7 +1,7 @@
 #ifndef IMAP__H__
 #define IMAP__H__
 
-#include "zip.hpp"
+#include <zip.hpp>
 
 #include <utility>
 #include <type_traits>

From 512196cc3897fe3ff2824666b8a599fb8dc3de74 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 7 Nov 2013 19:37:28 -0500
Subject: [PATCH 0151/1866] Updates to use IterBase and std::begin/end

---
 takewhile.hpp | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/takewhile.hpp b/takewhile.hpp
index 11123561..a41c6109 100644
--- a/takewhile.hpp
+++ b/takewhile.hpp
@@ -1,7 +1,10 @@
 #ifndef TAKEWHILE__H__
 #define TAKEWHILE__H__
 
+#include <iterbase.hpp>
+
 #include <utility>
+#include <iterator>
 
 namespace iter {
 
@@ -13,7 +16,7 @@ namespace iter {
     TakeWhile<FilterFunc, Container> takewhile(FilterFunc, Container &);
 
     template <typename FilterFunc, typename Container>
-    class TakeWhile {
+    class TakeWhile : IterBase<Container>{
         private:
             Container & container;
             FilterFunc filter_func;
@@ -21,12 +24,9 @@ namespace iter {
             friend TakeWhile takewhile<FilterFunc, Container>(
                     FilterFunc, Container &);
 
-            // Type of the Container::Iterator, but since the name of that 
-            // iterator can be anything, we have to grab it with this
-            using contained_iter_type = decltype(container.begin());
+            using typename IterBase<Container>::contained_iter_type;
 
-            // The type returned when dereferencing the Container::Iterator
-            using contained_iter_ret = decltype(container.begin().operator*());
+            using typename IterBase<Container>::contained_iter_ret;
 
             // Value constructor for use only in the takewhile function
             TakeWhile(FilterFunc filter_func, Container & container) :
@@ -82,15 +82,15 @@ namespace iter {
 
             Iterator begin() const {
                 return Iterator(
-                        this->container.begin(),
-                        this->container.end(),
+                        std::begin(this->container),
+                        std::end(this->container),
                         this->filter_func);
             }
 
             Iterator end() const {
                 return Iterator(
-                        this->container.end(),
-                        this->container.end(),
+                        std::end(this->container),
+                        std::end(this->container),
                         this->filter_func);
             }
 

From 78c3f3d59bf543171edc485e47a9e3a3502d18b4 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 7 Nov 2013 19:42:09 -0500
Subject: [PATCH 0152/1866] Updates to use IterBase

---
 sorted.hpp | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/sorted.hpp b/sorted.hpp
index b684ddfe..581b69c0 100644
--- a/sorted.hpp
+++ b/sorted.hpp
@@ -1,6 +1,9 @@
 #ifndef SORTED__HPP__
 #define SORTED__HPP__
 
+#include <iterbase.hpp>
+
+#include <iterator>
 #include <algorithm>
 #include <vector>
 
@@ -12,19 +15,18 @@ namespace iter {
     Sorted<Container, CompareFunc> sorted(Container &, CompareFunc);
 
     template <typename Container, typename CompareFunc>
-    class Sorted {
+    class Sorted : IterBase<Container> {
         private:
             friend Sorted
                 sorted<Container, CompareFunc>(Container &, CompareFunc);
 
-            using contained_iter_type =
-                decltype(std::declval<Container>().begin());
+            using typename IterBase<Container>::contained_iter_type;
+
+            using typename IterBase<Container>::contained_iter_ret;
 
             std::vector<contained_iter_type> sorted_iters;
 
-            using sorted_iter_type = decltype(sorted_iters.begin());
-            using contained_iter_ret = 
-                decltype(sorted_iters.begin().operator*().operator*());
+            using sorted_iter_type = decltype(std::begin(sorted_iters));
 
             Sorted() = delete;
             Sorted & operator=(const Sorted &) = delete;

From 9f0a16fa8c552ed9310274439c71cf277206dede Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 7 Nov 2013 19:50:46 -0500
Subject: [PATCH 0153/1866] Updates to use std::begin/end

---
 sorted.hpp | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/sorted.hpp b/sorted.hpp
index 581b69c0..b9b7a215 100644
--- a/sorted.hpp
+++ b/sorted.hpp
@@ -34,14 +34,14 @@ namespace iter {
             Sorted(Container & container, CompareFunc compare_func) {
                 // Fill the sorted_iters vector with an iterator to each
                 // element in the container
-                for (auto iter = container.begin();
-                        iter != container.end();
+                for (auto iter = std::begin(container);
+                        iter != std::end(container);
                         ++iter) {
                     sorted_iters.push_back(iter);
                 }
 
                 // sort by comparing the elements that the iterators point to
-                std::sort(sorted_iters.begin(), sorted_iters.end(),
+                std::sort(std::begin(sorted_iters), std::end(sorted_iters),
                         [&] (const contained_iter_type & it1,
                             const contained_iter_type & it2)
                         { return compare_func(*it1, *it2); });
@@ -67,12 +67,12 @@ namespace iter {
             };
 
             IteratorIterator begin() {
-                IteratorIterator iteriter(sorted_iters.begin());
+                IteratorIterator iteriter(std::begin(sorted_iters));
                 return iteriter;
             }
 
             IteratorIterator end() {
-                IteratorIterator iteriter(sorted_iters.end());
+                IteratorIterator iteriter(std::end(sorted_iters));
                 return iteriter;
             }
     };
@@ -88,13 +88,13 @@ namespace iter {
              decltype(sorted(
                          container,
                          std::less<decltype(
-                             std::declval<Container>().begin().operator*())>()
+                             *std::begin(std::declval<Container>()))>()
                          ))
      {
          return sorted(
                  container,
                  std::less<decltype(
-                     std::declval<Container>().begin().operator*())>()
+                     *std::begin(std::declval<Container>()))>()
                  );
     }
 

From ca782827d90ddbf865a60ac00f2f92bff3fbfd72 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 7 Nov 2013 19:55:16 -0500
Subject: [PATCH 0154/1866] Sorts by first character to avoid confusion

---
 tests/testsorted.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tests/testsorted.cpp b/tests/testsorted.cpp
index 7abdafc6..2a0bea29 100644
--- a/tests/testsorted.cpp
+++ b/tests/testsorted.cpp
@@ -18,11 +18,12 @@ int main()
         std::cout << i << '\n';
     }
 
+    std::cout << "Sort by first character only\n";
     std::vector<std::string> svec = {"hello", "everyone", "thanks", "for",
                                      "having", "me", "here", "today"};
     for (auto s : sorted(svec,
                 [] (const std::string & s1, const std::string & s2) {
-                    return s1[1] < s2[1]; })) {
+                    return s1[0] < s2[0]; })) {
         std::cout << s << '\n';
     }
         

From 3339646d49503cfff70c4242f651aabb34ded2c5 Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Fri, 8 Nov 2013 18:19:58 -0500
Subject: [PATCH 0155/1866] grouper readme written

---
 README.md | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/README.md b/README.md
index f6646077..7cf6e800 100644
--- a/README.md
+++ b/README.md
@@ -21,6 +21,7 @@ library.
 [reverse](#reverse)<br />
 [slice](#slice)<br />
 [moving_section](#moving_section)<br />
+[grouper](#grouper)<br />
 
 ##### Combinatoric fuctions
 [product](#product)<br />
@@ -328,6 +329,26 @@ for (auto sec : moving_section(v,4)) {
     std::cout << std::endl;                                                    
 }
 ```  
+grouper
+------
+
+grouper is very similar to moving section, exception instead of the 
+section sliding by only 1 it goes the length of the full section.
+
+Example usage:
+```c++
+std::vector<int> v {1,2,3,4,5,6,7,8,9};                                        
+for (auto sec : grouper(v,4)) 
+//each section will have 4 elements
+//except the last one may be cut short
+{
+    for (auto i : sec) {                                                       
+        std::cout << i << " ";                                                 
+        i.get() *= 2;                                                          
+    }                                                                          
+    std::cout << std::endl;                                                    
+}  
+```
 
 product
 ------

From 47b853a016a6b8f23f56142ed868ebbecbc51081 Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Fri, 8 Nov 2013 18:28:57 -0500
Subject: [PATCH 0156/1866] Updated for filter adaptors

---
 README.md | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/README.md b/README.md
index 7cf6e800..b227a8a4 100644
--- a/README.md
+++ b/README.md
@@ -13,6 +13,8 @@ library.
 [imap](#imap)<br />
 [filter](#filter)<br />
 [filterfalse](#filterfalse)<br />
+[unique_everseen](#unique_everseen)<br />
+[unique_justseen](#unique_justseen)<br />
 [takewhile](#takewhile)<br />
 [dropwhile](#dropwhile)<br />
 [cycle](#cycle)<br />
@@ -134,6 +136,33 @@ for(auto i : filterfalse(vec)) {
     cout << i << '\n';
 }
 ```
+unique_everseen
+---------------
+This is a filter adaptor that only generates values that have never been seen 
+before. For this algo to work your object must be specialized for `std::hash`
+otherwise it will not be very efficient
+
+Example Usage:
+```c++
+std::vector<int> v {1,2,3,4,3,2,1,5,6,7,7,8,9,8,9,6};                      
+for (auto i : unique_everseen(v)) {                                        
+    std::cout << i << " ";                                                 
+}std::cout << std::endl; 
+```
+
+unique_justseen
+--------------
+Another filter adaptor that only prevents duplicates that are in a row, if the 
+sequence is sorted it will work exactly the same as `unique_justseen`, in that 
+case it will be better and more efficient to use.
+
+Example Usage:
+```c++
+std::vector<int> v {1,1,1,2,2,4,4,5,6,7,8,8,8,8,9,9};                          
+for (auto i : unique_justseen(v)) {                                            
+    std::cout << i << " ";                                                     
+}std::cout << std::endl; 
+```
 
 takewhile
 ---------

From f8b9e620187f468b96b6a2f5e0badb1e7a0f6386 Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Sat, 9 Nov 2013 12:46:20 -0500
Subject: [PATCH 0157/1866] fixed small error in unique_everseen test file

---
 tests/testunique_everseen.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/tests/testunique_everseen.cpp b/tests/testunique_everseen.cpp
index e373a8a3..d57674e7 100644
--- a/tests/testunique_everseen.cpp
+++ b/tests/testunique_everseen.cpp
@@ -14,7 +14,6 @@ int main() {
         }std::cout << std::endl;
     }
     {
-        //should work same as justseen here
         std::vector<int> v {1,2,3,4,3,2,1,5,6,7,7,8,9,8,9,6};
         for (auto i : unique_everseen(v)) {
             std::cout << i << " ";

From 5ba041c54f920aafcc9eee0870b28e1b420b4e31 Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Sat, 9 Nov 2013 14:45:28 -0500
Subject: [PATCH 0158/1866] Added zip test file for boost

---
 boost_tests/.gitignore                   |   3 +
 boost_tests/SConstruct                   |  31 +++++++
 boost_tests/pattern_files/zip_output.txt |  36 ++++++++
 boost_tests/testzip.cpp                  | 100 +++++++++++++++++++++++
 4 files changed, 170 insertions(+)
 create mode 100644 boost_tests/.gitignore
 create mode 100644 boost_tests/SConstruct
 create mode 100644 boost_tests/pattern_files/zip_output.txt
 create mode 100644 boost_tests/testzip.cpp

diff --git a/boost_tests/.gitignore b/boost_tests/.gitignore
new file mode 100644
index 00000000..5d88f468
--- /dev/null
+++ b/boost_tests/.gitignore
@@ -0,0 +1,3 @@
+*.o
+*.dblite
+testzip
diff --git a/boost_tests/SConstruct b/boost_tests/SConstruct
new file mode 100644
index 00000000..13eb390c
--- /dev/null
+++ b/boost_tests/SConstruct
@@ -0,0 +1,31 @@
+import platform
+import os
+
+env = Environment(
+    CXX='c++',
+    CXXFLAGS= ['-g',  '-Wall', '-Wextra',  '-Weffc++', '-Wno-unused-parameter' ,
+               '-pedantic', '-std=c++11',
+               '-I/usr/local/include', '-I/opt/local/include'],
+    CPPPATH='..',
+    LINKFLAGS=['-L/usr/local/lib', '-L/opt/local/lib']
+    )
+
+# allows highighting to print to terminal from compiler output
+env['ENV']['TERM'] = os.environ['TERM']
+
+# if on MAC, needs the linker flag for -stdlib=libc++
+# obselete with mavericks
+""" if platform.system() == 'Darwin':
+    env['CXX'] += '-stdlib=libc++'
+    env['CXXFLAGS'].append('-stdlib=libc++')
+"""
+
+
+
+progs = Split( '''
+		zip 
+        ''')
+
+
+for p in progs:
+    env.Program('test{0}.cpp'.format(p))
diff --git a/boost_tests/pattern_files/zip_output.txt b/boost_tests/pattern_files/zip_output.txt
new file mode 100644
index 00000000..f2ea8edd
--- /dev/null
+++ b/boost_tests/pattern_files/zip_output.txt
@@ -0,0 +1,36 @@
+1
+hello
+4
+good day
+9
+goodbye
+69
+hello
+69
+good day
+69
+goodbye
+
+Variadic template zip iterator
+1 1.2 i 1.2
+2 1.4 like 1.2
+3 12.3 apples 1.2
+4 4.5 alot 1.2
+
+1 i 2.2 1.2
+2 like 2.2 1.2
+3 apples 2.2 1.2
+4 alot 2.2 1.2
+
+Try some weird range differences
+
+
+2.2 i 1 1.2
+2.2 like 2 1.2
+2.2 apples 3 1.2
+2.2 alot 4 1.2
+
+1 asdfas 1.1
+5 aaron 2.2
+1 ryan 3.3
+2 apple 4.4
diff --git a/boost_tests/testzip.cpp b/boost_tests/testzip.cpp
new file mode 100644
index 00000000..cf2ced29
--- /dev/null
+++ b/boost_tests/testzip.cpp
@@ -0,0 +1,100 @@
+#include "../zip.hpp"
+#include "../chain.hpp"
+#include <vector>
+#include <string>
+#include <iostream>
+#include <array>
+
+#define BOOST_TEST_MODULE ZipTest test
+#include <boost/test/included/unit_test.hpp>
+#include <boost/test/output_test_stream.hpp>
+using boost::test_tools::output_test_stream;
+
+
+using iter::zip;
+
+BOOST_AUTO_TEST_CASE ( zip_test ) {
+
+    output_test_stream output("pattern_files/zip_output.txt",true);
+    //Ryan's test
+    {
+        std::vector<int> ivec{1, 4, 9, 16, 25, 36};
+        std::vector<std::string> svec{"hello", "good day", "goodbye"};
+
+        for (auto e : zip(ivec, svec)) {
+            auto &i = std::get<0>(e);
+            output << i << std::endl;
+            i = 69;
+            output << std::get<1>(e) << std::endl;
+        }
+        BOOST_REQUIRE(output.match_pattern());
+        for (auto e : zip(ivec, svec)) {
+            output << std::get<0>(e) << std::endl;
+            output << std::get<1>(e) << std::endl;
+        }
+        BOOST_REQUIRE(output.match_pattern());
+    }
+    //Aaron's test
+    {
+        std::array<int,4> i{{1,2,3,4}};
+        std::vector<float> f{1.2,1.4,12.3,4.5,9.9};
+        std::vector<std::string> s{"i","like","apples","alot","dude"};
+        std::array<double,5> d{{1.2,1.2,1.2,1.2,1.2}};
+        output << std::endl << "Variadic template zip iterator" << std::endl;
+        for (auto e : iter::zip(i,f,s,d)) {
+            output << std::get<0>(e) << " " 
+                << std::get<1>(e) << " " 
+                << std::get<2>(e) << " "
+                << std::get<3>(e) << std::endl;
+            std::get<1>(e)=2.2f; //modify the float array
+        }
+        output<<std::endl;
+        BOOST_REQUIRE(output.match_pattern());
+        for (auto e : iter::zip(i,s,f,d)) {
+            output << std::get<0>(e) << " " 
+                << std::get<1>(e) << " "
+                << std::get<2>(e) << " " 
+                << std::get<3>(e) << std::endl;
+        }
+        BOOST_REQUIRE(output.match_pattern());
+        output << std::endl << "Try some weird range differences" << std::endl;
+        std::vector<int> empty{};
+        for (auto e : iter::zip(empty,f,s,d)) {
+            output << std::get<0>(e) << " " 
+                << std::get<1>(e) << " " 
+                << std::get<2>(e) << " "
+                << std::get<3>(e) << std::endl;
+        }
+        output<<std::endl;
+        BOOST_REQUIRE(output.match_pattern());
+        for (auto e : iter::zip(f,s,empty,d)) {
+            output << std::get<0>(e) << " " 
+                << std::get<1>(e) << " " 
+                << std::get<2>(e) << " "
+                << std::get<3>(e) << std::endl;
+        }//both should print nothing
+        output<<std::endl;
+        BOOST_REQUIRE(output.match_pattern());
+        for (auto e : iter::zip(f,s,i,d)) { //i should be the limiter now
+            output << std::get<0>(e) << " " 
+                << std::get<1>(e) << " " 
+                << std::get<2>(e) << " "
+                << std::get<3>(e) << std::endl;
+        }
+        output<<std::endl;
+        BOOST_REQUIRE(output.match_pattern());
+        const std::vector<double> constvector{1.1,2.2,3.3,4.4};
+        for (auto e : zip(iter::chain(std::vector<int>{1,5},std::array<int,2>{{1,2}}),
+                    std::initializer_list<std::string>{"asdfas","aaron","ryan","apple","juice"},
+                    constvector)) 
+        { 
+
+            output << std::get<0>(e) << " " 
+                << std::get<1>(e) << " " 
+                << std::get<2>(e) << std::endl;
+        }
+        BOOST_REQUIRE(output.match_pattern());
+    }
+    BOOST_REQUIRE(output.match_pattern());
+}
+

From f6525c15ae163f2b505cf18eea63329d7b1d8092 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 13 Nov 2013 11:23:10 -0500
Subject: [PATCH 0159/1866] Adds support for initializer_lists to enumerate

---
 enumerate.hpp           | 20 ++++++++++++++------
 tests/testenumerate.cpp |  5 +++++
 2 files changed, 19 insertions(+), 6 deletions(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index 620b8c7e..0bee2657 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -5,6 +5,7 @@
 
 #include <utility>
 #include <iterator>
+#include <functional>
 
 
 // enumerate functionality for python-style for-each enumerate loops
@@ -22,9 +23,11 @@ namespace iter {
     template <typename Container>
     class Enumerable;
 
-    template <typename Container>
-    Enumerable<Container> enumerate(Container &);
+    template <typename T>
+    Enumerable<std::initializer_list<T>> enumerate(std::initializer_list<T> && il);
 
+    template <typename Container>
+    Enumerable<Container> enumerate(Container &&);
 
     template <typename Container>
     class Enumerable : public IterBase<Container>{
@@ -32,19 +35,19 @@ namespace iter {
             Container & container;
             // The only thing allowed to directly instantiate an Enumerable is
             // the enumerate function
-            friend Enumerable enumerate<Container>(Container &);
+            //friend Enumerable enumerate<Container>(Container &);
 
             using typename IterBase<Container>::contained_iter_type;
 
             using typename IterBase<Container>::contained_iter_ret;
 
             
+        public:
             // Value constructor for use only in the enumerate function
             Enumerable(Container & container) : container(container) { }
             Enumerable () = delete;
             Enumerable & operator=(const Enumerable &) = delete;
 
-        public:
             Enumerable(const Enumerable &) = default;
 
             // "yielded" by the Enumerable::Iterator.  Has a .index, and a 
@@ -98,10 +101,15 @@ namespace iter {
 
     // Helper function to instantiate an Enumerable
     template <typename Container>
-    Enumerable<Container> enumerate(Container & container) {
-        return Enumerable<Container>(container);
+    Enumerable<Container> enumerate(Container && container) {
+        return Enumerable<Container>(std::forward<Container>(container));
     }
 
+    template <typename T>
+    Enumerable<std::initializer_list<T>> enumerate(std::initializer_list<T> && il)
+    {
+        return Enumerable<std::initializer_list<T>>(il);
+    }
 
 }
 
diff --git a/tests/testenumerate.cpp b/tests/testenumerate.cpp
index faebd71f..a6b3adf9 100644
--- a/tests/testenumerate.cpp
+++ b/tests/testenumerate.cpp
@@ -31,5 +31,10 @@ int main() {
         std::cout << e.index << ": " << e.element << '\n';
     }
 
+
+    for (auto e : enumerate({0, 1, 4, 9, 16, 25})) {
+        std::cout << e.index << "^2 = " << e.element << '\n';
+    }
+
     return 0;
 }

From 2a4f4c18b49b3c6e5ca7df2fbe4088d7149b145e Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 13 Nov 2013 23:04:59 -0500
Subject: [PATCH 0160/1866] Makes Enumerable ctor private again

---
 enumerate.hpp | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index 0bee2657..816bd6e6 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -24,7 +24,8 @@ namespace iter {
     class Enumerable;
 
     template <typename T>
-    Enumerable<std::initializer_list<T>> enumerate(std::initializer_list<T> && il);
+    Enumerable<std::initializer_list<T>> enumerate(
+            std::initializer_list<T> &&);
 
     template <typename Container>
     Enumerable<Container> enumerate(Container &&);
@@ -33,18 +34,21 @@ namespace iter {
     class Enumerable : public IterBase<Container>{
         private:
             Container & container;
+
             // The only thing allowed to directly instantiate an Enumerable is
             // the enumerate function
-            //friend Enumerable enumerate<Container>(Container &);
+            friend Enumerable enumerate<Container>(Container &&);
+            template <typename T>
+            friend Enumerable<std::initializer_list<T>> enumerate(std::initializer_list<T> &&);
 
             using typename IterBase<Container>::contained_iter_type;
 
             using typename IterBase<Container>::contained_iter_ret;
 
+            Enumerable(Container & container) : container(container) { }
             
         public:
             // Value constructor for use only in the enumerate function
-            Enumerable(Container & container) : container(container) { }
             Enumerable () = delete;
             Enumerable & operator=(const Enumerable &) = delete;
 

From d6e3ee29a21bf6dc9dfabba41f608d4b7243c850 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 13 Nov 2013 23:33:21 -0500
Subject: [PATCH 0161/1866] Starts converting slice.hpp to use helper Slice

---
 slice.hpp | 81 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 81 insertions(+)

diff --git a/slice.hpp b/slice.hpp
index aea7d1ce..c989de7a 100644
--- a/slice.hpp
+++ b/slice.hpp
@@ -45,6 +45,87 @@ namespace iter {
         return slice(std::forward<Container>(container),0,end);
     }
 
+    //Forward declarations of Slice and slice
+    template <typename Container>
+    class Slice;
+
+    //template <typename T>
+    //Slice<std::initializer_list<T>> slice( std::initializer_list<T> &&);
+
+    template <typename Container>
+    Slice<Container> slice(Container &&);
+
+    template <typename Container>
+    class Slice : public IterBase<Container>{
+        private:
+            Container & container;
+
+            // The only thing allowed to directly instantiate an Slice is
+            // the slice function
+            friend Slice slice<Container>(Container &&);
+            //template <typename T>
+            //friend Slice<std::initializer_list<T>> slice(std::initializer_list<T> &&);
+
+            using typename IterBase<Container>::contained_iter_type;
+
+            using typename IterBase<Container>::contained_iter_ret;
+
+            Slice(Container & container) : container(container) { }
+            
+        public:
+            // Value constructor for use only in the slice function
+            Slice () = delete;
+            Slice & operator=(const Slice &) = delete;
+
+            Slice(const Slice &) = default;
+
+
+            //  Holds an iterator of the contained type and a size_t for the
+            //  index.  Each call to ++ increments both of these data members.
+            //  Each dereference returns an IterYield.
+            class Iterator {
+                private:
+                    contained_iter_type sub_iter;
+                public:
+                    Iterator (contained_iter_type si) :
+                        sub_iter(si)
+                    { }
+
+                    IterYield operator*() const {
+                        return IterYield(this->index, *this->sub_iter);
+                    }
+
+                    Iterator & operator++() { 
+                        ++this->sub_iter;
+                        return *this;
+                    }
+
+                    bool operator!=(const Iterator & other) const {
+                        return this->sub_iter != other.sub_iter;
+                    }
+            };
+
+            Iterator begin() const {
+                return Iterator(std::begin(this->container));
+            }
+
+            Iterator end() const {
+                return Iterator(std::end(this->container));
+            }
+
+    };
+    // Helper function to instantiate an Slice
+    template <typename Container>
+    Slice<Container> slice(Container && container) {
+        return Slice<Container>(std::forward<Container>(container));
+    }
+
+    template <typename T>
+    Slice<std::initializer_list<T>> slice(std::initializer_list<T> && il)
+    {
+        return Slice<std::initializer_list<T>>(il);
+    }
+
 }
 
 #endif //SLICE_HPP

From d5614a1ae270d5d691ae1c9a89bce2a54746a515 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 13 Nov 2013 23:37:43 -0500
Subject: [PATCH 0162/1866] Adds test with step larger than range for slice

Should give a slice with only the first element, instead gives
an empty slice
---
 tests/testslice.cpp | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/tests/testslice.cpp b/tests/testslice.cpp
index 84159637..030beb66 100644
--- a/tests/testslice.cpp
+++ b/tests/testslice.cpp
@@ -8,6 +8,13 @@ int main() {
     std::cout << std::endl << "Slice range test" << std::endl << std::endl;
     std::vector<int> a{0,1,2,3,4,5,6,7,8,9,10,11,12,13};
     std::vector<std::string> b{"hey","how","are","you","doing"};
+
+    std::cout << "step out of slice\n";
+    for (auto i : iter::slice(a, 1, 4, 5)) {
+        std::cout << i << '\n';
+    }
+    std::cout << "end step out\n";
+
     for (auto i : iter::slice(a,2)) {
         std::cout << i << std::endl;
     }

From 7a3584c39be5a2cb8843f8e2241ff18a4a7bd45f Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Wed, 13 Nov 2013 23:50:57 -0500
Subject: [PATCH 0163/1866] changed testzip

---
 boost_tests/testzip.cpp | 8 +++++++-
 tests/testzip.cpp       | 2 +-
 2 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/boost_tests/testzip.cpp b/boost_tests/testzip.cpp
index cf2ced29..802924d3 100644
--- a/boost_tests/testzip.cpp
+++ b/boost_tests/testzip.cpp
@@ -6,7 +6,13 @@
 #include <array>
 
 #define BOOST_TEST_MODULE ZipTest test
-#include <boost/test/included/unit_test.hpp>
+
+#ifdef COMPILED_BINARY
+    #include <boost/test/unit_test.hpp>
+#else
+    #include <boost/test/included/unit_test.hpp>
+#endif
+
 #include <boost/test/output_test_stream.hpp>
 using boost::test_tools::output_test_stream;
 
diff --git a/tests/testzip.cpp b/tests/testzip.cpp
index ea30599a..eb0ef476 100644
--- a/tests/testzip.cpp
+++ b/tests/testzip.cpp
@@ -71,7 +71,7 @@ int main() {
         }
         std::cout<<std::endl;
         const std::vector<double> constvector{1.1,2.2,3.3,4.4};
-        for (auto e : zip(iter::chain(std::vector<int>{1,5},std::array<int,2>{{1,2}}),
+        for (auto e : zip(iter::chain(std::vector<int>(5,5),std::array<int,2>{{1,2}}),
                     std::initializer_list<std::string>{"asdfas","aaron","ryan","apple","juice"},
                     constvector)) 
         { 

From 4f76b9984456de6c22c546b4bc0bde811190bc1e Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Wed, 13 Nov 2013 23:53:24 -0500
Subject: [PATCH 0164/1866] added include in enumerate

---
 enumerate.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/enumerate.hpp b/enumerate.hpp
index 816bd6e6..ef367d52 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -6,6 +6,7 @@
 #include <utility>
 #include <iterator>
 #include <functional>
+#include <initializer_list>
 
 
 // enumerate functionality for python-style for-each enumerate loops

From 1dd3bbf152be95e74925a524ecd58a3d8a9049a3 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 13 Nov 2013 23:57:26 -0500
Subject: [PATCH 0165/1866] continuing development on slice...

---
 slice.hpp | 92 ++++++++++++++++++++++++++++---------------------------
 1 file changed, 47 insertions(+), 45 deletions(-)

diff --git a/slice.hpp b/slice.hpp
index c989de7a..7cfd5674 100644
--- a/slice.hpp
+++ b/slice.hpp
@@ -8,61 +8,25 @@
 #include <cassert>
 
 namespace iter {
-    template <typename Container, typename DifferenceType>
-    auto slice( Container && container,
-            DifferenceType begin,
-            DifferenceType end,
-            DifferenceType step = 1
-            ) -> iterator_range<wrap_iter<decltype(std::begin(container))>>
-    {
-        // Check for an invalid slice. The sign of step must be equal to the
-        // sign of (end - begin). Since we don't force DifferenceType to be a
-        // primitive, just compare.
-        if (!(begin > end && step < 0) && !(begin <= end && step > 0)) {
-            // Just in case it gets dereferenced it will be the first element
-            // had the range been valid. This handles zero-length slices.
-            auto empty = std::next(std::begin(container), begin);
-            return iterator_range<wrap_iter<decltype(std::begin(container))>>(
-                    make_wrap_iter(empty, step),
-                    make_wrap_iter(empty, step));
-        }
-        // Return the iterator range
-        DifferenceType new_end = end - ((end - begin) % step);
-        auto begin_iter = std::next(std::begin(container), begin);
-        auto end_iter = std::next(std::begin(container), new_end);
-        return iterator_range<wrap_iter<decltype(std::begin(container))>>(
-                make_wrap_iter(begin_iter,step),
-                make_wrap_iter(end_iter,step));
-
-    }
-    //only give the end as an arg and assume step  is 1 and begin is 0
-    template <typename Container, typename DifferenceType>
-    auto slice(
-            Container && container,
-            DifferenceType end
-            ) -> iterator_range<wrap_iter<decltype(std::begin(container))>>
-    {
-        return slice(std::forward<Container>(container),0,end);
-    }
 
     //Forward declarations of Slice and slice
-    template <typename Container>
-    class Slice;
+    //template <typename Container, typename DifferenceType>
+    //class Slice;
 
     //template <typename T>
     //Slice<std::initializer_list<T>> slice( std::initializer_list<T> &&);
 
-    template <typename Container>
-    Slice<Container> slice(Container &&);
+    //template <typename Container, typename DifferenceType>
+    //Slice<Container> slice(Container &&);
 
-    template <typename Container>
+    template <typename Container, typename DifferencType>
     class Slice : public IterBase<Container>{
         private:
             Container & container;
 
             // The only thing allowed to directly instantiate an Slice is
             // the slice function
-            friend Slice slice<Container>(Container &&);
+            //friend Slice slice<Container, DifferenceType>(Container &&);
             //template <typename T>
             //friend Slice<std::initializer_list<T>> slice(std::initializer_list<T> &&);
 
@@ -70,9 +34,16 @@ namespace iter {
 
             using typename IterBase<Container>::contained_iter_ret;
 
-            Slice(Container & container) : container(container) { }
             
         public:
+            Slice(Container & container, DifferenceType start,
+                  DifferenceType stop, DifferenceType step=1) :
+                container(container),
+                start(start),
+                stop(stop),
+                step(step)
+            { }
+
             // Value constructor for use only in the slice function
             Slice () = delete;
             Slice & operator=(const Slice &) = delete;
@@ -115,17 +86,48 @@ namespace iter {
 
     };
     // Helper function to instantiate an Slice
-    template <typename Container>
-    Slice<Container> slice(Container && container) {
+    template <typename Container, typename DifferencType>
+    Slice<Container, DifferenceType> slice(Container && container) {
         return Slice<Container>(std::forward<Container>(container));
     }
 
+#if 0
     template <typename T>
     Slice<std::initializer_list<T>> slice(std::initializer_list<T> && il)
     {
         return Slice<std::initializer_list<T>>(il);
     }
+#endif
 
+        // Check for an invalid slice. The sign of step must be equal to the
+        // sign of (end - begin). Since we don't force DifferenceType to be a
+        // primitive, just compare.
+        if (!(begin > end && step < 0) && !(begin <= end && step > 0)) {
+            // Just in case it gets dereferenced it will be the first element
+            // had the range been valid. This handles zero-length slices.
+            auto empty = std::next(std::begin(container), begin);
+            return iterator_range<wrap_iter<decltype(std::begin(container))>>(
+                    make_wrap_iter(empty, step),
+                    make_wrap_iter(empty, step));
+        }
+        // Return the iterator range
+        DifferenceType new_end = end - ((end - begin) % step);
+        auto begin_iter = std::next(std::begin(container), begin);
+        auto end_iter = std::next(std::begin(container), new_end);
+        return iterator_range<wrap_iter<decltype(std::begin(container))>>(
+                make_wrap_iter(begin_iter,step),
+                make_wrap_iter(end_iter,step));
+
+    }
+    //only give the end as an arg and assume step  is 1 and begin is 0
+    template <typename Container, typename DifferenceType>
+    auto slice(
+            Container && container,
+            DifferenceType end
+            ) -> iterator_range<wrap_iter<decltype(std::begin(container))>>
+    {
+        return slice(std::forward<Container>(container),0,end);
+    }
 }
 
 #endif //SLICE_HPP

From 25d753517ed4047c3cf43a3e9bd939ca75e7766c Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 14 Nov 2013 00:15:36 -0500
Subject: [PATCH 0166/1866] Rough completion of slice conversion

---
 slice.hpp | 74 +++++++++++++++++++++----------------------------------
 1 file changed, 28 insertions(+), 46 deletions(-)

diff --git a/slice.hpp b/slice.hpp
index 7cfd5674..fffc71ca 100644
--- a/slice.hpp
+++ b/slice.hpp
@@ -1,8 +1,7 @@
 #ifndef SLICE_HPP
 #define SLICE_HPP
 
-#include "iterator_range.hpp"
-#include "wrap_iter.hpp"
+#include <iterbase.hpp>
 
 #include <iterator>
 #include <cassert>
@@ -19,10 +18,13 @@ namespace iter {
     //template <typename Container, typename DifferenceType>
     //Slice<Container> slice(Container &&);
 
-    template <typename Container, typename DifferencType>
+    template <typename Container, typename DifferenceType>
     class Slice : public IterBase<Container>{
         private:
             Container & container;
+            DifferenceType start;
+            DifferenceType stop;
+            DifferenceType step;
 
             // The only thing allowed to directly instantiate an Slice is
             // the slice function
@@ -37,12 +39,17 @@ namespace iter {
             
         public:
             Slice(Container & container, DifferenceType start,
-                  DifferenceType stop, DifferenceType step=1) :
+                  DifferenceType stop, DifferenceType step) :
                 container(container),
                 start(start),
                 stop(stop),
                 step(step)
-            { }
+            { 
+                if ((start < stop && step) <=0 ||
+                        (start > stop && step >=0)){
+                    this->stop = start;
+                } 
+            }
 
             // Value constructor for use only in the slice function
             Slice () = delete;
@@ -62,8 +69,8 @@ namespace iter {
                         sub_iter(si)
                     { }
 
-                    IterYield operator*() const {
-                        return IterYield(this->index, *this->sub_iter);
+                    contained_iter_ret operator*() const {
+                        return *this->sub_iter;
                     }
 
                     Iterator & operator++() { 
@@ -77,56 +84,31 @@ namespace iter {
             };
 
             Iterator begin() const {
-                return Iterator(std::begin(this->container));
+                return Iterator(std::next(
+                            std::begin(this->container), this->start));
             }
 
             Iterator end() const {
-                return Iterator(std::end(this->container));
+                return Iterator(std::next(
+                            std::begin(this->container), this->stop));
             }
 
     };
     // Helper function to instantiate an Slice
-    template <typename Container, typename DifferencType>
-    Slice<Container, DifferenceType> slice(Container && container) {
-        return Slice<Container>(std::forward<Container>(container));
-    }
-
-#if 0
-    template <typename T>
-    Slice<std::initializer_list<T>> slice(std::initializer_list<T> && il)
-    {
-        return Slice<std::initializer_list<T>>(il);
+    template <typename Container, typename DifferenceType>
+    Slice<Container, DifferenceType> slice(
+            Container && container, DifferenceType start,
+            DifferenceType stop, DifferenceType step=1) {
+        return Slice<Container, DifferenceType>(
+                std::forward<Container>(container), start, stop, step);
     }
-#endif
-
-        // Check for an invalid slice. The sign of step must be equal to the
-        // sign of (end - begin). Since we don't force DifferenceType to be a
-        // primitive, just compare.
-        if (!(begin > end && step < 0) && !(begin <= end && step > 0)) {
-            // Just in case it gets dereferenced it will be the first element
-            // had the range been valid. This handles zero-length slices.
-            auto empty = std::next(std::begin(container), begin);
-            return iterator_range<wrap_iter<decltype(std::begin(container))>>(
-                    make_wrap_iter(empty, step),
-                    make_wrap_iter(empty, step));
-        }
-        // Return the iterator range
-        DifferenceType new_end = end - ((end - begin) % step);
-        auto begin_iter = std::next(std::begin(container), begin);
-        auto end_iter = std::next(std::begin(container), new_end);
-        return iterator_range<wrap_iter<decltype(std::begin(container))>>(
-                make_wrap_iter(begin_iter,step),
-                make_wrap_iter(end_iter,step));
 
-    }
     //only give the end as an arg and assume step  is 1 and begin is 0
     template <typename Container, typename DifferenceType>
-    auto slice(
-            Container && container,
-            DifferenceType end
-            ) -> iterator_range<wrap_iter<decltype(std::begin(container))>>
-    {
-        return slice(std::forward<Container>(container),0,end);
+    Slice<Container, DifferenceType> slice(
+            Container && container, DifferenceType stop) {
+        return Slice<Container, DifferenceType>(
+                std::forward<Container>(container), 0, stop, 1);
     }
 }
 

From d6304d76aa3c1118ba05964e9ec6f9e12e007a9a Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 14 Nov 2013 00:29:35 -0500
Subject: [PATCH 0167/1866] Almost functioning conversion of slice

---
 slice.hpp | 21 ++++++++++++---------
 1 file changed, 12 insertions(+), 9 deletions(-)

diff --git a/slice.hpp b/slice.hpp
index fffc71ca..af93db28 100644
--- a/slice.hpp
+++ b/slice.hpp
@@ -4,7 +4,6 @@
 #include <iterbase.hpp>
 
 #include <iterator>
-#include <cassert>
 
 namespace iter {
 
@@ -45,7 +44,7 @@ namespace iter {
                 stop(stop),
                 step(step)
             { 
-                if ((start < stop && step) <=0 ||
+                if ((start < stop && step <=0) ||
                         (start > stop && step >=0)){
                     this->stop = start;
                 } 
@@ -64,9 +63,11 @@ namespace iter {
             class Iterator {
                 private:
                     contained_iter_type sub_iter;
+                    DifferenceType step;
                 public:
-                    Iterator (contained_iter_type si) :
-                        sub_iter(si)
+                    Iterator (contained_iter_type si, DifferenceType step) :
+                        sub_iter(si),
+                        step(step)
                     { }
 
                     contained_iter_ret operator*() const {
@@ -74,7 +75,7 @@ namespace iter {
                     }
 
                     Iterator & operator++() { 
-                        ++this->sub_iter;
+                        std::advance(this->sub_iter, this->step);
                         return *this;
                     }
 
@@ -84,13 +85,15 @@ namespace iter {
             };
 
             Iterator begin() const {
-                return Iterator(std::next(
-                            std::begin(this->container), this->start));
+                return Iterator(
+                        std::next(std::begin(this->container), this->start),
+                        this->step);
             }
 
             Iterator end() const {
-                return Iterator(std::next(
-                            std::begin(this->container), this->stop));
+                return Iterator(
+                        std::next(std::begin(this->container), this->stop),
+                        this->step);
             }
 
     };

From 75cdb3ca251693c1c3e9b5f92a1f2ffa5640e188 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 14 Nov 2013 00:32:48 -0500
Subject: [PATCH 0168/1866] Adds description messages

---
 tests/testslice.cpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/tests/testslice.cpp b/tests/testslice.cpp
index 84159637..178bbac7 100644
--- a/tests/testslice.cpp
+++ b/tests/testslice.cpp
@@ -24,11 +24,13 @@ int main() {
     for (auto i : iter::slice(a,0,15,3)) {
         std::cout << i << std::endl;
     }
-    std::cout<<std::endl;
+
+    std::cout<< "\n13 down to 0\n";
     for (auto i : iter::slice(a,13,-1,-1)) {
         std::cout << i << std::endl;
     }
-    std::cout<<std::endl;
+
+    std::cout<< "\nInvalid range [1:10:-1]\n";
     for (auto i : iter::slice(a,1,10,-1)) {
         //invalid range returns two begin iters
         std::cout << i << std::endl;

From bc53b305906efc6e3110f5058f3ba8789dfed8c8 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 14 Nov 2013 00:46:27 -0500
Subject: [PATCH 0169/1866] Removes -Weffc++ from compilation flags

---
 tests/SConstruct | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/SConstruct b/tests/SConstruct
index 8c300998..ceb1f196 100644
--- a/tests/SConstruct
+++ b/tests/SConstruct
@@ -2,8 +2,8 @@ import platform
 import os
 
 env = Environment(
-    CXX='c++',
-    CXXFLAGS= ['-g',  '-Wall', '-Wextra',  '-Weffc++',
+    CXX='clang++',
+    CXXFLAGS= ['-g',  '-Wall', '-Wextra',
                '-pedantic', '-std=c++11',
                '-I/usr/local/include'],
     CPPPATH='..',

From b18ff9164339441196dff649c8b1e375491d8e34 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 14 Nov 2013 00:48:38 -0500
Subject: [PATCH 0170/1866] Fixes a bunch of comments

---
 slice.hpp | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/slice.hpp b/slice.hpp
index af93db28..f8995214 100644
--- a/slice.hpp
+++ b/slice.hpp
@@ -44,22 +44,19 @@ namespace iter {
                 stop(stop),
                 step(step)
             { 
+                // sets stop = start if the range is empty
                 if ((start < stop && step <=0) ||
                         (start > stop && step >=0)){
                     this->stop = start;
                 } 
             }
 
-            // Value constructor for use only in the slice function
             Slice () = delete;
             Slice & operator=(const Slice &) = delete;
 
             Slice(const Slice &) = default;
 
 
-            //  Holds an iterator of the contained type and a size_t for the
-            //  index.  Each call to ++ increments both of these data members.
-            //  Each dereference returns an IterYield.
             class Iterator {
                 private:
                     contained_iter_type sub_iter;
@@ -97,7 +94,8 @@ namespace iter {
             }
 
     };
-    // Helper function to instantiate an Slice
+
+    // Helper function to instantiate a Slice
     template <typename Container, typename DifferenceType>
     Slice<Container, DifferenceType> slice(
             Container && container, DifferenceType start,

From 0630c71fae866f27e705390e97b79f9ec9eea615 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 14 Nov 2013 01:11:28 -0500
Subject: [PATCH 0171/1866] adds test with imperfect step size

---
 tests/testslice.cpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/tests/testslice.cpp b/tests/testslice.cpp
index 178bbac7..690a1cd9 100644
--- a/tests/testslice.cpp
+++ b/tests/testslice.cpp
@@ -30,6 +30,11 @@ int main() {
         std::cout << i << std::endl;
     }
 
+    std::cout<< "\nunevent step [0:5:3]\n";
+    for (auto i : iter::slice(a, 0, 5, 3)) {
+        std::cout << i << '\n';
+    }
+
     std::cout<< "\nInvalid range [1:10:-1]\n";
     for (auto i : iter::slice(a,1,10,-1)) {
         //invalid range returns two begin iters

From ac6a076158a4012b2ea0bd204a14a6db813fa603 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 14 Nov 2013 01:11:50 -0500
Subject: [PATCH 0172/1866] Handles case of uneven step size

with a slice like [0:5:3] the position isn't exactly equal to the end,
so the Slice::Iterator::operator!= has to handle that case
---
 slice.hpp | 20 ++++++++++++++------
 1 file changed, 14 insertions(+), 6 deletions(-)

diff --git a/slice.hpp b/slice.hpp
index f8995214..1e44e4e7 100644
--- a/slice.hpp
+++ b/slice.hpp
@@ -60,10 +60,16 @@ namespace iter {
             class Iterator {
                 private:
                     contained_iter_type sub_iter;
-                    DifferenceType step;
+                    DifferenceType current;
+                    const DifferenceType stop;
+                    const DifferenceType step;
+
                 public:
-                    Iterator (contained_iter_type si, DifferenceType step) :
+                    Iterator (contained_iter_type si, DifferenceType start,
+                            DifferenceType stop, DifferenceType step) :
                         sub_iter(si),
+                        current(start),
+                        stop(stop),
                         step(step)
                     { }
 
@@ -73,24 +79,26 @@ namespace iter {
 
                     Iterator & operator++() { 
                         std::advance(this->sub_iter, this->step);
+                        this->current += this->step;
                         return *this;
                     }
 
-                    bool operator!=(const Iterator & other) const {
-                        return this->sub_iter != other.sub_iter;
+                    bool operator!=(const Iterator &) const {
+                        return (this->step > 0 && this->current < this->stop)||
+                            (this->step < 0 && this->current > this->stop);
                     }
             };
 
             Iterator begin() const {
                 return Iterator(
                         std::next(std::begin(this->container), this->start),
-                        this->step);
+                        this->start, this->stop, this->step);
             }
 
             Iterator end() const {
                 return Iterator(
                         std::next(std::begin(this->container), this->stop),
-                        this->step);
+                        this->stop, this->stop, this->step);
             }
 
     };

From 0ed6f67121417474d463d3fa1acbd586dd025c01 Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Thu, 14 Nov 2013 02:05:07 -0500
Subject: [PATCH 0173/1866] Fixed slice but not the pythonic way

---
 slice.hpp           |  6 ++++++
 tests/testslice.cpp | 11 +++++++++++
 2 files changed, 17 insertions(+)

diff --git a/slice.hpp b/slice.hpp
index 1e44e4e7..60877039 100644
--- a/slice.hpp
+++ b/slice.hpp
@@ -49,6 +49,12 @@ namespace iter {
                         (start > stop && step >=0)){
                     this->stop = start;
                 } 
+                if (this->stop > static_cast<DifferenceType>(container.size())) {
+                    this->stop = static_cast<DifferenceType>(container.size());
+                }
+                if (this->start < static_cast<DifferenceType>(container.size())) {
+                    this->start = 0; 
+                }
             }
 
             Slice () = delete;
diff --git a/tests/testslice.cpp b/tests/testslice.cpp
index 98f3806f..6db6da85 100644
--- a/tests/testslice.cpp
+++ b/tests/testslice.cpp
@@ -47,4 +47,15 @@ int main() {
         //invalid range returns two begin iters
         std::cout << i << std::endl;
     }
+    std::cout<< "\nOversize range [1:100:1]\n";
+    for (auto i : iter::slice(a,1,100,1)) {
+        //invalid range returns two begin iters
+        std::cout << i << std::endl;
+    }
+    std::cout<< "\nOversize range and undersize[1:100:1]\n";
+    for (auto i : iter::slice(a,-100,100,1)) {
+        //invalid range returns two begin iters
+        std::cout << i << std::endl;
+    }
+
 }

From 1b35cef27f6c31651f09b325660e5580d16a437f Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Thu, 14 Nov 2013 02:07:40 -0500
Subject: [PATCH 0174/1866] small error

---
 slice.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/slice.hpp b/slice.hpp
index 60877039..7e9759c6 100644
--- a/slice.hpp
+++ b/slice.hpp
@@ -52,7 +52,7 @@ namespace iter {
                 if (this->stop > static_cast<DifferenceType>(container.size())) {
                     this->stop = static_cast<DifferenceType>(container.size());
                 }
-                if (this->start < static_cast<DifferenceType>(container.size())) {
+                if (this->start < 0) {
                     this->start = 0; 
                 }
             }

From 092f51c6aa5bd743248e25b84675f95d328aea55 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 14 Nov 2013 13:57:54 -0500
Subject: [PATCH 0175/1866] Handle skipping whole or part of group

Each group has a "completed" mutable bool that determines whether it has
been exhausted or not.  The Group destructor checks the flag and if it
is false, it exhausts the group.
---
 groupby.hpp | 45 ++++++++++++++++++++++++++++++++++++---------
 1 file changed, 36 insertions(+), 9 deletions(-)

diff --git a/groupby.hpp b/groupby.hpp
index 15d98eaf..0a3a67d2 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -6,7 +6,6 @@
 #include <utility>
 #include <iterator>
 
-
 namespace iter {
 
     template <typename Container, typename KeyFunc>
@@ -103,35 +102,63 @@ namespace iter {
             class Group {
                 private:
                     friend Iterator;
+                    friend class GroupIterator;
                     Iterator *owner;
                     key_func_ret key;
+                    mutable bool completed = false;
 
                     Group(Iterator *owner, key_func_ret key) :
                         owner(owner),
                         key(key)
                     { }
 
+                public:
+                    ~Group() {
+                        if (!this->completed) {
+                            for (auto iter = this->begin(), end = this->end();
+                                    iter != end;
+                                    ++iter) { }
+                        }
+                    }
+                           
+
 
                     Group () = delete;
-                public:
-                    Group (const Group &) = default;
+                    Group (const Group &other) :
+                            owner(other.owner),
+                            key(other.key),
+                            completed(other.completed) {
+                        other.completed = true;
+                    }
 
                     class GroupIterator {
                         private:
                             Iterator * owner;
                             const key_func_ret key;
+                            const Group * group;
+
+                            bool not_at_end() const {
+                                return !this->owner->exhausted() &&
+                                    this->owner->next_key() == this->key;
+                            }
 
                         public:
-                            GroupIterator(Iterator * owner, key_func_ret key) :
+                            GroupIterator(Iterator * owner, const Group *group,
+                                          key_func_ret key) :
                                 owner(owner),
-                                key(key)
+                                key(key),
+                                group(group)
                             { }
 
                             GroupIterator(const GroupIterator &) = default;
 
                             bool operator!=(const GroupIterator &) const {
-                                return !this->owner->exhausted() &&
-                                    this->owner->next_key() == this->key;
+                                if (this->not_at_end()) {
+                                    return true;
+                                } else {
+                                    this->group->completed = true;
+                                    return false;
+                                }
                             }
 
                             GroupIterator & operator++() {
@@ -145,11 +172,11 @@ namespace iter {
                     };
 
                     GroupIterator begin() const {
-                        return GroupIterator(this->owner, key);
+                        return GroupIterator(this->owner, this, key);
                     }
 
                     GroupIterator end() const {
-                        return GroupIterator(this->owner, key);
+                        return GroupIterator(this->owner, this, key);
                     }
 
             };

From 05651e792e327b5d6f52a096a61fa023e536e6c2 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 14 Nov 2013 14:00:16 -0500
Subject: [PATCH 0176/1866] Adds test for skipping whole group

---
 tests/testgroupby.cpp | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/tests/testgroupby.cpp b/tests/testgroupby.cpp
index d499e8e8..8897d379 100644
--- a/tests/testgroupby.cpp
+++ b/tests/testgroupby.cpp
@@ -29,6 +29,20 @@ int main()
         std::cout << '\n';
     }
 
+    std::cout << "skipping length of 3\n";
+    for (auto gb : groupby(vec, &length)) {
+        if (gb.first == 3) {
+            continue;
+        }
+        std::cout << "key: " << gb.first << '\n';
+        std::cout << "content: ";
+        for (auto s : gb.second) {
+            std::cout << s << "  ";
+        }
+        std::cout << '\n';
+    }
+   
+
     std::vector<int> ivec = {5, 5, 6, 6, 19, 19, 19, 19, 69, 0, 10, 10};
     for (auto gb : groupby(ivec)) {
         std::cout << "key: " << gb.first << '\n';

From 9bac68db3dc02e6ede66701dc11cab82508c6f40 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 14 Nov 2013 15:05:46 -0500
Subject: [PATCH 0177/1866] Replaces pointers with references in groupby

---
 groupby.hpp | 27 ++++++++++++++-------------
 1 file changed, 14 insertions(+), 13 deletions(-)

diff --git a/groupby.hpp b/groupby.hpp
index 0a3a67d2..52b44128 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -67,7 +67,7 @@ namespace iter {
                         return KeyGroupPair(
                                 this->key_func(*this->sub_iter),
                                 Group(
-                                    this, 
+                                    *this, 
                                     this->key_func(*this->sub_iter)));
                     }
 
@@ -103,11 +103,11 @@ namespace iter {
                 private:
                     friend Iterator;
                     friend class GroupIterator;
-                    Iterator *owner;
+                    Iterator & owner;
                     key_func_ret key;
                     mutable bool completed = false;
 
-                    Group(Iterator *owner, key_func_ret key) :
+                    Group(Iterator & owner, key_func_ret key) :
                         owner(owner),
                         key(key)
                     { }
@@ -133,17 +133,18 @@ namespace iter {
 
                     class GroupIterator {
                         private:
-                            Iterator * owner;
+                            Iterator & owner;
                             const key_func_ret key;
-                            const Group * group;
+                            const Group & group;
 
                             bool not_at_end() const {
-                                return !this->owner->exhausted() &&
-                                    this->owner->next_key() == this->key;
+                                return !this->owner.exhausted() &&
+                                    this->owner.next_key() == this->key;
                             }
 
                         public:
-                            GroupIterator(Iterator * owner, const Group *group,
+                            GroupIterator(Iterator & owner,
+                                          const Group & group,
                                           key_func_ret key) :
                                 owner(owner),
                                 key(key),
@@ -156,27 +157,27 @@ namespace iter {
                                 if (this->not_at_end()) {
                                     return true;
                                 } else {
-                                    this->group->completed = true;
+                                    this->group.completed = true;
                                     return false;
                                 }
                             }
 
                             GroupIterator & operator++() {
-                                this->owner->increment_iterator();
+                                this->owner.increment_iterator();
                                 return *this;
                             }
 
                             contained_iter_ret operator*() const {
-                                return this->owner->current();
+                                return this->owner.current();
                             }
                     };
 
                     GroupIterator begin() const {
-                        return GroupIterator(this->owner, this, key);
+                        return GroupIterator(this->owner, *this, key);
                     }
 
                     GroupIterator end() const {
-                        return GroupIterator(this->owner, this, key);
+                        return GroupIterator(this->owner, *this, key);
                     }
 
             };

From 4493e043ffea352ca13088e9841d61c82e80eaad Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 14 Nov 2013 15:20:53 -0500
Subject: [PATCH 0178/1866] Removes unnecessary Iterator& in GroupIterator

---
 groupby.hpp | 17 +++++++----------
 1 file changed, 7 insertions(+), 10 deletions(-)

diff --git a/groupby.hpp b/groupby.hpp
index 52b44128..5d1b34ee 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -133,20 +133,17 @@ namespace iter {
 
                     class GroupIterator {
                         private:
-                            Iterator & owner;
                             const key_func_ret key;
                             const Group & group;
 
                             bool not_at_end() const {
-                                return !this->owner.exhausted() &&
-                                    this->owner.next_key() == this->key;
+                                return !this->group.owner.exhausted() &&
+                                    this->group.owner.next_key() == this->key;
                             }
 
                         public:
-                            GroupIterator(Iterator & owner,
-                                          const Group & group,
+                            GroupIterator(const Group & group,
                                           key_func_ret key) :
-                                owner(owner),
                                 key(key),
                                 group(group)
                             { }
@@ -163,21 +160,21 @@ namespace iter {
                             }
 
                             GroupIterator & operator++() {
-                                this->owner.increment_iterator();
+                                this->group.owner.increment_iterator();
                                 return *this;
                             }
 
                             contained_iter_ret operator*() const {
-                                return this->owner.current();
+                                return this->group.owner.current();
                             }
                     };
 
                     GroupIterator begin() const {
-                        return GroupIterator(this->owner, *this, key);
+                        return GroupIterator(*this, key);
                     }
 
                     GroupIterator end() const {
-                        return GroupIterator(this->owner, *this, key);
+                        return GroupIterator(*this, key);
                     }
 
             };

From ea31fbf5dcf4c3476961e814faff056f678e5dd7 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 14 Nov 2013 15:29:47 -0500
Subject: [PATCH 0179/1866] Make Group movable, not copyable

---
 groupby.hpp | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/groupby.hpp b/groupby.hpp
index 5d1b34ee..38f5e6ac 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -123,8 +123,13 @@ namespace iter {
                            
 
 
+                    // can be move constructed, but not copied or move assigned
                     Group () = delete;
-                    Group (const Group &other) :
+                    Group (const Group &) = delete;
+                    Group & operator=(const Group &) = delete;
+                    Group & operator=(Group &&) = delete;
+
+                    Group (Group && other) :
                             owner(other.owner),
                             key(other.key),
                             completed(other.completed) {

From 9df4a8198636755dfe822d2c9abfbd8b9ae7fd7f Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 14 Nov 2013 15:41:05 -0500
Subject: [PATCH 0180/1866] adds comments explaining 'completed'

---
 groupby.hpp | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/groupby.hpp b/groupby.hpp
index 38f5e6ac..c02e7a5f 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -105,6 +105,16 @@ namespace iter {
                     friend class GroupIterator;
                     Iterator & owner;
                     key_func_ret key;
+
+                    // completed is set if a Group is iterated through
+                    // completely.  It is checked in the destructor, and
+                    // if the Group has not been completed, the destructor
+                    // exhausts it.  This ensures that the next Group starts
+                    // at the correct position when the user short-circuits
+                    // iteration over a Group.
+                    // The move constructor sets the rvalue's completed
+                    // attribute to true, so its destructor doesn't do anything
+                    // when called.
                     mutable bool completed = false;
 
                     Group(Iterator & owner, key_func_ret key) :

From 8979c6e959f7c0fa06fd199ebcfc67fc93ddd5f4 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 14 Nov 2013 21:48:44 -0500
Subject: [PATCH 0181/1866] Removes commented out bits from SConstruct

---
 tests/SConstruct | 11 +----------
 1 file changed, 1 insertion(+), 10 deletions(-)

diff --git a/tests/SConstruct b/tests/SConstruct
index ceb1f196..a28500f5 100644
--- a/tests/SConstruct
+++ b/tests/SConstruct
@@ -2,7 +2,7 @@ import platform
 import os
 
 env = Environment(
-    CXX='clang++',
+    CXX='c++',
     CXXFLAGS= ['-g',  '-Wall', '-Wextra',
                '-pedantic', '-std=c++11',
                '-I/usr/local/include'],
@@ -12,15 +12,6 @@ env = Environment(
 # allows highighting to print to terminal from compiler output
 env['ENV']['TERM'] = os.environ['TERM']
 
-# if on MAC, needs the linker flag for -stdlib=libc++
-# obselete with mavericks
-""" if platform.system() == 'Darwin':
-    env['CXX'] += '-stdlib=libc++'
-    env['CXXFLAGS'].append('-stdlib=libc++')
-"""
-
-
-
 progs = Split( '''
 		cycle 
 		enumerate 

From 5cbc4a63cbc419463109f3736dcdfc2c8ffc8f42 Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Thu, 14 Nov 2013 22:15:07 -0500
Subject: [PATCH 0182/1866] super special size()

---
 slice.hpp           | 13 +++++++++++--
 tests/testslice.cpp |  7 ++++++-
 2 files changed, 17 insertions(+), 3 deletions(-)

diff --git a/slice.hpp b/slice.hpp
index 7e9759c6..a5b537bc 100644
--- a/slice.hpp
+++ b/slice.hpp
@@ -17,6 +17,15 @@ namespace iter {
     //template <typename Container, typename DifferenceType>
     //Slice<Container> slice(Container &&);
 
+    template <typename Container>
+    size_t size(Container & container) {
+        return container.size();
+    }
+    template <typename T, size_t N>
+    size_t size(T (&)[N]) {
+        return N;
+    }
+
     template <typename Container, typename DifferenceType>
     class Slice : public IterBase<Container>{
         private:
@@ -49,8 +58,8 @@ namespace iter {
                         (start > stop && step >=0)){
                     this->stop = start;
                 } 
-                if (this->stop > static_cast<DifferenceType>(container.size())) {
-                    this->stop = static_cast<DifferenceType>(container.size());
+                if (this->stop > static_cast<DifferenceType>(size(container))) {
+                    this->stop = static_cast<DifferenceType>(size(container));
                 }
                 if (this->start < 0) {
                     this->start = 0; 
diff --git a/tests/testslice.cpp b/tests/testslice.cpp
index 6db6da85..80b7f15b 100644
--- a/tests/testslice.cpp
+++ b/tests/testslice.cpp
@@ -57,5 +57,10 @@ int main() {
         //invalid range returns two begin iters
         std::cout << i << std::endl;
     }
-
+    std::cout<< "\nstatic array[1:8:2]\n";
+    int arr[10] = {0,1,2,3,4,5,6,7,8,9};
+    for (auto i : iter::slice(arr,1,8,2)) {
+        //invalid range returns two begin iters
+        std::cout << i << std::endl;
+    }
 }

From 58d5432c2ec94c150474b9b07b3a7801098fc9aa Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Thu, 14 Nov 2013 22:28:05 -0500
Subject: [PATCH 0183/1866] awesome slice SFINAE

---
 slice.hpp | 21 ++++++++++++++++++++-
 1 file changed, 20 insertions(+), 1 deletion(-)

diff --git a/slice.hpp b/slice.hpp
index a5b537bc..a6a0f59f 100644
--- a/slice.hpp
+++ b/slice.hpp
@@ -4,6 +4,7 @@
 #include <iterbase.hpp>
 
 #include <iterator>
+#include <type_traits>
 
 namespace iter {
 
@@ -16,11 +17,29 @@ namespace iter {
 
     //template <typename Container, typename DifferenceType>
     //Slice<Container> slice(Container &&);
+    template <typename T>
+    class has_size
+    {
+        typedef char one;
+        typedef long two;
 
+        template <typename C> static one test( decltype(&C::size) ) ;
+        template <typename C> static two test(...);
+
+
+        public:
+        enum { value = sizeof(test<T>(0)) == sizeof(char) };
+    };
     template <typename Container>
-    size_t size(Container & container) {
+    typename std::enable_if<has_size<Container>::value,size_t>::type 
+    size(Container & container) {
         return container.size();
     }
+    template <typename Container>
+    typename std::enable_if<!has_size<Container>::value,size_t>::type 
+    size(Container & container) {
+        return std::distance(container.end(),container.begin());
+    }
     template <typename T, size_t N>
     size_t size(T (&)[N]) {
         return N;

From 3e3385256674290782ad8cdb849c748d49818891 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 14 Nov 2013 23:45:18 -0500
Subject: [PATCH 0184/1866] Support for initializer_list, uses stdbegin/end

---
 slice.hpp | 21 ++++++++++++++++++++-
 1 file changed, 20 insertions(+), 1 deletion(-)

diff --git a/slice.hpp b/slice.hpp
index a6a0f59f..24b69e7c 100644
--- a/slice.hpp
+++ b/slice.hpp
@@ -6,6 +6,7 @@
 #include <iterator>
 #include <type_traits>
 
+
 namespace iter {
 
     //Forward declarations of Slice and slice
@@ -35,16 +36,20 @@ namespace iter {
     size(Container & container) {
         return container.size();
     }
+
     template <typename Container>
     typename std::enable_if<!has_size<Container>::value,size_t>::type 
     size(Container & container) {
-        return std::distance(container.end(),container.begin());
+        return std::distance(std::begin(container), std::end(container));
     }
+
     template <typename T, size_t N>
     size_t size(T (&)[N]) {
         return N;
     }
 
+
+
     template <typename Container, typename DifferenceType>
     class Slice : public IterBase<Container>{
         private:
@@ -153,6 +158,20 @@ namespace iter {
         return Slice<Container, DifferenceType>(
                 std::forward<Container>(container), 0, stop, 1);
     }
+
+    template <typename T, typename DifferenceType>
+    Slice<std::initializer_list<T>, DifferenceType> slice(
+            std::initializer_list<T> && il, DifferenceType start,
+            DifferenceType stop, DifferenceType step=1) {
+        return Slice<std::initializer_list<T>, DifferenceType>(
+                il, start, stop, step);
+    }
+
+    template <typename T, typename DifferenceType>
+    Slice<std::initializer_list<T>, DifferenceType> slice(
+            std::initializer_list<T> && il, DifferenceType stop) {
+        return Slice<std::initializer_list<T>, DifferenceType>(il, 0, stop, 1);
+    }
 }
 
 #endif //SLICE_HPP

From 71ab631a3f883356615d7ce2eec6ae85e92fb5ac Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 14 Nov 2013 23:46:40 -0500
Subject: [PATCH 0185/1866] Adds initializer_list test for slice

---
 tests/testslice.cpp | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/tests/testslice.cpp b/tests/testslice.cpp
index 80b7f15b..cc19f455 100644
--- a/tests/testslice.cpp
+++ b/tests/testslice.cpp
@@ -1,4 +1,5 @@
 #include <slice.hpp>
+#include <range.hpp>
 
 #include <iostream>
 #include <vector>
@@ -57,10 +58,17 @@ int main() {
         //invalid range returns two begin iters
         std::cout << i << std::endl;
     }
+
     std::cout<< "\nstatic array[1:8:2]\n";
     int arr[10] = {0,1,2,3,4,5,6,7,8,9};
     for (auto i : iter::slice(arr,1,8,2)) {
         //invalid range returns two begin iters
         std::cout << i << std::endl;
     }
+
+    std::cout << "\ninitializer list\n";
+    for (auto i : iter::slice({1, 2, 4, 8, 16, 32, 64, 128}, 2, 6)) {
+        std::cout << i << '\n';
+    }
+
 }

From 0f1bee3e970983d35d5a68bf12b3acbc1070d7b8 Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Wed, 20 Nov 2013 15:05:39 -0500
Subject: [PATCH 0186/1866] Updated product to use std::begin, since container
 is const uses const overload

---
 product.hpp | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/product.hpp b/product.hpp
index 6b47cfd2..42465b04 100644
--- a/product.hpp
+++ b/product.hpp
@@ -15,19 +15,20 @@ namespace iter {
             auto end = product_iter<Containers...>(containers...);
             return iterator_range<decltype(begin)>(begin,end);
         }
+    //template <typenam
     template <typename Container>
         struct product_iter<Container> {
             public:
-                using Iterator = decltype(std::declval<Container>().cbegin());
+                using Iterator = decltype(std::begin(std::declval<Container>()));
             private:
                 Iterator begin;
                 Iterator mover;
                 const Iterator end;
             public:
                 product_iter(const Container & c) :
-                    begin(c.cbegin()),
-                    mover(c.cbegin()),
-                    end(c.cend()){}
+                    begin(std::begin(c)),
+                    mover(std::begin(c)),
+                    end(std::end(c)){}
                 decltype(std::make_tuple(*mover)) operator*()
                 //since you can't modify anything anyway it's ok to return a
                 //tuple of whatever the iterator derefs to
@@ -60,7 +61,7 @@ namespace iter {
         struct product_iter<Container,Containers...>
         {
             public:
-                using Iterator = decltype(std::declval<Container>().cbegin());
+                using Iterator = decltype(std::begin(std::declval<Container>()));
             private:
                 Iterator begin;
                 Iterator mover;
@@ -73,9 +74,9 @@ namespace iter {
                     return begin != end && inner_iter.is_not_empty_range();
                 }
                 product_iter(const Container & c, const Containers & ... containers):
-                    begin(c.cbegin()),
-                    mover(c.cbegin()),
-                    end(c.cend()),
+                    begin(std::begin(c)),
+                    mover(std::begin(c)),
+                    end(std::end(c)),
                     inner_iter(containers...){
                         no_empty_ranges = is_not_empty_range();
                     }

From 62f2fb03514fbe7d87f2da0e8ae4457c81cf531e Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 21 Nov 2013 13:22:33 -0500
Subject: [PATCH 0187/1866] Adds test with range temporary

for (auto i : enumerate(range(...))), something I've been meaning to do
for a while.
---
 tests/testenumerate.cpp | 16 ++++++++++++++--
 1 file changed, 14 insertions(+), 2 deletions(-)

diff --git a/tests/testenumerate.cpp b/tests/testenumerate.cpp
index a6b3adf9..498139e3 100644
--- a/tests/testenumerate.cpp
+++ b/tests/testenumerate.cpp
@@ -1,24 +1,28 @@
 #include <enumerate.hpp>
+#include <range.hpp>
 
 #include <string>
 #include <iostream>
 #include <vector>
 
 using iter::enumerate;
+using iter::range;
 
 int main() {
-    std::string s = "hello world";
-
+    std::cout << "const std::string\n";
     const std::string const_string("goodbye world");
     for (auto e : enumerate(const_string)) {
         std::cout << e.index << ": " << e.element << std::endl;
     }
 
+
     std::vector<int> vec;
     for(int i = 0; i < 12; ++i) { 
         vec.push_back(i * i);
     }
 
+
+    std::cout << "print vector element, set it to zero, then print it again\n";
     for (auto e : enumerate(vec)) { 
         std::cout << e.index << ": " << e.element << std::endl;
         e.element = 0;
@@ -26,15 +30,23 @@ int main() {
         std::cout << e.index << ": " << e.element << std::endl;
     }
 
+    std::cout << "static array\n";
     int array[] = {1, 9, 8, 11};
     for (auto e : enumerate(array)) {
         std::cout << e.index << ": " << e.element << '\n';
     }
 
 
+    std::cout << "initializer list\n";
     for (auto e : enumerate({0, 1, 4, 9, 16, 25})) {
         std::cout << e.index << "^2 = " << e.element << '\n';
     }
 
+
+    std::cout << "range(10, 20, 2)\n";
+    for (auto e : enumerate(range(10, 20, 2))) {
+        std::cout << e.index << ": " << e.element << '\n';
+    }
+
     return 0;
 }

From c37c84a84a97c519943f503052df86674e88cfaf Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 21 Nov 2013 13:24:55 -0500
Subject: [PATCH 0188/1866] Adds support for temporaries

---
 enumerate.hpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index ef367d52..8f900b1a 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -33,7 +33,7 @@ namespace iter {
 
     template <typename Container>
     class Enumerable : public IterBase<Container>{
-        private:
+        public:
             Container & container;
 
             // The only thing allowed to directly instantiate an Enumerable is
@@ -46,7 +46,7 @@ namespace iter {
 
             using typename IterBase<Container>::contained_iter_ret;
 
-            Enumerable(Container & container) : container(container) { }
+            Enumerable(Container && container) : container(container) { }
             
         public:
             // Value constructor for use only in the enumerate function
@@ -113,7 +113,8 @@ namespace iter {
     template <typename T>
     Enumerable<std::initializer_list<T>> enumerate(std::initializer_list<T> && il)
     {
-        return Enumerable<std::initializer_list<T>>(il);
+        return Enumerable<std::initializer_list<T>>(
+                std::forward<std::initializer_list<T>>(il));
     }
 
 }

From 3c0cc9a6f96f84963dd0b112ee36e18309a1102e Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 21 Nov 2013 13:31:29 -0500
Subject: [PATCH 0189/1866] Restores privacy to enumerate

---
 enumerate.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index 8f900b1a..31fd282a 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -33,7 +33,7 @@ namespace iter {
 
     template <typename Container>
     class Enumerable : public IterBase<Container>{
-        public:
+        private:
             Container & container;
 
             // The only thing allowed to directly instantiate an Enumerable is

From 3c138e9f2fc9ac3484d9e8f6f24856b7544035d4 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 21 Nov 2013 13:38:48 -0500
Subject: [PATCH 0190/1866] Adds initializer_list test

---
 tests/testcycle.cpp | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/tests/testcycle.cpp b/tests/testcycle.cpp
index bd4e2d0b..72c88dd8 100644
--- a/tests/testcycle.cpp
+++ b/tests/testcycle.cpp
@@ -21,11 +21,21 @@ int main() {
     int array[] = {68, 69, 70};
     for (auto i : cycle(array)) {
         std::cout << i << '\n';
-        if (count == 100) {
+        if (count == 20) {
             break;
         }
         ++count;
     }
 
+    count = 0;
+    for (auto i : cycle({7, 8, 9})) {
+        std::cout << i << '\n';
+        if (count == 20) {
+            break;
+        }
+        ++count;
+    }
+
+
     return 0;
 }

From 5772be8f62753529e6b24f291bfc77951163e521 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 21 Nov 2013 13:39:44 -0500
Subject: [PATCH 0191/1866] Adds support for initializer_list

---
 cycle.hpp | 24 ++++++++++++++++++------
 1 file changed, 18 insertions(+), 6 deletions(-)

diff --git a/cycle.hpp b/cycle.hpp
index a6aaa029..1890f229 100644
--- a/cycle.hpp
+++ b/cycle.hpp
@@ -13,14 +13,20 @@ namespace iter {
     class Cycle;
 
     template <typename Container>
-    Cycle<Container> cycle(Container &);
+    Cycle<Container> cycle(Container &&);
 
+    template <typename T>
+    Cycle<std::initializer_list<T>> cycle(
+            std::initializer_list<T> &&);
 
     template <typename Container>
     class Cycle : public IterBase<Container>{
-        private:
+        public:
             // The cycle function is the only thing allowed to create a Cycle
-            friend Cycle cycle<Container>(Container &);
+            friend Cycle cycle<Container>(Container &&);
+            template <typename T>
+            friend Cycle<std::initializer_list<T>> cycle(
+                    std::initializer_list<T> &&);
 
             using typename IterBase<Container>::contained_iter_type;
 
@@ -29,7 +35,7 @@ namespace iter {
             Container & container;
             
             // Value constructor for use only in the cycle function
-            Cycle(Container & container) : container(container) { }
+            Cycle(Container && container) : container(container) { }
             Cycle () = delete;
             Cycle & operator=(const Cycle &) = delete;
 
@@ -80,10 +86,16 @@ namespace iter {
 
     // Helper function to instantiate an Filter
     template <typename Container>
-    Cycle<Container> cycle(Container & container) {
-        return Cycle<Container>(container);
+    Cycle<Container> cycle(Container && container) {
+        return Cycle<Container>(std::forward<Container>(container));
     }
 
+    template <typename T>
+    Cycle<std::initializer_list<T>> cycle(std::initializer_list<T> && il)
+    {
+        return Cycle<std::initializer_list<T>>(
+                std::forward<std::initializer_list<T>>(il));
+    }
 }
 
 #endif //ifndef CYCLE__H__

From cde655ae3d2f85b01eeba3933234cf7848874c63 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 21 Nov 2013 13:55:24 -0500
Subject: [PATCH 0192/1866] formatting

---
 enumerate.hpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index 31fd282a..1abcb748 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -40,7 +40,8 @@ namespace iter {
             // the enumerate function
             friend Enumerable enumerate<Container>(Container &&);
             template <typename T>
-            friend Enumerable<std::initializer_list<T>> enumerate(std::initializer_list<T> &&);
+            friend Enumerable<std::initializer_list<T>> enumerate(
+                    std::initializer_list<T> &&);
 
             using typename IterBase<Container>::contained_iter_type;
 

From 77469bf1574c2894f021e77ffa138cebd9eeab6e Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 21 Nov 2013 15:05:44 -0500
Subject: [PATCH 0193/1866] Adds Range::Iterator::operator= to copy value

---
 range.hpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/range.hpp b/range.hpp
index edd48505..07aa655f 100644
--- a/range.hpp
+++ b/range.hpp
@@ -85,6 +85,11 @@ namespace iter {
                         step(step)
                     { }
 
+                    Iterator & operator=(const Iterator &other) {
+                        this->value = other.value;
+                        return *this;
+                    }
+
                     T operator*() const {
                         return this->value;
                     }

From ba0031d663fb7bc16de314afbbc9d4cc3fe3b3d0 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 21 Nov 2013 15:07:34 -0500
Subject: [PATCH 0194/1866] Adds test with temporary

---
 tests/testcycle.cpp | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/tests/testcycle.cpp b/tests/testcycle.cpp
index 72c88dd8..98987a77 100644
--- a/tests/testcycle.cpp
+++ b/tests/testcycle.cpp
@@ -1,9 +1,11 @@
 #include <cycle.hpp>
+#include <range.hpp>
 
 #include <vector>
 #include <iostream>
 
 using iter::cycle;
+using iter::range;
 
 int main() {
     std::vector<int> vec = {2, 4, 6};
@@ -36,6 +38,15 @@ int main() {
         ++count;
     }
 
+    count = 0;
+    for (auto i : cycle(range(3))) {
+        std::cout << i << '\n';
+        if (count == 20) {
+            break;
+        }
+        ++count;
+    }
+
 
     return 0;
 }

From a180961bae3d2ec5e7faa8e0393331c9f518d8fa Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 21 Nov 2013 15:08:42 -0500
Subject: [PATCH 0195/1866] Adds support for temporaries

---
 cycle.hpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/cycle.hpp b/cycle.hpp
index 1890f229..8d4a5e95 100644
--- a/cycle.hpp
+++ b/cycle.hpp
@@ -5,6 +5,7 @@
 
 #include <utility>
 #include <iterator>
+#include <initializer_list>
 
 namespace iter {
 
@@ -21,7 +22,7 @@ namespace iter {
 
     template <typename Container>
     class Cycle : public IterBase<Container>{
-        public:
+        private:
             // The cycle function is the only thing allowed to create a Cycle
             friend Cycle cycle<Container>(Container &&);
             template <typename T>
@@ -61,7 +62,7 @@ namespace iter {
                     Iterator & operator++() { 
                         ++this->sub_iter;
                         // reset to beginning upon reaching the end
-                        if (this->sub_iter == this->end) {
+                        if (!(this->sub_iter != this->end)) {
                             this->sub_iter = this->begin;
                         }
                         return *this;

From f971d5029f9f033d6b820d2c585364b7f46196f6 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 21 Nov 2013 15:12:51 -0500
Subject: [PATCH 0196/1866] Adds test with const string

---
 tests/testcycle.cpp | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/tests/testcycle.cpp b/tests/testcycle.cpp
index 98987a77..d7c0f91b 100644
--- a/tests/testcycle.cpp
+++ b/tests/testcycle.cpp
@@ -47,6 +47,15 @@ int main() {
         ++count;
     }
 
+    count = 0;
+    const std::string s("hello");
+    for (auto c : cycle(s)) {
+        std::cout << c << '\n';
+        if (count == 20) {
+            break;
+        }
+        ++count;
+    }
 
     return 0;
 }

From 3bd45410db736ba0916485ae3f9ef7ebc7b88a42 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 21 Nov 2013 17:37:00 -0500
Subject: [PATCH 0197/1866] Adds test with initializer_list

---
 tests/testfilter.cpp | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/tests/testfilter.cpp b/tests/testfilter.cpp
index 63718646..a82b524f 100644
--- a/tests/testfilter.cpp
+++ b/tests/testfilter.cpp
@@ -49,5 +49,12 @@ int main() {
     }
 
 
+    std::cout << "ever numbers in initializer_list\n";
+    for (auto i : filter([] (const int i) {return i % 2 == 0;},
+                         {1, 2, 3, 4, 5, 6, 7}))
+    {
+        std::cout << i << '\n';
+    }
+
     return 0;
 }

From 62ad190e0cc9ab21dbc5863cb7b9c30a6e01e3be Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 21 Nov 2013 17:39:34 -0500
Subject: [PATCH 0198/1866] Adds test with range(10) temp

---
 tests/testfilter.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/tests/testfilter.cpp b/tests/testfilter.cpp
index a82b524f..3d528e21 100644
--- a/tests/testfilter.cpp
+++ b/tests/testfilter.cpp
@@ -1,4 +1,5 @@
 #include <filter.hpp>
+#include <range.hpp>
 
 #include <vector>
 #include <iostream>
@@ -48,6 +49,11 @@ int main() {
         std::cout << i << '\n';
     }
 
+    std::cout << "odd numbers in range(10) temp\n";
+    for (auto i : filter([] (const int i) {return i % 2;}, iter::range(10))) {
+        std::cout << i << '\n';
+    }
+
 
     std::cout << "ever numbers in initializer_list\n";
     for (auto i : filter([] (const int i) {return i % 2 == 0;},

From 8775a7551b08dd2403160d4cd75ffbcfd8b5d1b9 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 21 Nov 2013 17:41:49 -0500
Subject: [PATCH 0199/1866] Adds support for initializer_lists and temporaries

---
 filter.hpp | 43 +++++++++++++++++++++++++++++++++----------
 1 file changed, 33 insertions(+), 10 deletions(-)

diff --git a/filter.hpp b/filter.hpp
index 0af88a29..152f6d30 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -5,6 +5,7 @@
 
 #include <utility>
 #include <iterator>
+#include <initializer_list>
 
 namespace iter {
 
@@ -13,24 +14,31 @@ namespace iter {
     class Filter;
 
     template <typename FilterFunc, typename Container>
-    Filter<FilterFunc, Container> filter(FilterFunc, Container &);
+    Filter<FilterFunc, Container> filter(FilterFunc, Container &&);
+
+    template <typename FilterFunc, typename T>
+    Filter<FilterFunc, std::initializer_list<T>> filter(
+            FilterFunc, std::initializer_list<T> &&);
 
     template <typename FilterFunc, typename Container>
     class Filter : IterBase<Container>{
-        private:
+        public:
             Container & container;
             FilterFunc filter_func;
 
             // The filter function is the only thing allowed to create a Filter
-            friend Filter filter<FilterFunc, Container>(FilterFunc,
-                    Container &);
+            friend Filter filter<FilterFunc, Container>(
+                    FilterFunc, Container &&);
 
+            template <typename T>
+            friend Filter<FilterFunc, std::initializer_list<T>> filter(
+                    FilterFunc, std::initializer_list<T> &&);
             using typename IterBase<Container>::contained_iter_type;
 
             using typename IterBase<Container>::contained_iter_ret;
             
             // Value constructor for use only in the filter function
-            Filter(FilterFunc filter_func, Container & container) :
+            Filter(FilterFunc filter_func, Container && container) :
                 container(container),
                 filter_func(filter_func)
             { }
@@ -100,8 +108,9 @@ namespace iter {
     // Helper function to instantiate a Filter
     template <typename FilterFunc, typename Container>
     Filter<FilterFunc, Container> filter(
-            FilterFunc filter_func, Container & container) {
-        return Filter<FilterFunc, Container>(filter_func, container);
+            FilterFunc filter_func, Container && container) {
+        return Filter<FilterFunc, Container>(
+                filter_func, std::forward<Container>(container));
     }
 
     namespace detail {
@@ -126,9 +135,23 @@ namespace iter {
 
 
     template <typename Container>
-    auto filter(Container & container) ->
-            decltype(filter(detail::BoolTester<Container>(), container)) {
-        return filter(detail::BoolTester<Container>(), container);
+    auto filter(Container && container) ->
+            decltype(filter(
+                        detail::BoolTester<Container>(),
+                        std::forward<Container>(container))) {
+        return filter(detail::BoolTester<Container>(),
+                std::forward<Container>(container));
+    }
+
+    template <typename FilterFunc, typename T>
+    Filter<FilterFunc, std::initializer_list<T>> filter(
+            FilterFunc filter_func,
+            std::initializer_list<T> && il)
+    {
+        return Filter<FilterFunc, std::initializer_list<T>>(
+                filter_func,
+                std::move(il));
+                //std::forward<std::initializer_list<T>>(il));
     }
 
 }

From beac28ee84c47182d86ae05032153c436fdef41f Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 21 Nov 2013 17:43:05 -0500
Subject: [PATCH 0200/1866] removes commented out line

---
 filter.hpp | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/filter.hpp b/filter.hpp
index 152f6d30..55d6eb15 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -149,9 +149,7 @@ namespace iter {
             std::initializer_list<T> && il)
     {
         return Filter<FilterFunc, std::initializer_list<T>>(
-                filter_func,
-                std::move(il));
-                //std::forward<std::initializer_list<T>>(il));
+                filter_func, std::move(il));
     }
 
 }

From a0db1a993af03f9392cc68158c0e383c562fd002 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 21 Nov 2013 17:44:11 -0500
Subject: [PATCH 0201/1866] replaces forward with move

---
 enumerate.hpp | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index 1abcb748..851602c9 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -114,8 +114,7 @@ namespace iter {
     template <typename T>
     Enumerable<std::initializer_list<T>> enumerate(std::initializer_list<T> && il)
     {
-        return Enumerable<std::initializer_list<T>>(
-                std::forward<std::initializer_list<T>>(il));
+        return Enumerable<std::initializer_list<T>>(std::move(il));
     }
 
 }

From f816d41e73dc8b87884a4ba9b35b41ebfa464e4f Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 21 Nov 2013 17:44:39 -0500
Subject: [PATCH 0202/1866] replaces forward with move

---
 cycle.hpp | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/cycle.hpp b/cycle.hpp
index 8d4a5e95..5cce0d91 100644
--- a/cycle.hpp
+++ b/cycle.hpp
@@ -94,8 +94,7 @@ namespace iter {
     template <typename T>
     Cycle<std::initializer_list<T>> cycle(std::initializer_list<T> && il)
     {
-        return Cycle<std::initializer_list<T>>(
-                std::forward<std::initializer_list<T>>(il));
+        return Cycle<std::initializer_list<T>>(std::move(il));
     }
 }
 

From b63a6c63fcc7b10f2f7249b52266fc853ae9288d Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 21 Nov 2013 19:30:57 -0500
Subject: [PATCH 0203/1866] Adds test for initialization_list with default
 filter

---
 tests/testfilter.cpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/tests/testfilter.cpp b/tests/testfilter.cpp
index 3d528e21..006cc8d3 100644
--- a/tests/testfilter.cpp
+++ b/tests/testfilter.cpp
@@ -62,5 +62,10 @@ int main() {
         std::cout << i << '\n';
     }
 
+    std::cout << "default in initialization_list\n";
+    for (auto i : filter({-2, -1, 0, 0, 0, 1, 2})) {
+        std::cout << i << '\n';
+    }
+
     return 0;
 }

From 2fd239306156261dc30f12bc73b2497df4bfa7c5 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 21 Nov 2013 19:31:14 -0500
Subject: [PATCH 0204/1866] Adds support for single argument
 initialization_list filter

---
 filter.hpp | 27 +++++++++++++++++++--------
 1 file changed, 19 insertions(+), 8 deletions(-)

diff --git a/filter.hpp b/filter.hpp
index 55d6eb15..5be53cb6 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -113,6 +113,15 @@ namespace iter {
                 filter_func, std::forward<Container>(container));
     }
 
+    template <typename FilterFunc, typename T>
+    Filter<FilterFunc, std::initializer_list<T>> filter(
+            FilterFunc filter_func,
+            std::initializer_list<T> && il)
+    {
+        return Filter<FilterFunc, std::initializer_list<T>>(
+                filter_func, std::move(il));
+    }
+
     namespace detail {
 
         template <typename T>
@@ -139,17 +148,19 @@ namespace iter {
             decltype(filter(
                         detail::BoolTester<Container>(),
                         std::forward<Container>(container))) {
-        return filter(detail::BoolTester<Container>(),
+        return filter(
+                detail::BoolTester<Container>(),
                 std::forward<Container>(container));
     }
 
-    template <typename FilterFunc, typename T>
-    Filter<FilterFunc, std::initializer_list<T>> filter(
-            FilterFunc filter_func,
-            std::initializer_list<T> && il)
-    {
-        return Filter<FilterFunc, std::initializer_list<T>>(
-                filter_func, std::move(il));
+    template <typename T>
+    auto filter(std::initializer_list<T> && il) ->
+            decltype(filter(
+                        detail::BoolTester<std::initializer_list<T>>(),
+                        std::move(il))) {
+           return filter(
+                   detail::BoolTester<std::initializer_list<T>>(),
+                   std::move(il));
     }
 
 }

From 288b025357b197699647b285b7cf07fc57c0aa10 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 21 Nov 2013 23:32:11 -0500
Subject: [PATCH 0205/1866] Adds range(10) temp test

---
 tests/testfilterfalse.cpp | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/tests/testfilterfalse.cpp b/tests/testfilterfalse.cpp
index 73a8e5eb..156bec0e 100644
--- a/tests/testfilterfalse.cpp
+++ b/tests/testfilterfalse.cpp
@@ -1,9 +1,11 @@
 #include <filterfalse.hpp>
+#include <range.hpp>    
 
 #include <vector>
 #include <iostream>
 
 using iter::filterfalse;
+using iter::range;
 
 bool greater_than_four(int i) {
     return i > 4;
@@ -58,5 +60,12 @@ int main() {
         std::cout << i << '\n';
     }
 
+
+    std::cout << "i%2 with range(10), should print even numbers\n";
+    for (auto i : filterfalse([] (const int i) { return i % 2; }, range(10))) {
+        std::cout << i << '\n';
+    }
+
+
     return 0;
 }

From 14838a46a997f8e7cd2b6e3a4c5915e73ad9d35a Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 21 Nov 2013 23:37:44 -0500
Subject: [PATCH 0206/1866] Adds temp test with default filter

---
 tests/testfilterfalse.cpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/tests/testfilterfalse.cpp b/tests/testfilterfalse.cpp
index 156bec0e..93be73d7 100644
--- a/tests/testfilterfalse.cpp
+++ b/tests/testfilterfalse.cpp
@@ -66,6 +66,10 @@ int main() {
         std::cout << i << '\n';
     }
 
+    std::cout << "range(-1, 2)\n";
+    for (auto i : filterfalse(range(-1, 2))) {
+        std::cout << i << '\n';
+    }
 
     return 0;
 }

From 70752f0e770a904f784cd07217457e52ee3b4b39 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 21 Nov 2013 23:39:04 -0500
Subject: [PATCH 0207/1866] Adds temp test with default predicate

---
 tests/testfilter.cpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/tests/testfilter.cpp b/tests/testfilter.cpp
index 006cc8d3..0b0b4865 100644
--- a/tests/testfilter.cpp
+++ b/tests/testfilter.cpp
@@ -54,6 +54,11 @@ int main() {
         std::cout << i << '\n';
     }
 
+    std::cout << "range(-1, 2)\n";
+    for (auto i : filter(iter::range(-1, 2))) {
+        std::cout << i << '\n';
+    }
+
 
     std::cout << "ever numbers in initializer_list\n";
     for (auto i : filter([] (const int i) {return i % 2 == 0;},

From d03f33994c6f224370c967ab023cb1e92a899258 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 21 Nov 2013 23:39:27 -0500
Subject: [PATCH 0208/1866] Adds support for temporaries

---
 filterfalse.hpp | 22 +++++++++++++++-------
 1 file changed, 15 insertions(+), 7 deletions(-)

diff --git a/filterfalse.hpp b/filterfalse.hpp
index b18cca5c..3275f2ab 100644
--- a/filterfalse.hpp
+++ b/filterfalse.hpp
@@ -4,6 +4,8 @@
 #include <iterbase.hpp>
 #include <filter.hpp>
 
+#include <utility>
+
 namespace iter {
 
     namespace detail {
@@ -53,20 +55,26 @@ namespace iter {
     // the bool result of the function.  The PredicateFlipper is then passed
     // to the normal filter() function
     template <typename FilterFunc, typename Container>
-    auto filterfalse(FilterFunc filter_func, Container & container) ->
-            decltype(filter(detail::PredicateFlipper<FilterFunc, Container>(
-                            filter_func), container)) {
+    auto filterfalse(FilterFunc filter_func, Container && container) ->
+            decltype(filter(
+                        detail::PredicateFlipper<FilterFunc, Container>(
+                            filter_func),
+                        std::forward<Container>(container))) {
         return filter(
                 detail::PredicateFlipper<FilterFunc, Container>(filter_func),
-                container);
+                std::forward<Container>(container));
     }
 
     // Single argument version, uses a BoolFlipper to reverse the truthiness
     // of an object
     template <typename Container>
-    auto filterfalse(Container & container) ->
-            decltype(filter(detail::BoolFlipper<Container>(), container)) {
-        return filter(detail::BoolFlipper<Container>(), container);
+    auto filterfalse(Container && container) ->
+            decltype(filter(
+                        detail::BoolFlipper<Container>(),
+                        std::forward<Container>(container))) {
+        return filter(
+                detail::BoolFlipper<Container>(),
+                std::forward<Container>(container));
     }
 
 }

From 365dd5f63ecd7d608ca5d960fcb166050d12d715 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 21 Nov 2013 23:41:55 -0500
Subject: [PATCH 0209/1866] Adds test for initializer_list

---
 tests/testfilterfalse.cpp | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/tests/testfilterfalse.cpp b/tests/testfilterfalse.cpp
index 93be73d7..ca708f5a 100644
--- a/tests/testfilterfalse.cpp
+++ b/tests/testfilterfalse.cpp
@@ -71,5 +71,12 @@ int main() {
         std::cout << i << '\n';
     }
 
+    std::cout << "initializer_list\n";
+    for (auto i : filterfalse([] (const int i) { return  i % 2; },
+                {10, 11, 12, 13, 14, 15, 16}))
+    {
+        std::cout << i << '\n';
+    }
+
     return 0;
 }

From 33f5f9c4a1db8c5476c809d8efc03df8f66b7ccb Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 21 Nov 2013 23:45:51 -0500
Subject: [PATCH 0210/1866] Adds test for initializer_list with default
 predicate

---
 tests/testfilterfalse.cpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/tests/testfilterfalse.cpp b/tests/testfilterfalse.cpp
index ca708f5a..0ff0fad0 100644
--- a/tests/testfilterfalse.cpp
+++ b/tests/testfilterfalse.cpp
@@ -78,5 +78,10 @@ int main() {
         std::cout << i << '\n';
     }
 
+    std::cout << "initializer_list with default\n";
+    for (auto i : filterfalse({-1, -2, 0, 0, 0, 0, 1, 2, 3})) {
+        std::cout << i << '\n';
+    }
+
     return 0;
 }

From df92bd654268ef9be677d46cb597f265975e582b Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 21 Nov 2013 23:46:09 -0500
Subject: [PATCH 0211/1866] Adds support for initializer_lists

---
 filterfalse.hpp | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/filterfalse.hpp b/filterfalse.hpp
index 3275f2ab..4448e7d0 100644
--- a/filterfalse.hpp
+++ b/filterfalse.hpp
@@ -77,6 +77,31 @@ namespace iter {
                 std::forward<Container>(container));
     }
 
+    
+
+    //specializations for initializer_lists
+    template <typename FilterFunc, typename T>
+    auto filterfalse(FilterFunc filter_func, std::initializer_list<T> && container) ->
+            decltype(filter(
+                        detail::PredicateFlipper<FilterFunc, std::initializer_list<T>>(
+                            filter_func),
+                        std::move(container))) {
+        return filter(
+                detail::PredicateFlipper<FilterFunc, std::initializer_list<T>>(filter_func),
+                std::move(container));
+    }
+
+    // Single argument version, uses a BoolFlipper to reverse the truthiness
+    // of an object
+    template <typename T>
+    auto filterfalse(std::initializer_list<T> && container) ->
+            decltype(filter(
+                        detail::BoolFlipper<std::initializer_list<T>>(),
+                        std::move(container))) {
+        return filter(
+                detail::BoolFlipper<std::initializer_list<T>>(),
+                std::move(container));
+    }
 }
 
 #endif //#ifndef FILTER_FALSE__HPP__

From 71a8d306fa2f8b35eb5240f5867b4ea4efeeacea Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 21 Nov 2013 23:50:09 -0500
Subject: [PATCH 0212/1866] Adds test with temp

---
 tests/testtakewhile.cpp | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/tests/testtakewhile.cpp b/tests/testtakewhile.cpp
index 59568fe2..9da89040 100644
--- a/tests/testtakewhile.cpp
+++ b/tests/testtakewhile.cpp
@@ -1,14 +1,21 @@
 #include <takewhile.hpp>
+#include <range.hpp>
 
 #include <vector>
 #include <iostream>
 
 using iter::takewhile;
+using iter::range;
 
 int main() {
     std::vector<int> ivec{1, 2, 3, 4, 5, 6, 7, 6, 5, 4, 3, 2, 1};
     for (auto i : takewhile([] (int i) {return i < 5;}, ivec)) {
         std::cout << i << '\n';
     }
+
+    for (auto i : takewhile([] (int i) {return i < 5;}, range(10))) {
+        std::cout << i << '\n';
+    }
+
     return 0;
 }

From 0162c442a25caf45c62cb800f59fce4b636c6210 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 21 Nov 2013 23:51:39 -0500
Subject: [PATCH 0213/1866] Adds support for temporaries

---
 takewhile.hpp | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/takewhile.hpp b/takewhile.hpp
index a41c6109..7cf3bf73 100644
--- a/takewhile.hpp
+++ b/takewhile.hpp
@@ -13,7 +13,7 @@ namespace iter {
     class TakeWhile;
 
     template <typename FilterFunc, typename Container>
-    TakeWhile<FilterFunc, Container> takewhile(FilterFunc, Container &);
+    TakeWhile<FilterFunc, Container> takewhile(FilterFunc, Container &&);
 
     template <typename FilterFunc, typename Container>
     class TakeWhile : IterBase<Container>{
@@ -22,14 +22,14 @@ namespace iter {
             FilterFunc filter_func;
 
             friend TakeWhile takewhile<FilterFunc, Container>(
-                    FilterFunc, Container &);
+                    FilterFunc, Container &&);
 
             using typename IterBase<Container>::contained_iter_type;
 
             using typename IterBase<Container>::contained_iter_ret;
 
             // Value constructor for use only in the takewhile function
-            TakeWhile(FilterFunc filter_func, Container & container) :
+            TakeWhile(FilterFunc filter_func, Container && container) :
                 container(container),
                 filter_func(filter_func)
             { }
@@ -99,8 +99,10 @@ namespace iter {
     // Helper function to instantiate a TakeWhile
     template <typename FilterFunc, typename Container>
     TakeWhile<FilterFunc, Container> takewhile(
-            FilterFunc filter_func, Container & container) {
-        return TakeWhile<FilterFunc, Container>(filter_func, container);
+            FilterFunc filter_func, Container && container) {
+        return TakeWhile<FilterFunc, Container>(
+                filter_func,
+                std::forward<Container>(container));
     }
 
 }

From ee77cd61c55cf1d3a67ab457c508056f39349c7b Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 21 Nov 2013 23:52:52 -0500
Subject: [PATCH 0214/1866] Adds test with temporary

---
 tests/testdropwhile.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/tests/testdropwhile.cpp b/tests/testdropwhile.cpp
index c29dde4b..5db34401 100644
--- a/tests/testdropwhile.cpp
+++ b/tests/testdropwhile.cpp
@@ -1,14 +1,20 @@
 #include <dropwhile.hpp>
+#include <range.hpp>
 
 #include <vector>
 #include <iostream>
 
 using iter::dropwhile;
+using iter::range;
 
 int main() {
     std::vector<int> ivec{1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4};
     for (auto i : dropwhile([] (int i) {return i < 5;}, ivec)) {
         std::cout << i << '\n';
     }
+
+    for (auto i : dropwhile([] (int i) {return i < 5;}, range(10))) {
+        std::cout << i << '\n';
+    }
     return 0;
 }

From 9abd92582e788b8e11e6f1179a89718ea76250ad Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 21 Nov 2013 23:54:20 -0500
Subject: [PATCH 0215/1866] Adds support for temporaries

---
 dropwhile.hpp | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/dropwhile.hpp b/dropwhile.hpp
index ab9dccdf..3fda7cde 100644
--- a/dropwhile.hpp
+++ b/dropwhile.hpp
@@ -13,7 +13,7 @@ namespace iter {
     class DropWhile;
 
     template <typename FilterFunc, typename Container>
-    DropWhile<FilterFunc, Container> dropwhile(FilterFunc, Container &);
+    DropWhile<FilterFunc, Container> dropwhile(FilterFunc, Container &&);
 
     template <typename FilterFunc, typename Container>
     class DropWhile : IterBase<Container> {
@@ -22,7 +22,7 @@ namespace iter {
             FilterFunc filter_func;
 
             friend DropWhile dropwhile<FilterFunc, Container>(
-                    FilterFunc, Container &);
+                    FilterFunc, Container &&);
 
             using typename IterBase<Container>::contained_iter_type;
 
@@ -30,7 +30,7 @@ namespace iter {
 
             
             // Value constructor for use only in the dropwhile function
-            DropWhile(FilterFunc filter_func, Container & container) :
+            DropWhile(FilterFunc filter_func, Container && container) :
                 container(container),
                 filter_func(filter_func)
             { }
@@ -97,8 +97,10 @@ namespace iter {
     // Helper function to instantiate a DropWhile
     template <typename FilterFunc, typename Container>
     DropWhile<FilterFunc, Container> dropwhile(
-            FilterFunc filter_func, Container & container) {
-        return DropWhile<FilterFunc, Container>(filter_func, container);
+            FilterFunc filter_func, Container && container) {
+        return DropWhile<FilterFunc, Container>(
+                filter_func, 
+                std::forward<Container>(container));
     }
 
 }

From 2ed2144224b7777fb5cc4abac7739577b88df2f1 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 21 Nov 2013 23:55:56 -0500
Subject: [PATCH 0216/1866] Adds test for initializer_list

---
 tests/testdropwhile.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/tests/testdropwhile.cpp b/tests/testdropwhile.cpp
index 5db34401..8413e291 100644
--- a/tests/testdropwhile.cpp
+++ b/tests/testdropwhile.cpp
@@ -16,5 +16,11 @@ int main() {
     for (auto i : dropwhile([] (int i) {return i < 5;}, range(10))) {
         std::cout << i << '\n';
     }
+
+    for (auto i : dropwhile([] (int i) {return i < 5;}, 
+                {1, 2, 3, 4, 5, 6, 7, 8, 9})) {
+        std::cout << i << '\n';
+    }
+
     return 0;
 }

From 74ff071268a1d7f5b55d07daf72d6f0fbf6dcc44 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 22 Nov 2013 00:05:49 -0500
Subject: [PATCH 0217/1866] Restores privacy

---
 filter.hpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/filter.hpp b/filter.hpp
index 5be53cb6..75c23bc0 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -22,7 +22,7 @@ namespace iter {
 
     template <typename FilterFunc, typename Container>
     class Filter : IterBase<Container>{
-        public:
+        private:
             Container & container;
             FilterFunc filter_func;
 
@@ -30,9 +30,9 @@ namespace iter {
             friend Filter filter<FilterFunc, Container>(
                     FilterFunc, Container &&);
 
-            template <typename T>
-            friend Filter<FilterFunc, std::initializer_list<T>> filter(
-                    FilterFunc, std::initializer_list<T> &&);
+            template <typename FF, typename T>
+            friend Filter<FF, std::initializer_list<T>> filter(
+                    FF, std::initializer_list<T> &&);
             using typename IterBase<Container>::contained_iter_type;
 
             using typename IterBase<Container>::contained_iter_ret;

From 02c543fa50affae8c9788ef4a2a76af335329b57 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 22 Nov 2013 00:06:47 -0500
Subject: [PATCH 0218/1866] Adds support for initializer_lists

---
 dropwhile.hpp | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/dropwhile.hpp b/dropwhile.hpp
index 3fda7cde..1f13efc9 100644
--- a/dropwhile.hpp
+++ b/dropwhile.hpp
@@ -5,6 +5,7 @@
 
 #include <utility>
 #include <iterator>
+#include <initializer_list>
 
 namespace iter {
 
@@ -15,6 +16,10 @@ namespace iter {
     template <typename FilterFunc, typename Container>
     DropWhile<FilterFunc, Container> dropwhile(FilterFunc, Container &&);
 
+    template <typename FilterFunc, typename T>
+    DropWhile<FilterFunc, std::initializer_list<T>> dropwhile(
+            FilterFunc, std::initializer_list<T> &&);
+
     template <typename FilterFunc, typename Container>
     class DropWhile : IterBase<Container> {
         private:
@@ -24,6 +29,10 @@ namespace iter {
             friend DropWhile dropwhile<FilterFunc, Container>(
                     FilterFunc, Container &&);
 
+            template <typename FF, typename T>
+            friend DropWhile<FF, std::initializer_list<T>> dropwhile(
+                    FF, std::initializer_list<T> &&);
+
             using typename IterBase<Container>::contained_iter_type;
 
             using typename IterBase<Container>::contained_iter_ret;
@@ -103,6 +112,14 @@ namespace iter {
                 std::forward<Container>(container));
     }
 
+    template <typename FilterFunc, typename T>
+    DropWhile<FilterFunc, std::initializer_list<T>> dropwhile(
+            FilterFunc filter_func, std::initializer_list<T> && il)
+    {
+        return DropWhile<FilterFunc, std::initializer_list<T>>(
+                filter_func,
+                std::move(il));
+    }
 }
 
 #endif //ifndef DROPWHILE__H__

From 7c4a44cb48d5b1f3ae41648840606e0fbb1ee7f4 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 22 Nov 2013 00:08:36 -0500
Subject: [PATCH 0219/1866] Adds test for initializer_list

---
 tests/testtakewhile.cpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/tests/testtakewhile.cpp b/tests/testtakewhile.cpp
index 9da89040..6cbd6e17 100644
--- a/tests/testtakewhile.cpp
+++ b/tests/testtakewhile.cpp
@@ -17,5 +17,10 @@ int main() {
         std::cout << i << '\n';
     }
 
+    for (auto i : takewhile([] (int i) {return i < 5;}, 
+                {1, 2, 3, 4, 5, 6, 7, 8, 9})) {
+        std::cout << i << '\n';
+    }
+
     return 0;
 }

From ba17f1a14b8e09425097b9b5e294f0a06360e5ea Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 22 Nov 2013 00:12:09 -0500
Subject: [PATCH 0220/1866] Adds support for initializer_lists

---
 takewhile.hpp | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/takewhile.hpp b/takewhile.hpp
index 7cf3bf73..8531223f 100644
--- a/takewhile.hpp
+++ b/takewhile.hpp
@@ -5,6 +5,7 @@
 
 #include <utility>
 #include <iterator>
+#include <initializer_list>
 
 namespace iter {
 
@@ -15,6 +16,10 @@ namespace iter {
     template <typename FilterFunc, typename Container>
     TakeWhile<FilterFunc, Container> takewhile(FilterFunc, Container &&);
 
+    template <typename FilterFunc, typename T>
+    TakeWhile<FilterFunc, std::initializer_list<T>> takewhile(
+            FilterFunc, std::initializer_list<T> &&);
+
     template <typename FilterFunc, typename Container>
     class TakeWhile : IterBase<Container>{
         private:
@@ -24,6 +29,10 @@ namespace iter {
             friend TakeWhile takewhile<FilterFunc, Container>(
                     FilterFunc, Container &&);
 
+            template <typename FF, typename T>
+            friend TakeWhile<FF, std::initializer_list<T>> takewhile(
+                    FF, std::initializer_list<T> &&);
+
             using typename IterBase<Container>::contained_iter_type;
 
             using typename IterBase<Container>::contained_iter_ret;
@@ -105,6 +114,15 @@ namespace iter {
                 std::forward<Container>(container));
     }
 
+    template <typename FilterFunc, typename T>
+    TakeWhile<FilterFunc, std::initializer_list<T>> takewhile(
+            FilterFunc filter_func, std::initializer_list<T> && il)
+    {
+        return TakeWhile<FilterFunc, std::initializer_list<T>>(
+                filter_func,
+                std::move(il));
+    }
+
 }
 
 #endif //ifndef TAKEWHILE__H__

From 79ca168830b1b2b4603a9f5bc3ebd94d7dcb486d Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Fri, 22 Nov 2013 14:46:41 -0500
Subject: [PATCH 0221/1866] added some tests

---
 tests/testcombinations.cpp | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/tests/testcombinations.cpp b/tests/testcombinations.cpp
index 422c088e..ad2919f8 100644
--- a/tests/testcombinations.cpp
+++ b/tests/testcombinations.cpp
@@ -17,13 +17,19 @@ int main() {
         for (auto j : i ) std::cout << j << " ";
         std::cout<<std::endl;
     }
-    for (auto i : combinations(v,3)) {
+    for (auto i : combinations(v,1)) {
+        for (auto j : i ) std::cout << j << " ";
+        std::cout<<std::endl;
+    }
+    for (auto i : combinations(v,5)) {
         for (auto j : i ) std::cout << j << " ";
         std::cout<<std::endl;
     }
+    /*
     for (auto i : combinations(std::vector<int>{1,2,3,4},3)) {
         for (auto j : i ) std::cout << j << " ";
         std::cout<<std::endl;
     }
+    */
     return 0;
 }

From 30d4d48588f5bec2d8e7206f0ab1f46f6e9b4364 Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Fri, 22 Nov 2013 14:55:33 -0500
Subject: [PATCH 0222/1866] added initializer_list support to combinations

---
 combinations.hpp           | 18 +++++++++++++-----
 tests/testcombinations.cpp |  4 +---
 2 files changed, 14 insertions(+), 8 deletions(-)

diff --git a/combinations.hpp b/combinations.hpp
index 8ef8939b..1ff9a991 100644
--- a/combinations.hpp
+++ b/combinations.hpp
@@ -8,6 +8,7 @@
 #include <type_traits>
 #include <iterator>
 #include <iostream>
+#include <initializer_list>
 
 namespace iter {
     //Could try having antoher template for container to return (right now it's
@@ -23,19 +24,26 @@ namespace iter {
             return 
                 iterator_range<combinations_iter<Container>>(begin,end);
         }
+    template <typename T>
+        iterator_range<combinations_iter<std::initializer_list<T>>>
+        combinations(std::initializer_list<T> && container, size_t N) {
+            auto begin = combinations_iter<std::initializer_list<T>>(container,N);
+            auto end = combinations_iter<std::initializer_list<T>>(container,N);
+            return {begin,end};
+        }
     template <typename Container>
         struct combinations_iter
         {
         private:
             const Container & items;
-            std::vector<decltype(items.cbegin())> indicies;
+            std::vector<decltype(std::begin(items))> indicies;
             bool not_done = true;
 
         public:
             //Holy shit look at this typedef
             using item_t = typename 
                 std::remove_const<
-                typename std::remove_reference<decltype(items.front())>::type>::type;
+                typename std::remove_reference<decltype(*(std::begin(items)))>::type>::type;
             combinations_iter(const Container & i, size_t N) : 
                 items(i),indicies(N)
             {
@@ -45,8 +53,8 @@ namespace iter {
                 }
                 size_t inc = 0;
                 for (auto & iter : indicies) {
-                    if (items.cbegin() + inc != items.cend()) {
-                        iter = items.cbegin()+inc;
+                    if (std::begin(items) + inc != std::end(items)) {
+                        iter = std::begin(items)+inc;
                         ++inc;
                     }
                     else {
@@ -74,7 +82,7 @@ namespace iter {
                     //index and the end of indicies is >= the distance between
                     //the item and end of item
                     if ((*iter + std::distance(indicies.rbegin(),iter)) ==
-                            items.cend()) {
+                            std::end(items)) {
                         if ( (iter + 1) != indicies.rend()) {
                             size_t inc = 1;
                             for (auto down = iter; down != indicies.rbegin()-1;--down) {
diff --git a/tests/testcombinations.cpp b/tests/testcombinations.cpp
index ad2919f8..2576dc94 100644
--- a/tests/testcombinations.cpp
+++ b/tests/testcombinations.cpp
@@ -25,11 +25,9 @@ int main() {
         for (auto j : i ) std::cout << j << " ";
         std::cout<<std::endl;
     }
-    /*
-    for (auto i : combinations(std::vector<int>{1,2,3,4},3)) {
+    for (auto i : combinations({1,2,3,4},3)) {
         for (auto j : i ) std::cout << j << " ";
         std::cout<<std::endl;
     }
-    */
     return 0;
 }

From 0bd3b09b5418d22a6ea1bede538865d3c41824d7 Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Fri, 22 Nov 2013 15:14:53 -0500
Subject: [PATCH 0223/1866] Added initializer_list support to
 combinations_with_replacement

---
 combinations_with_replacement.hpp           | 17 ++++++++++++-----
 tests/testcombinations_with_replacement.cpp | 15 +++++++++++++++
 2 files changed, 27 insertions(+), 5 deletions(-)

diff --git a/combinations_with_replacement.hpp b/combinations_with_replacement.hpp
index 043e0cf2..07aacf85 100644
--- a/combinations_with_replacement.hpp
+++ b/combinations_with_replacement.hpp
@@ -24,19 +24,26 @@ namespace iter {
             return 
                 iterator_range<combinations_with_replacement_iter<Container>>(begin,end);
         }
-    template <typename Container>
+     template <typename T>
+        iterator_range<combinations_with_replacement_iter<std::initializer_list<T>>>
+        combinations_with_replacement(std::initializer_list<T> && container, size_t N) {
+            auto begin = combinations_with_replacement_iter<std::initializer_list<T>>(container, N);
+            auto end = combinations_with_replacement_iter<std::initializer_list<T>>(container, N);
+            return {begin,end};
+        }
+   template <typename Container>
         struct combinations_with_replacement_iter
         {
         private:
             const Container & items;
-            std::vector<decltype(items.cbegin())> indicies;
+            std::vector<decltype(std::begin(items))> indicies;
             bool not_done = true;
 
         public:
             //Holy shit look at this typedef
             using item_t = typename 
                 std::remove_const<
-                typename std::remove_reference<decltype(items.front())>::type>::type;
+                typename std::remove_reference<decltype(*(std::begin(items)))>::type>::type;
             combinations_with_replacement_iter(const Container & i, size_t N) : 
                 items(i), indicies(N)
             {
@@ -44,7 +51,7 @@ namespace iter {
                     not_done = false;
                     return;
                 }
-                for (auto & iter : indicies) iter = items.cbegin();
+                for (auto & iter : indicies) iter = std::begin(items);
             }
             //technically should be a dynarray
             std::vector<item_t> operator*()const
@@ -62,7 +69,7 @@ namespace iter {
             {
                 for (auto iter = indicies.rbegin(); iter != indicies.rend(); ++iter) {
                     ++(*iter);
-                    if (*iter == items.cend()) {
+                    if (*iter == std::end(items)) {
                         if ( (iter + 1) != indicies.rend()) {
                             for (auto down = iter; down != indicies.rbegin()-1;--down) {
                                 (*down) = (*(iter + 1)) + 1; 
diff --git a/tests/testcombinations_with_replacement.cpp b/tests/testcombinations_with_replacement.cpp
index 9d714e0c..40fbad82 100644
--- a/tests/testcombinations_with_replacement.cpp
+++ b/tests/testcombinations_with_replacement.cpp
@@ -14,5 +14,20 @@ int main() {
         for (auto j : i ) std::cout << j << " ";
         std::cout<<std::endl;
     }
+    for (auto i : combinations_with_replacement(v,4)) {
+        //std::cout << i << std::endl;
+        for (auto j : i ) std::cout << j << " ";
+        std::cout<<std::endl;
+    }
+    for (auto i : combinations_with_replacement(v,1)) {
+        //std::cout << i << std::endl;
+        for (auto j : i ) std::cout << j << " ";
+        std::cout<<std::endl;
+    }
+    for (auto i : combinations_with_replacement({1,2,3,4},4)) {
+        //std::cout << i << std::endl;
+        for (auto j : i ) std::cout << j << " ";
+        std::cout<<std::endl;
+    }
     return 0;
 }

From edd5d04c7a6589a30e0f47e24d457761f3de2753 Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Fri, 22 Nov 2013 15:30:46 -0500
Subject: [PATCH 0224/1866] permutations works with initializer_lists

---
 permutations.hpp           | 18 +++++++++++++++---
 tests/testpermutations.cpp |  7 +++++++
 2 files changed, 22 insertions(+), 3 deletions(-)

diff --git a/permutations.hpp b/permutations.hpp
index 839452c9..d9a65e2d 100644
--- a/permutations.hpp
+++ b/permutations.hpp
@@ -3,6 +3,8 @@
 
 #include "iterator_range.hpp"
 #include <algorithm>
+#include <initializer_list>
+#include <vector>
 
 namespace iter {
     template <typename Container>
@@ -15,24 +17,34 @@ namespace iter {
                     permutation_iter<Container>(container),
                     permutation_iter<Container>());
         }
+    //since initializer_list doesn't have bidir iters this is a hack
+    //to get it to work by using a vector in its place
+    template <typename T>
+        iterator_range<permutation_iter<std::vector<T>>>
+        permutations (std::initializer_list<T> && container) {
+            std::vector<T> begin(std::begin(container),std::end(container));
+            return  {permutation_iter<std::vector<T>>(container),
+                    permutation_iter<std::vector<T>>()};
+        }
+
     template <typename Container>
         struct permutation_iter
         {
             Container container;
-            using Iterator = decltype(container.begin());
+            using Iterator = decltype(std::begin(container));
             bool is_not_last = true;
             permutation_iter(){}
             permutation_iter(const Container & c) : container(c) 
             {
                 //sort first so you can get every permutation
-                std::sort(container.begin(),container.end());
+                std::sort(std::begin(container),std::end(container));
             }
             const Container & operator*()
             {
                 return container;
             }
             permutation_iter & operator++() {
-                is_not_last = std::next_permutation(container.begin(),container.end());
+                is_not_last = std::next_permutation(std::begin(container),std::end(container));
                 return *this;
             }
             bool operator!=(const permutation_iter &) {
diff --git a/tests/testpermutations.cpp b/tests/testpermutations.cpp
index aa72c98a..adeeca06 100644
--- a/tests/testpermutations.cpp
+++ b/tests/testpermutations.cpp
@@ -27,5 +27,12 @@ int main() {
         }
         std::cout << std::endl;
     }
+    //std::next_permutation doesn't work on initializer_lists
+    for (auto vec : permutations({1,2,3,4})) {
+        for (auto c : vec) {
+            std::cout << c << " ";
+        }
+        std::cout << std::endl;
+    }
     return 0;
 }

From 46e39f725a436ab98aad2f10d9c6beccff7217aa Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Fri, 22 Nov 2013 15:35:29 -0500
Subject: [PATCH 0225/1866] powerset initializer_list supoport

---
 powerset.hpp           | 11 +++++++++++
 tests/testpowerset.cpp |  5 +++++
 2 files changed, 16 insertions(+)

diff --git a/powerset.hpp b/powerset.hpp
index 52398325..58e7cdfc 100644
--- a/powerset.hpp
+++ b/powerset.hpp
@@ -3,6 +3,7 @@
 
 #include "iterator_range.hpp"
 #include "combinations.hpp"
+#include <initializer_list>
 
 namespace iter {
     template <typename Container>
@@ -17,6 +18,16 @@ namespace iter {
             return iterator_range<powerset_iter<Container>>(begin,end);
         }
 
+    template <typename T>
+        iterator_range<powerset_iter<std::initializer_list<T>>>
+        powerset(std::initializer_list<T> && container)
+        {
+            auto begin = powerset_iter<std::initializer_list<T>>(container);
+            auto end = powerset_iter<std::initializer_list<T>>(container);
+            return {begin,end};
+        }
+
+
     template <typename Container>
         struct powerset_iter {
         private:
diff --git a/tests/testpowerset.cpp b/tests/testpowerset.cpp
index 23249f42..10f92c52 100644
--- a/tests/testpowerset.cpp
+++ b/tests/testpowerset.cpp
@@ -10,5 +10,10 @@ int main() {
         for (auto i : v) std::cout << i << " ";
         std::cout << std::endl;
     }
+    for (auto v : powerset({1,2,3,4})) {
+        for (auto i : v) std::cout << i << " ";
+        std::cout << std::endl;
+    }
+
     return 0;
 }

From f0e655d49bc6a3ef945aeaa04f1239bd50f74a5f Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 22 Nov 2013 16:08:16 -0500
Subject: [PATCH 0226/1866] Adds tests for temporaries

---
 tests/testgroupby.cpp | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/tests/testgroupby.cpp b/tests/testgroupby.cpp
index 8897d379..19af7ad1 100644
--- a/tests/testgroupby.cpp
+++ b/tests/testgroupby.cpp
@@ -53,6 +53,15 @@ int main()
         std::cout << '\n';
     }
 
+    for (auto gb : groupby("aabbccccdd", [] (const char c) {return c < 'c';})){
+        std::cout << "key: " << gb.first << '\n';
+        std::cout << "content: ";
+        for (auto s : gb.second) {
+            std::cout << s << "  ";
+        }
+        std::cout << '\n';
+    }
+        
 
     return 0;
 }

From f441c5aa8573a85fe471a17426dce36fcc677a7a Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 22 Nov 2013 16:09:00 -0500
Subject: [PATCH 0227/1866]  Adds support for temporaries

---
 groupby.hpp | 20 ++++++++++++--------
 1 file changed, 12 insertions(+), 8 deletions(-)

diff --git a/groupby.hpp b/groupby.hpp
index c02e7a5f..49dd1b0d 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -12,7 +12,7 @@ namespace iter {
     class GroupBy;
 
     template <typename Container, typename KeyFunc>
-    GroupBy<Container, KeyFunc> groupby(Container &, KeyFunc);
+    GroupBy<Container, KeyFunc> groupby(Container &&, KeyFunc);
 
     template <typename Container, typename KeyFunc>
     class GroupBy : IterBase<Container> {
@@ -21,7 +21,7 @@ namespace iter {
             KeyFunc key_func;
 
             // The filter function is the only thing allowed to create a Filter
-            friend GroupBy groupby<Container, KeyFunc>(Container &, KeyFunc);
+            friend GroupBy groupby<Container, KeyFunc>(Container &&, KeyFunc);
 
             using typename IterBase<Container>::contained_iter_type;
 
@@ -31,7 +31,7 @@ namespace iter {
                 decltype(std::declval<KeyFunc>()(
                             std::declval<contained_iter_ret>()));
 
-            GroupBy(Container & container, KeyFunc key_func) :
+            GroupBy(Container && container, KeyFunc key_func) :
                 container(container),
                 key_func(key_func)
             { }
@@ -213,8 +213,10 @@ namespace iter {
 
     template <typename Container, typename KeyFunc>
     GroupBy<Container, KeyFunc> groupby(
-            Container & container, KeyFunc key_func) {
-        return GroupBy<Container, KeyFunc>(container, key_func);
+            Container && container, KeyFunc key_func) {
+        return GroupBy<Container, KeyFunc>(
+                std::forward<Container>(container),
+                key_func);
     }
 
     template <typename Container>
@@ -230,9 +232,11 @@ namespace iter {
     };
 
     template <typename Container>
-    auto groupby(Container & container) ->
-            decltype(groupby(container, ItemReturner<Container>())) {
-        return groupby(container, ItemReturner<Container>());
+    auto groupby(Container && container) ->
+            decltype(groupby(std::forward<Container>(container),
+                        ItemReturner<Container>())) {
+        return groupby(std::forward<Container>(container),
+                ItemReturner<Container>());
     }
 
 }

From 09fa6c2b56be40e1b2e42e3bf463187f0f1779c0 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 22 Nov 2013 16:19:04 -0500
Subject: [PATCH 0228/1866] Makes GroupBy movable, non-copyable

---
 groupby.hpp | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/groupby.hpp b/groupby.hpp
index 49dd1b0d..021afdfb 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -35,11 +35,14 @@ namespace iter {
                 container(container),
                 key_func(key_func)
             { }
-            GroupBy () = delete;
-            GroupBy & operator=(const GroupBy &) = delete;
 
         public:
-            GroupBy(const GroupBy &) = default;
+            GroupBy () = delete;
+            GroupBy(const GroupBy &) = delete;
+            GroupBy& operator=(const GroupBy &) = delete;
+
+            GroupBy (GroupBy &&) = default;
+            GroupBy & operator=(GroupBy &&) = default;
 
             class Iterator;
             class Group;
@@ -131,14 +134,12 @@ namespace iter {
                         }
                     }
                            
-
-
-                    // can be move constructed, but not copied or move assigned
+                    // movable, non-copyable
                     Group () = delete;
                     Group (const Group &) = delete;
                     Group & operator=(const Group &) = delete;
-                    Group & operator=(Group &&) = delete;
 
+                    Group & operator=(Group &&) = default;
                     Group (Group && other) :
                             owner(other.owner),
                             key(other.key),

From 66041a195393d3f91ff979d4cfaefc6e40c8da02 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 22 Nov 2013 17:23:18 -0500
Subject: [PATCH 0229/1866] Adds test for initializer_list with default key

---
 tests/testgroupby.cpp | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/tests/testgroupby.cpp b/tests/testgroupby.cpp
index 19af7ad1..c38687fc 100644
--- a/tests/testgroupby.cpp
+++ b/tests/testgroupby.cpp
@@ -61,6 +61,15 @@ int main()
         }
         std::cout << '\n';
     }
+    
+    for (auto gb : groupby({'a', 'a', 'b', 'b', 'c'})) {
+        std::cout << "key: " << gb.first << '\n';
+        std::cout << "content: ";
+        for (auto s : gb.second) {
+            std::cout << s << "  ";
+        }
+        std::cout << '\n';
+    }
         
 
     return 0;

From 14fb16b25d5e9a66e58d565b35904556eb21884c Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 22 Nov 2013 17:33:33 -0500
Subject: [PATCH 0230/1866] Adds test with initializer_list and defalt Key

---
 tests/testgroupby.cpp | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/tests/testgroupby.cpp b/tests/testgroupby.cpp
index c38687fc..c796e215 100644
--- a/tests/testgroupby.cpp
+++ b/tests/testgroupby.cpp
@@ -70,6 +70,16 @@ int main()
         }
         std::cout << '\n';
     }
+
+    for (auto gb : groupby({'a', 'a', 'b', 'b', 'c', 'c', 'd', 'd'},
+                [] (const char c) {return c < 'c'; })) {
+        std::cout << "key: " << gb.first << '\n';
+        std::cout << "content: ";
+        for (auto s : gb.second) {
+            std::cout << s << "  ";
+        }
+        std::cout << '\n';
+    }
         
 
     return 0;

From a3f535f24bbf873aead82489a76c138bec81e579 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 22 Nov 2013 17:33:51 -0500
Subject: [PATCH 0231/1866] Adds support for initializer_lists

---
 groupby.hpp | 49 ++++++++++++++++++++++++++++++++++++++++---------
 1 file changed, 40 insertions(+), 9 deletions(-)

diff --git a/groupby.hpp b/groupby.hpp
index 021afdfb..1abc2b93 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -5,6 +5,7 @@
 
 #include <utility>
 #include <iterator>
+#include <initializer_list>
 
 namespace iter {
 
@@ -14,15 +15,22 @@ namespace iter {
     template <typename Container, typename KeyFunc>
     GroupBy<Container, KeyFunc> groupby(Container &&, KeyFunc);
 
+    template <typename T, typename KeyFunc>
+    GroupBy<std::initializer_list<T>, KeyFunc> groupby(
+            std::initializer_list<T> &&, KeyFunc);
+
     template <typename Container, typename KeyFunc>
     class GroupBy : IterBase<Container> {
         private:
             Container & container;
             KeyFunc key_func;
 
-            // The filter function is the only thing allowed to create a Filter
             friend GroupBy groupby<Container, KeyFunc>(Container &&, KeyFunc);
 
+            template <typename T, typename KF>
+            friend GroupBy<std::initializer_list<T>, KF> groupby(
+                    std::initializer_list<T> &&, KF);
+
             using typename IterBase<Container>::contained_iter_type;
 
             using typename IterBase<Container>::contained_iter_ret;
@@ -212,14 +220,8 @@ namespace iter {
 
     };
 
-    template <typename Container, typename KeyFunc>
-    GroupBy<Container, KeyFunc> groupby(
-            Container && container, KeyFunc key_func) {
-        return GroupBy<Container, KeyFunc>(
-                std::forward<Container>(container),
-                key_func);
-    }
-
+    // Takes something and returns it, used for default key of comparing
+    // items in the sequence directly
     template <typename Container>
     class ItemReturner {
         private:
@@ -232,6 +234,16 @@ namespace iter {
             }
     };
 
+
+    template <typename Container, typename KeyFunc>
+    GroupBy<Container, KeyFunc> groupby(
+            Container && container, KeyFunc key_func) {
+        return GroupBy<Container, KeyFunc>(
+                std::forward<Container>(container),
+                key_func);
+    }
+
+
     template <typename Container>
     auto groupby(Container && container) ->
             decltype(groupby(std::forward<Container>(container),
@@ -240,6 +252,25 @@ namespace iter {
                 ItemReturner<Container>());
     }
 
+    
+    template <typename T, typename KeyFunc>
+    GroupBy<std::initializer_list<T>, KeyFunc> groupby(
+            std::initializer_list<T> && il, KeyFunc key_func) {
+        return GroupBy<std::initializer_list<T>, KeyFunc>(
+                std::move(il),
+                key_func);
+    }
+
+
+    template <typename T>
+    auto groupby(std::initializer_list<T> && il) ->
+            decltype(groupby(std::move(il),
+                        ItemReturner<std::initializer_list<T>>())) {
+        return groupby(
+                std::move(il),
+                ItemReturner<std::initializer_list<T>>());
+    }
+
 }
 
 

From 72a8fe6229f3b9f0a6d97339c338d7ccc4659cdc Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 22 Nov 2013 20:45:21 -0500
Subject: [PATCH 0232/1866] Adds test with two ranges zipped together (fails)

---
 tests/testzip.cpp | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/tests/testzip.cpp b/tests/testzip.cpp
index eb0ef476..65254030 100644
--- a/tests/testzip.cpp
+++ b/tests/testzip.cpp
@@ -1,5 +1,6 @@
 #include <zip.hpp>
 #include <chain.hpp>
+#include <range.hpp>
 
 #include <vector>
 #include <string>
@@ -25,6 +26,11 @@ int main() {
             std::cout << std::get<0>(e) << std::endl;
             std::cout << std::get<1>(e) << std::endl;
         }
+
+        for (auto e : zip(iter::range(10), iter::range(10, 20))) {
+            std::cout << std::get<0>(e) << '\n';
+            std::cout << std::get<1>(e) << '\n';
+        }
     }
     //Aaron's test
     {
@@ -81,6 +87,10 @@ int main() {
                 << std::get<2>(e) << std::endl;
         }
     }
+
+
+
+
     return 0;
 }
 

From adcd4c06c3445e58d2b7f8fb845606839f8e3c06 Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Fri, 22 Nov 2013 21:00:52 -0500
Subject: [PATCH 0233/1866] changed std::tie to std::forward_as_tuple

---
 zip.hpp | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/zip.hpp b/zip.hpp
index 909e03f4..200a9328 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -34,9 +34,9 @@ namespace iter {
             zip_iter(const Iterator & i) :
                 iter(i){ }
 
-            auto operator*() -> decltype(std::tie(*iter))
+            auto operator*() -> decltype(std::forward_as_tuple(*iter))
             {
-                return std::tie(*iter);
+                return std::forward_as_tuple(*iter);
             }
             zip_iter & operator++() {
                 ++iter;
@@ -60,9 +60,9 @@ namespace iter {
             zip_iter(const First & f, const Second & s) :
                 iter1(f),iter2(s) { }
 
-            auto operator*() -> decltype(std::tie(*iter1,*iter2))
+            auto operator*() -> decltype(std::forward_as_tuple(*iter1,*iter2))
             {
-                return std::tie(*iter1,*iter2);
+                return std::forward_as_tuple(*iter1,*iter2);
             }
             zip_iter & operator++() {
                 ++iter1;
@@ -84,7 +84,7 @@ namespace iter {
         public:
             using elem_type = decltype(*iter);
             using tuple_type = 
-                decltype(std::tuple_cat(std::tie(*iter),*inner_iter));
+                decltype(std::tuple_cat(std::forward_as_tuple(*iter),*inner_iter));
 
             zip_iter(const First & f, const Rest & ... rest) :
                 iter(f),
@@ -93,7 +93,7 @@ namespace iter {
 
             tuple_type operator*()
             {
-                return std::tuple_cat(std::tie(*iter),*inner_iter);
+                return std::tuple_cat(std::forward_as_tuple(*iter),*inner_iter);
             }
 
             zip_iter & operator++() {

From 84d17cc4f11a220732b708ac4f5d4307f52ecc67 Mon Sep 17 00:00:00 2001
From: Aaron Josephs <ajoseph4@binghamton.edu>
Date: Fri, 22 Nov 2013 21:12:53 -0500
Subject: [PATCH 0234/1866] Fixed include in slice

---
 slice.hpp                    | 1 +
 tests/testcommand_chains.cpp | 2 ++
 2 files changed, 3 insertions(+)

diff --git a/slice.hpp b/slice.hpp
index 24b69e7c..5f1d289f 100644
--- a/slice.hpp
+++ b/slice.hpp
@@ -5,6 +5,7 @@
 
 #include <iterator>
 #include <type_traits>
+#include <initializer_list>
 
 
 namespace iter {
diff --git a/tests/testcommand_chains.cpp b/tests/testcommand_chains.cpp
index 7bc48d2d..76aca6f4 100644
--- a/tests/testcommand_chains.cpp
+++ b/tests/testcommand_chains.cpp
@@ -31,6 +31,7 @@ int main() {
         }
     }
     std::cout << std::endl;
+    /*
     {
         std::vector<int> vec1{1,2,3,4,5,6};
         std::vector<int> vec2{7,8,9,10};
@@ -41,6 +42,7 @@ int main() {
                 << std::get<1>(t) << std::endl;
         }
     }
+    */
     std::cout << std::endl;
     {
         std::vector<int> vec1{1,2,3,4,5,6};

From 04c9017b86af6b2926d5df975cfffef1b820ce11 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 22 Nov 2013 21:19:05 -0500
Subject: [PATCH 0235/1866] Adds test with temps

---
 tests/testimap.cpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/tests/testimap.cpp b/tests/testimap.cpp
index 60f8ede0..328307b0 100644
--- a/tests/testimap.cpp
+++ b/tests/testimap.cpp
@@ -1,4 +1,5 @@
 #include <imap.hpp>
+#include <range.hpp>
 
 #include <vector>
 #include <iostream>
@@ -32,5 +33,9 @@ int main() {
         std::cout << i << '\n';
     }
 
+    for (auto i : imap([] (const int x) { return x*x; }, iter::range(10))) {
+        std::cout << i << '\n';
+    }
+
     return 0;
 }

From 70ffb5471442141220cb83c13edb7238d5baee77 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 22 Nov 2013 21:21:31 -0500
Subject: [PATCH 0236/1866] Adds support for temps

---
 imap.hpp | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/imap.hpp b/imap.hpp
index 781679a9..0d3424a9 100644
--- a/imap.hpp
+++ b/imap.hpp
@@ -67,12 +67,12 @@ namespace iter {
     class IMap;
 
     template <typename MapFunc, typename... Containers>
-    IMap<MapFunc, Containers...> imap(MapFunc, Containers &...);
+    IMap<MapFunc, Containers...> imap(MapFunc, Containers &&...);
 
     template <typename MapFunc, typename... Containers>
     class IMap {
         // The imap function is the only thing allowed to create a IMap
-        friend IMap imap<MapFunc, Containers...>(MapFunc, Containers & ...);
+        friend IMap imap<MapFunc, Containers...>(MapFunc, Containers && ...);
 
         // The type returned when dereferencing the Containers...::Iterator
         // XXX depends on zip using iterator_range.  would be nice if it didn't
@@ -87,9 +87,9 @@ namespace iter {
             Zipped zipped;
             
             // Value constructor for use only in the imap function
-            IMap(MapFunc map_func, Containers & ... containers) :
+            IMap(MapFunc map_func, Containers && ... containers) :
                 map_func(map_func),
-                zipped(zip(containers...))
+                zipped(zip(std::forward<Containers>(containers)...))
             { }
             IMap () = delete;
             IMap & operator=(const IMap &) = delete;
@@ -137,8 +137,10 @@ namespace iter {
     // Helper function to instantiate a IMap
     template <typename MapFunc, typename... Containers>
     IMap<MapFunc, Containers...> imap(
-            MapFunc map_func, Containers & ... containers) {
-        return IMap<MapFunc, Containers...>(map_func, containers...);
+            MapFunc map_func, Containers && ... containers) {
+        return IMap<MapFunc, Containers...>(
+                map_func,
+                std::forward<Containers>(containers)...);
     }
 
 }

From 07ab93d5ce5d2b61f7add4b800efaeb34cc74076 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 22 Nov 2013 23:09:45 -0500
Subject: [PATCH 0237/1866] Gets rid of template specialization to allow
 correct deduction

---
 unique_everseen.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/unique_everseen.hpp b/unique_everseen.hpp
index 52632636..53250b2d 100644
--- a/unique_everseen.hpp
+++ b/unique_everseen.hpp
@@ -27,7 +27,7 @@ namespace iter
                     }
                     else return false;
                 };
-        return filter<decltype(func),Container>(func,std::forward<Container>(container));
+        return filter(func,std::forward<Container>(container));
     }
 }
 

From ef17afec48ba01bf1311b245d5cb9f05fbd1e74a Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 22 Nov 2013 23:11:07 -0500
Subject: [PATCH 0238/1866] Gets rid of template specialization to allow
 correct deduction

---
 unique_justseen.hpp | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/unique_justseen.hpp b/unique_justseen.hpp
index c50ba1e0..296c0977 100644
--- a/unique_justseen.hpp
+++ b/unique_justseen.hpp
@@ -25,8 +25,7 @@ namespace iter
                         return *(++last) != e;
                     }
                 };
-        //return filter(func,std::forward<Container>(container));
-        return filter<decltype(func),Container>(func,std::forward<Container>(container));
+        return filter(func,std::forward<Container>(container));
     }
 }
 

From 70283426b7c6b960d659c4b094461a7b6cec5ebd Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 22 Nov 2013 23:23:04 -0500
Subject: [PATCH 0239/1866] Removes include of iterbase from itertools.hpp

---
 itertools.hpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/itertools.hpp b/itertools.hpp
index 4aecb577..b5a87d5d 100644
--- a/itertools.hpp
+++ b/itertools.hpp
@@ -15,7 +15,6 @@
 #include <grouper.hpp>
 #include <imap.hpp>
 #include <iterator_range.hpp>
-#include <iterbase.hpp>
 #include <moving_section.hpp>
 #include <permutations.hpp>
 #include <powerset.hpp>

From f8807d24ef9f785779e2f01a52f8d8e66a7db473 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 24 Nov 2013 23:19:12 -0500
Subject: [PATCH 0240/1866] Adds test with temporary

---
 tests/testcompress.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/tests/testcompress.cpp b/tests/testcompress.cpp
index 76dfccaf..22da18ba 100644
--- a/tests/testcompress.cpp
+++ b/tests/testcompress.cpp
@@ -1,9 +1,11 @@
 #include <compress.hpp>
+#include <range.hpp>
 
 #include <vector>
 #include <iostream>
 
 using iter::compress;
+using iter::range;
 
 template <typename DataType, typename SelectorType>
 void testcase(std::vector<DataType> data_vec,
@@ -30,6 +32,10 @@ int main(void)
     std::cout << "Should print 2\n";
     testcase(ivec, bvec3);
 
+    for (auto i : compress(range(10), bvec)) {
+        std::cout << i << '\n';
+    }
+    
 
     return 0;
 }

From 279cd2d1aaaa7cf6bf6ade4464c22681ef8f1d13 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 24 Nov 2013 23:21:57 -0500
Subject: [PATCH 0241/1866] Adds description to temp test

---
 tests/testcompress.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tests/testcompress.cpp b/tests/testcompress.cpp
index 22da18ba..8335ad28 100644
--- a/tests/testcompress.cpp
+++ b/tests/testcompress.cpp
@@ -32,6 +32,7 @@ int main(void)
     std::cout << "Should print 2\n";
     testcase(ivec, bvec3);
 
+    std::cout << "Should print 0 2 4\n";
     for (auto i : compress(range(10), bvec)) {
         std::cout << i << '\n';
     }

From f0b958067afaeea0e9a80d68f68340f4bd0236cb Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 24 Nov 2013 23:23:12 -0500
Subject: [PATCH 0242/1866] Adds support for temporaries

---
 compress.hpp | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/compress.hpp b/compress.hpp
index ff64bb9d..20d96f45 100644
--- a/compress.hpp
+++ b/compress.hpp
@@ -3,7 +3,6 @@
 
 #include <iterbase.hpp>
 
-
 #include <utility>
 
 namespace iter {
@@ -13,7 +12,7 @@ namespace iter {
     class Compressed;
 
     template <typename Container, typename Selector>
-    Compressed<Container, Selector> compress(Container &, Selector &);
+    Compressed<Container, Selector> compress(Container &&, Selector &&);
 
 
     template <typename Container, typename Selector>
@@ -25,7 +24,7 @@ namespace iter {
             // The only thing allowed to directly instantiate an Compressed is
             // the compress function
             friend Compressed compress<Container, Selector>(
-                    Container &, Selector &);
+                    Container &&, Selector &&);
 
             using typename IterBase<Container>::contained_iter_type;
 
@@ -35,7 +34,7 @@ namespace iter {
             using selector_iter_type = decltype(std::begin(selectors));
             
             // Value constructor for use only in the compress function
-            Compressed(Container & container, Selector & selectors) :
+            Compressed(Container && container, Selector && selectors) :
                 container(container),
                 selectors(selectors)
             { }
@@ -111,8 +110,10 @@ namespace iter {
     // Helper function to instantiate an Compressed
     template <typename Container, typename Selector>
     Compressed<Container, Selector> compress(
-            Container & container, Selector & selectors) {
-        return Compressed<Container, Selector>(container, selectors);
+            Container && container, Selector && selectors) {
+        return Compressed<Container, Selector>(
+                std::forward<Container>(container),
+                std::forward<Selector>(selectors));
     }
 
 }

From 0d38735709a5fd383a89539add93e890ac96edea Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 24 Nov 2013 23:37:31 -0500
Subject: [PATCH 0243/1866] Adds test with init list for data

---
 tests/testcompress.cpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/tests/testcompress.cpp b/tests/testcompress.cpp
index 8335ad28..e6e6659f 100644
--- a/tests/testcompress.cpp
+++ b/tests/testcompress.cpp
@@ -37,6 +37,10 @@ int main(void)
         std::cout << i << '\n';
     }
     
+    std::cout << "Should print 0 2 4\n";
+    for (auto i : compress({0,1,2,3,4,5}, bvec)) {
+        std::cout << i << '\n';
+    }
 
     return 0;
 }

From 8566bcacdbb291ec7f8202ae66311f6a7be63405 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 24 Nov 2013 23:37:48 -0500
Subject: [PATCH 0244/1866] Adds support for init list for data

---
 compress.hpp | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/compress.hpp b/compress.hpp
index 20d96f45..e183e53c 100644
--- a/compress.hpp
+++ b/compress.hpp
@@ -14,6 +14,10 @@ namespace iter {
     template <typename Container, typename Selector>
     Compressed<Container, Selector> compress(Container &&, Selector &&);
 
+    template <typename T, typename Selector>
+    Compressed<std::initializer_list<T>, Selector> compress(
+            std::initializer_list<T> &&, Selector &&);
+
 
     template <typename Container, typename Selector>
     class Compressed : public IterBase<Container> {
@@ -25,6 +29,9 @@ namespace iter {
             // the compress function
             friend Compressed compress<Container, Selector>(
                     Container &&, Selector &&);
+            template <typename T, typename Sel>
+            friend Compressed<std::initializer_list<T>, Sel> compress(
+                    std::initializer_list<T> &&, Sel &&);
 
             using typename IterBase<Container>::contained_iter_type;
 
@@ -116,6 +123,13 @@ namespace iter {
                 std::forward<Selector>(selectors));
     }
 
+    template <typename T, typename Selector>
+    Compressed<std::initializer_list<T>, Selector> compress(
+            std::initializer_list<T> && il, Selector && selectors) {
+        return Compressed<std::initializer_list<T>, Selector>(
+                std::move(il),
+                std::forward<Selector>(selectors));
+    }
 }
 
 #endif //ifndef COMPRESS__H__

From 8874e18d1fa750a97b25927be0a3ebbe57b41bec Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 24 Nov 2013 23:46:54 -0500
Subject: [PATCH 0245/1866] Adds test for initlist with seletors

---
 tests/testcompress.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/tests/testcompress.cpp b/tests/testcompress.cpp
index e6e6659f..2b3f97bd 100644
--- a/tests/testcompress.cpp
+++ b/tests/testcompress.cpp
@@ -42,5 +42,11 @@ int main(void)
         std::cout << i << '\n';
     }
 
+    std::cout << "Should print 0 2 4\n";
+    for (auto i : compress(range(10), {true, false, true, false, true})) {
+        std::cout << i << '\n';
+    }
+        
+
     return 0;
 }

From 9371715a2a0b1203ec23ab05aae8959a5932f4ba Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 24 Nov 2013 23:47:12 -0500
Subject: [PATCH 0246/1866] Adds support for init list with selectors

---
 compress.hpp | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/compress.hpp b/compress.hpp
index e183e53c..e732c47e 100644
--- a/compress.hpp
+++ b/compress.hpp
@@ -4,6 +4,7 @@
 #include <iterbase.hpp>
 
 #include <utility>
+#include <initializer_list>
 
 namespace iter {
 
@@ -18,6 +19,10 @@ namespace iter {
     Compressed<std::initializer_list<T>, Selector> compress(
             std::initializer_list<T> &&, Selector &&);
 
+    template <typename Container, typename T>
+    Compressed<Container, std::initializer_list<T>> compress(
+            Container &&, std::initializer_list<T> &&);
+
 
     template <typename Container, typename Selector>
     class Compressed : public IterBase<Container> {
@@ -29,10 +34,15 @@ namespace iter {
             // the compress function
             friend Compressed compress<Container, Selector>(
                     Container &&, Selector &&);
+
             template <typename T, typename Sel>
             friend Compressed<std::initializer_list<T>, Sel> compress(
                     std::initializer_list<T> &&, Sel &&);
 
+            template <typename Con, typename T>
+            friend Compressed<Con, std::initializer_list<T>> compress(
+                    Con &&, std::initializer_list<T> &&);
+
             using typename IterBase<Container>::contained_iter_type;
 
             using typename IterBase<Container>::contained_iter_ret;
@@ -130,6 +140,14 @@ namespace iter {
                 std::move(il),
                 std::forward<Selector>(selectors));
     }
+
+    template <typename Container, typename T>
+    Compressed<Container, std::initializer_list<T>> compress(
+            Container && container, std::initializer_list<T> && il) {
+        return Compressed<Container, std::initializer_list<T>>(
+                std::forward<Container>(container),
+                std::move(il));
+    }
 }
 
 #endif //ifndef COMPRESS__H__

From a903c302922445c142c820bc130e958ca2d4e231 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 24 Nov 2013 23:56:02 -0500
Subject: [PATCH 0247/1866] Addes test for two init lists

---
 tests/testcompress.cpp | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/tests/testcompress.cpp b/tests/testcompress.cpp
index 2b3f97bd..ebbeb642 100644
--- a/tests/testcompress.cpp
+++ b/tests/testcompress.cpp
@@ -46,6 +46,13 @@ int main(void)
     for (auto i : compress(range(10), {true, false, true, false, true})) {
         std::cout << i << '\n';
     }
+
+    std::cout << "Should print 0 2 4\n";
+    for (auto i : compress({0, 1, 2, 3, 4, 5},
+                {true, false, true, false, true}))
+    {
+        std::cout << i << '\n';
+    }
         
 
     return 0;

From 7f16a658713707de13969fb69953638385288324 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 24 Nov 2013 23:56:18 -0500
Subject: [PATCH 0248/1866] Adds support for two init lists

---
 compress.hpp | 24 ++++++++++++++++++++----
 1 file changed, 20 insertions(+), 4 deletions(-)

diff --git a/compress.hpp b/compress.hpp
index e732c47e..1d3df13e 100644
--- a/compress.hpp
+++ b/compress.hpp
@@ -23,6 +23,9 @@ namespace iter {
     Compressed<Container, std::initializer_list<T>> compress(
             Container &&, std::initializer_list<T> &&);
 
+    template <typename T, typename U>
+    Compressed<std::initializer_list<T>, std::initializer_list<U>> compress(
+            std::initializer_list<T> &&, std::initializer_list<U> &&);
 
     template <typename Container, typename Selector>
     class Compressed : public IterBase<Container> {
@@ -43,6 +46,10 @@ namespace iter {
             friend Compressed<Con, std::initializer_list<T>> compress(
                     Con &&, std::initializer_list<T> &&);
 
+            template <typename T, typename U>
+            friend Compressed<std::initializer_list<T>, std::initializer_list<U>> compress(
+                    std::initializer_list<T> &&, std::initializer_list<U> &&);
+
             using typename IterBase<Container>::contained_iter_type;
 
             using typename IterBase<Container>::contained_iter_ret;
@@ -135,18 +142,27 @@ namespace iter {
 
     template <typename T, typename Selector>
     Compressed<std::initializer_list<T>, Selector> compress(
-            std::initializer_list<T> && il, Selector && selectors) {
+            std::initializer_list<T> && data, Selector && selectors) {
         return Compressed<std::initializer_list<T>, Selector>(
-                std::move(il),
+                std::move(data),
                 std::forward<Selector>(selectors));
     }
 
     template <typename Container, typename T>
     Compressed<Container, std::initializer_list<T>> compress(
-            Container && container, std::initializer_list<T> && il) {
+            Container && container, std::initializer_list<T> && selectors) {
         return Compressed<Container, std::initializer_list<T>>(
                 std::forward<Container>(container),
-                std::move(il));
+                std::move(selectors));
+    }
+
+    template <typename T, typename U>
+    Compressed<std::initializer_list<T>, std::initializer_list<U>> compress(
+            std::initializer_list<T> && data,
+            std::initializer_list<U> && selectors) {
+        return Compressed<std::initializer_list<T>, std::initializer_list<U>>(
+                std::move(data),
+                std::move(selectors));
     }
 }
 

From 105aa1d890e5337c923350cdc82dfbda73e3bbf7 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 24 Nov 2013 23:58:06 -0500
Subject: [PATCH 0249/1866] Fixes skip_failures

The check also needed to compare the current selector iterator to the
end of the selectors iterable.  The missing check was causing some
warnings in valgrind about conditional jumps on uninitialized values.
---
 compress.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/compress.hpp b/compress.hpp
index 1d3df13e..20be94d5 100644
--- a/compress.hpp
+++ b/compress.hpp
@@ -83,6 +83,7 @@ namespace iter {
 
                     void skip_failures() {
                         while (this->sub_iter != this->sub_end &&
+                               this->selector_iter != this->selector_end &&
                                 !*this->selector_iter) {
                             this->increment_iterators();
                         }

From d4f79321842dd584f799a7d51d3e066a2cdb7cac Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 25 Nov 2013 00:18:49 -0500
Subject: [PATCH 0250/1866] Replaces <> with "" for local includes

---
 chain.hpp           |  1 +
 compress.hpp        |  2 +-
 cycle.hpp           |  2 +-
 enumerate.hpp       |  2 +-
 filter.hpp          |  2 +-
 filterfalse.hpp     |  4 ++--
 groupby.hpp         |  2 +-
 grouper.hpp         |  1 +
 imap.hpp            |  2 +-
 itertools.hpp       | 58 ++++++++++++++++++++++-----------------------
 moving_section.hpp  |  1 +
 permutations.hpp    |  1 +
 powerset.hpp        |  1 +
 product.hpp         |  3 ++-
 slice.hpp           |  2 +-
 sorted.hpp          |  2 +-
 takewhile.hpp       |  2 +-
 tests/SConstruct    |  2 +-
 unique_everseen.hpp |  1 +
 unique_justseen.hpp |  1 +
 zip_longest.hpp     |  3 ++-
 21 files changed, 52 insertions(+), 43 deletions(-)

diff --git a/chain.hpp b/chain.hpp
index 2c536a27..d54b1426 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -2,6 +2,7 @@
 #define CHAIN_HPP
 
 #include "iterator_range.hpp"
+
 #include <utility>
 #include <iterator>
 
diff --git a/compress.hpp b/compress.hpp
index 20be94d5..b97db516 100644
--- a/compress.hpp
+++ b/compress.hpp
@@ -1,7 +1,7 @@
 #ifndef COMPRESS__H__
 #define COMPRESS__H__
 
-#include <iterbase.hpp>
+#include "iterbase.hpp"
 
 #include <utility>
 #include <initializer_list>
diff --git a/cycle.hpp b/cycle.hpp
index 5cce0d91..53da8619 100644
--- a/cycle.hpp
+++ b/cycle.hpp
@@ -1,7 +1,7 @@
 #ifndef CYCLE__H__
 #define CYCLE__H__
 
-#include <iterbase.hpp>
+#include "iterbase.hpp"
 
 #include <utility>
 #include <iterator>
diff --git a/enumerate.hpp b/enumerate.hpp
index 851602c9..12bf9af8 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -1,7 +1,7 @@
 #ifndef ENUMERABLE__H__
 #define ENUMERABLE__H__
 
-#include <iterbase.hpp>
+#include "iterbase.hpp"
 
 #include <utility>
 #include <iterator>
diff --git a/filter.hpp b/filter.hpp
index 75c23bc0..3e51d2d9 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -1,7 +1,7 @@
 #ifndef FILTER__H__
 #define FILTER__H__
 
-#include <iterbase.hpp>
+#include "iterbase.hpp"
 
 #include <utility>
 #include <iterator>
diff --git a/filterfalse.hpp b/filterfalse.hpp
index 4448e7d0..02c3b9b7 100644
--- a/filterfalse.hpp
+++ b/filterfalse.hpp
@@ -1,8 +1,8 @@
 #ifndef FILTER_FALSE__HPP__
 #define FILTER_FALSE__HPP__
 
-#include <iterbase.hpp>
-#include <filter.hpp>
+#include "iterbase.hpp"
+#include "filter.hpp"
 
 #include <utility>
 
diff --git a/groupby.hpp b/groupby.hpp
index 1abc2b93..e42b6755 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -1,7 +1,7 @@
 #ifndef GROUP__BY__HPP
 #define GROUP__BY__HPP
 
-#include <iterbase.hpp>
+#include "iterbase.hpp"
 
 #include <utility>
 #include <iterator>
diff --git a/grouper.hpp b/grouper.hpp
index b359ba7c..eb885e27 100644
--- a/grouper.hpp
+++ b/grouper.hpp
@@ -2,6 +2,7 @@
 #define GROUPER_HPP 
 
 #include "iterator_range.hpp"
+
 #include <vector>
 #include <algorithm>
 #include <functional>
diff --git a/imap.hpp b/imap.hpp
index 0d3424a9..ea447f81 100644
--- a/imap.hpp
+++ b/imap.hpp
@@ -1,7 +1,7 @@
 #ifndef IMAP__H__
 #define IMAP__H__
 
-#include <zip.hpp>
+#include "zip.hpp"
 
 #include <utility>
 #include <type_traits>
diff --git a/itertools.hpp b/itertools.hpp
index b5a87d5d..4129c4c7 100644
--- a/itertools.hpp
+++ b/itertools.hpp
@@ -1,35 +1,35 @@
 #ifndef ITERTOOLS_HPP
 #define ITERTOOLS_HPP
 
-#include <chain.hpp>
-#include <combinations.hpp>
-#include <combinations_with_replacement.hpp>
-#include <compress.hpp>
-#include <count.hpp>
-#include <cycle.hpp>
-#include <dropwhile.hpp>
-#include <enumerate.hpp>
-#include <filter.hpp>
-#include <filterfalse.hpp>
-#include <groupby.hpp>
-#include <grouper.hpp>
-#include <imap.hpp>
-#include <iterator_range.hpp>
-#include <moving_section.hpp>
-#include <permutations.hpp>
-#include <powerset.hpp>
-#include <product.hpp>
-#include <range.hpp>
-#include <repeat.hpp>
-#include <reverse.hpp>
-#include <slice.hpp>
-#include <sorted.hpp>
-#include <takewhile.hpp>
-#include <unique_everseen.hpp>
-#include <unique_justseen.hpp>
-#include <wrap_iter.hpp>
-#include <zip.hpp>
-#include <zip_longest.hpp>
+#include "chain.hpp"
+#include "combinations.hpp"
+#include "combinations_with_replacement.hpp"
+#include "compress.hpp"
+#include "count.hpp"
+#include "cycle.hpp"
+#include "dropwhile.hpp"
+#include "enumerate.hpp"
+#include "filter.hpp"
+#include "filterfalse.hpp"
+#include "groupby.hpp"
+#include "grouper.hpp"
+#include "imap.hpp"
+#include "iterator_range.hpp"
+#include "moving_section.hpp"
+#include "permutations.hpp"
+#include "powerset.hpp"
+#include "product.hpp"
+#include "range.hpp"
+#include "repeat.hpp"
+#include "reverse.hpp"
+#include "slice.hpp"
+#include "sorted.hpp"
+#include "takewhile.hpp"
+#include "unique_everseen.hpp"
+#include "unique_justseen.hpp"
+#include "wrap_iter.hpp"
+#include "zip.hpp"
+#include "zip_longest.hpp"
 //not sure if should include "iterator_range.hpp"
 //since it's already in everything
 
diff --git a/moving_section.hpp b/moving_section.hpp
index d4dc52f4..3ee6eb9b 100644
--- a/moving_section.hpp
+++ b/moving_section.hpp
@@ -2,6 +2,7 @@
 #define MOVING_SECTION_HPP
 
 #include "iterator_range.hpp"
+
 #include <vector>
 #include <algorithm>
 #include <functional>
diff --git a/permutations.hpp b/permutations.hpp
index d9a65e2d..1d0e4442 100644
--- a/permutations.hpp
+++ b/permutations.hpp
@@ -2,6 +2,7 @@
 #define PERMUTATIONS_HPP
 
 #include "iterator_range.hpp"
+
 #include <algorithm>
 #include <initializer_list>
 #include <vector>
diff --git a/powerset.hpp b/powerset.hpp
index 58e7cdfc..178bd756 100644
--- a/powerset.hpp
+++ b/powerset.hpp
@@ -3,6 +3,7 @@
 
 #include "iterator_range.hpp"
 #include "combinations.hpp"
+
 #include <initializer_list>
 
 namespace iter {
diff --git a/product.hpp b/product.hpp
index 42465b04..e934c362 100644
--- a/product.hpp
+++ b/product.hpp
@@ -1,9 +1,10 @@
 #ifndef PRODUCT_HPP
 #define PRODUCT_HPP
+#include "iterator_range.hpp"
+
 #include <tuple>
 #include <utility>
 #include <iterator>
-#include "iterator_range.hpp"
 
 namespace iter {
     template <typename ... Containers>
diff --git a/slice.hpp b/slice.hpp
index 5f1d289f..b6c84db0 100644
--- a/slice.hpp
+++ b/slice.hpp
@@ -1,7 +1,7 @@
 #ifndef SLICE_HPP
 #define SLICE_HPP
 
-#include <iterbase.hpp>
+#include "iterbase.hpp"
 
 #include <iterator>
 #include <type_traits>
diff --git a/sorted.hpp b/sorted.hpp
index b9b7a215..1e5cd20c 100644
--- a/sorted.hpp
+++ b/sorted.hpp
@@ -1,7 +1,7 @@
 #ifndef SORTED__HPP__
 #define SORTED__HPP__
 
-#include <iterbase.hpp>
+#include "iterbase.hpp"
 
 #include <iterator>
 #include <algorithm>
diff --git a/takewhile.hpp b/takewhile.hpp
index 8531223f..8d2b3088 100644
--- a/takewhile.hpp
+++ b/takewhile.hpp
@@ -1,7 +1,7 @@
 #ifndef TAKEWHILE__H__
 #define TAKEWHILE__H__
 
-#include <iterbase.hpp>
+#include "iterbase.hpp"
 
 #include <utility>
 #include <iterator>
diff --git a/tests/SConstruct b/tests/SConstruct
index a28500f5..835050bf 100644
--- a/tests/SConstruct
+++ b/tests/SConstruct
@@ -3,7 +3,7 @@ import os
 
 env = Environment(
     CXX='c++',
-    CXXFLAGS= ['-g',  '-Wall', '-Wextra',
+    CXXFLAGS= ['-g', '-Wall', '-Wextra',
                '-pedantic', '-std=c++11',
                '-I/usr/local/include'],
     CPPPATH='..',
diff --git a/unique_everseen.hpp b/unique_everseen.hpp
index 53250b2d..1a67f7e8 100644
--- a/unique_everseen.hpp
+++ b/unique_everseen.hpp
@@ -2,6 +2,7 @@
 #define UNIQUE_EVERSEEN_HPP
 
 #include "filter.hpp"
+
 #include <type_traits>
 #include <functional>
 #include <utility>
diff --git a/unique_justseen.hpp b/unique_justseen.hpp
index 296c0977..5729ae23 100644
--- a/unique_justseen.hpp
+++ b/unique_justseen.hpp
@@ -2,6 +2,7 @@
 #define UNIQUE_JUSTSEEN_HPP
 
 #include "filter.hpp"
+
 #include <type_traits>
 #include <functional>
 #include <utility>
diff --git a/zip_longest.hpp b/zip_longest.hpp
index 56d67e90..b81b1268 100644
--- a/zip_longest.hpp
+++ b/zip_longest.hpp
@@ -1,11 +1,12 @@
 #ifndef ZIP_LONGEST_HPP
 #define ZIP_LONGEST_HPP
 
+#include "iterator_range.hpp"
+
 #include <boost/optional.hpp>
 #include <tuple>
 #include <utility>
 #include <iterator>
-#include "iterator_range.hpp"
 
 namespace iter {
     template <typename ... Containers>

From 0db723c0a13609b1733fce8d282c4505185f7152 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 27 Nov 2013 17:10:39 -0500
Subject: [PATCH 0251/1866] Update README.md

---
 README.md | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/README.md b/README.md
index b227a8a4..20eee131 100644
--- a/README.md
+++ b/README.md
@@ -18,6 +18,7 @@ library.
 [takewhile](#takewhile)<br />
 [dropwhile](#dropwhile)<br />
 [cycle](#cycle)<br />
+[groupby](#groupby)<br />
 [compress](#compress)<br />
 [chain](#chain)<br />
 [reverse](#reverse)<br />
@@ -207,6 +208,29 @@ for (auto i : cycle(vec)) {
 }
 ```
 
+groupby
+-------
+Separate an iterable into groups sharing a common key.  The following example
+creates a new group whenever a string of a different length is encountered.
+```c++
+vector<string> vec = {
+    "hi", "ab", "ho",
+    "abc", "def",
+    "abcde", "efghi"
+};
+
+for (auto gb : groupby(vec, [] (const string &s) {return s.length(); })) {
+    cout << "key: " << gb.first << '\n';
+    cout << "content: ";
+    for (auto s : gb.second) {
+        cout << s << "  ";
+    }
+    cout << '\n';
+}
+```
+*Note*: Just like Python's `itertools.groupby`, this doesn't do any sorting.
+It just iterates through, making a new group each time there is a key change.
+Thus, the the group is unsorted, the same key may appear multiple times.
 
 zip
 ---

From 8eb4a9539d054fd82773c8c6561d9d3ae4d78a71 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 27 Nov 2013 16:14:54 -0500
Subject: [PATCH 0252/1866] Adds groupby test with lambda

---
 tests/testgroupby.cpp | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/tests/testgroupby.cpp b/tests/testgroupby.cpp
index c796e215..89aace14 100644
--- a/tests/testgroupby.cpp
+++ b/tests/testgroupby.cpp
@@ -29,6 +29,15 @@ int main()
         std::cout << '\n';
     }
 
+    for (auto gb : groupby(vec, [] (const std::string &s) {return s.length(); })) {
+        std::cout << "key: " << gb.first << '\n';
+        std::cout << "content: ";
+        for (auto s : gb.second) {
+            std::cout << s << "  ";
+        }
+        std::cout << '\n';
+    }
+
     std::cout << "skipping length of 3\n";
     for (auto gb : groupby(vec, &length)) {
         if (gb.first == 3) {

From c8b15ef6a428e7f4f0cd187265ef1641a1936104 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 14 Dec 2013 02:32:25 -0500
Subject: [PATCH 0253/1866] Moves range step check to range function

Also compresses separate Range constructors into one
---
 range.hpp | 28 ++++++++--------------------
 1 file changed, 8 insertions(+), 20 deletions(-)

diff --git a/range.hpp b/range.hpp
index 07aa655f..939487e2 100644
--- a/range.hpp
+++ b/range.hpp
@@ -22,7 +22,7 @@ namespace iter {
     // Thrown when step 0 occurs
     class RangeException : public std::exception {
         virtual const char *what() const throw() { 
-            return "Range() step argument must not be zero";
+            return "Range() step must be non-zero";
         }
     };
 
@@ -46,11 +46,6 @@ namespace iter {
             const T start; 
             const T stop;
             const T step;
-            void step_check() const throw(RangeException) {
-                if (step == 0) {
-                    throw RangeException();
-                }
-            }
 
             Range(T stop) :
                 start(0),
@@ -58,19 +53,11 @@ namespace iter {
                 step(1)
             { }
 
-            Range(T start, T stop) :
-                start(start),
-                stop(stop),
-                step(1)
-            { }
-
-            Range(T start, T stop, T step) :
+            Range(T start, T stop, T step=1) :
                 start(start),
                 stop(stop),
                 step(step)
-            {
-                this->step_check();
-            }
+            { }
 
         public:
             Range() = delete;
@@ -105,12 +92,12 @@ namespace iter {
                     // There are two odd cases that need to be handled
                     //
                     // 1) The Range is infinite, such as
-                    // Range (-1, 0, -1) which would go    forever down toward
+                    // Range (-1, 0, -1) which would go forever down toward
                     // infinitely (theoretically).  If this occurs, the Range
                     // will instead effectively be empty
                     //
                     // 2) (stop - start) % step != 0.  For
-                    // example Range(1, 10, 2).  The     iterator will never be
+                    // example Range(1, 10, 2).  The iterator will never be
                     // exactly equal to the stop value.
                     bool operator!=(const Range::Iterator & other) const {
                         return !(this->step > 0 && this->value >= other.value) 
@@ -118,7 +105,6 @@ namespace iter {
                     }
             };
 
-
             Iterator begin() const {
                 return Iterator(start, step);
             }
@@ -129,7 +115,6 @@ namespace iter {
     };
 
 
-
     template <typename T>
     Range<T> range(T stop) {
         return Range<T>(stop);
@@ -142,6 +127,9 @@ namespace iter {
 
     template <typename T>
     Range<T> range(T start, T stop, T step) {
+        if (step == 0) {
+            throw RangeException();
+        }
         return Range<T>(start, stop, step);
     }
 }

From bf417cccb6c168556e2f95a6388a4e1130bf9323 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 14 Dec 2013 02:37:11 -0500
Subject: [PATCH 0254/1866] fixes unever indents

---
 tests/SConstruct | 60 ++++++++++++++++++++++++------------------------
 1 file changed, 30 insertions(+), 30 deletions(-)

diff --git a/tests/SConstruct b/tests/SConstruct
index 835050bf..56b5aa44 100644
--- a/tests/SConstruct
+++ b/tests/SConstruct
@@ -12,36 +12,36 @@ env = Environment(
 # allows highighting to print to terminal from compiler output
 env['ENV']['TERM'] = os.environ['TERM']
 
-progs = Split( '''
-		cycle 
-		enumerate 
-		range 
-		zip 
-		slice 
-		reverse 
-		filter 
-		repeat 
-		takewhile 
-		dropwhile 
-		zip_longest 
-		product 
-		permutations 
-		compress 
-		combinations_with_replacement 
-		combinations 
-		powerset
-        moving_section
-        imap
-        count
-        filterfalse
-        grouper
-        chain
-        command_chains
-        groupby
-        sorted
-        unique_justseen
-        unique_everseen
-        ''')
+progs = Split('''
+              cycle 
+              enumerate 
+              range 
+              zip 
+              slice 
+              reverse 
+              filter 
+              repeat 
+              takewhile 
+              dropwhile 
+              zip_longest 
+              product 
+              permutations 
+              compress 
+              combinations_with_replacement 
+              combinations 
+              powerset
+              moving_section
+              imap
+              count
+              filterfalse
+              grouper
+              chain
+              command_chains
+              groupby
+              sorted
+              unique_justseen
+              unique_everseen
+              ''')
 
 
 for p in progs:

From 16f26c548fe821f429f5297c3ce19d48fc9d70f9 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 28 Dec 2013 21:13:29 -0500
Subject: [PATCH 0255/1866] Removes cycle's requirement on iterator assignment

Previously the iterator of the iterable being cycled over needed to
support assignment for when the end was reached.  This shortcoming was
exposed when cycling over a range, whose iterator has a const step data
member, and hence cannot be assigned with operator=.  Instead, the
destructor is explicitly invoked and the iterator is reconstructed using
placement new.
---
 cycle.hpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/cycle.hpp b/cycle.hpp
index 53da8619..cc120ac1 100644
--- a/cycle.hpp
+++ b/cycle.hpp
@@ -63,7 +63,9 @@ namespace iter {
                         ++this->sub_iter;
                         // reset to beginning upon reaching the end
                         if (!(this->sub_iter != this->end)) {
-                            this->sub_iter = this->begin;
+                            this->sub_iter.~contained_iter_type();
+                            new(&this->sub_iter) contained_iter_type(
+                                    this->begin);
                         }
                         return *this;
                     }

From 48b264bce7694a7939ba4edc6c04401d00434b89 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 28 Dec 2013 21:20:48 -0500
Subject: [PATCH 0256/1866] Removes operator= from range iterator

---
 range.hpp | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/range.hpp b/range.hpp
index 939487e2..02d9944b 100644
--- a/range.hpp
+++ b/range.hpp
@@ -72,11 +72,6 @@ namespace iter {
                         step(step)
                     { }
 
-                    Iterator & operator=(const Iterator &other) {
-                        this->value = other.value;
-                        return *this;
-                    }
-
                     T operator*() const {
                         return this->value;
                     }

From 8401812c445ad8dd5d7c8cfcd364ca31fd165160 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 28 Dec 2013 21:37:07 -0500
Subject: [PATCH 0257/1866] Adds comment

---
 cycle.hpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/cycle.hpp b/cycle.hpp
index cc120ac1..bb2b7abe 100644
--- a/cycle.hpp
+++ b/cycle.hpp
@@ -63,6 +63,8 @@ namespace iter {
                         ++this->sub_iter;
                         // reset to beginning upon reaching the end
                         if (!(this->sub_iter != this->end)) {
+                            // explicit destruction with placement new in order
+                            // to support iterators with no operator=
                             this->sub_iter.~contained_iter_type();
                             new(&this->sub_iter) contained_iter_type(
                                     this->begin);

From e0f1c34d483ef095039fb40386b6cea944b8b3b2 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 28 Dec 2013 21:37:20 -0500
Subject: [PATCH 0258/1866] Removes requirement on iterator having operator=

---
 takewhile.hpp | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/takewhile.hpp b/takewhile.hpp
index 8d2b3088..3670cff2 100644
--- a/takewhile.hpp
+++ b/takewhile.hpp
@@ -55,11 +55,15 @@ namespace iter {
                     const contained_iter_type sub_end;
                     FilterFunc filter_func;
 
-                    // increment until the iterator points to is true on the 
-                    // predicate.  Called by constructor and operator++
+                    // check if the current value is true under the predicate
+                    // if it is not, set the sub_iter to the end using
+                    // placement new to avoid the requirement of the iterator
+                    // having an operator=
                     void check_current() {
                         if (!this->filter_func(*this->sub_iter)) {
-                            this->sub_iter = this->sub_end;
+                            this->sub_iter.~contained_iter_type();
+                            new(&this->sub_iter) contained_iter_type(
+                                    this->sub_end);
                         }
                     }
 

From aff5621ab2b5f36142bd27ae2cdf292e8c8aafac Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 28 Dec 2013 21:50:25 -0500
Subject: [PATCH 0259/1866] Fixes memory error in takewhile

check_current was being called in the constructor on each
Iterator creation, thus when an end iterator was created, the end was
being checked against the predicate which was one passed the end.
The fix checks for end before doing the check in the constructor.
---
 takewhile.hpp | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/takewhile.hpp b/takewhile.hpp
index 3670cff2..58ca4bd3 100644
--- a/takewhile.hpp
+++ b/takewhile.hpp
@@ -75,7 +75,10 @@ namespace iter {
                         sub_end(end),
                         filter_func(filter_func)
                     { 
-                        this->check_current();
+                        if (this->sub_iter != this->sub_end) {
+                            // only do the check if not already at the end
+                            this->check_current();
+                        }
                     } 
 
                     contained_iter_ret operator*() const {

From 428dce969db8dc454339b530fd82e773846b17ec Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 8 Jan 2014 16:07:29 -0500
Subject: [PATCH 0260/1866] replaces throw() with noexcept

---
 range.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/range.hpp b/range.hpp
index 02d9944b..175f3bac 100644
--- a/range.hpp
+++ b/range.hpp
@@ -21,8 +21,8 @@ namespace iter {
 
     // Thrown when step 0 occurs
     class RangeException : public std::exception {
-        virtual const char *what() const throw() { 
-            return "Range() step must be non-zero";
+        virtual const char *what() const noexcept { 
+            return "range step must be non-zero";
         }
     };
 

From 51b126693fada8a4118fd9cf7eb2972b30beb6d3 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 8 Jan 2014 16:08:28 -0500
Subject: [PATCH 0261/1866] attempts to flatten enumerate

---
 enumerate.hpp | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index 12bf9af8..5868c92b 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -32,7 +32,7 @@ namespace iter {
     Enumerable<Container> enumerate(Container &&);
 
     template <typename Container>
-    class Enumerable : public IterBase<Container>{
+    class Enumerable {
         private:
             Container & container;
 
@@ -43,9 +43,7 @@ namespace iter {
             friend Enumerable<std::initializer_list<T>> enumerate(
                     std::initializer_list<T> &&);
 
-            using typename IterBase<Container>::contained_iter_type;
-
-            using typename IterBase<Container>::contained_iter_ret;
+            using IterDef = IterBase<Container>;
 
             Enumerable(Container && container) : container(container) { }
             
@@ -61,8 +59,8 @@ namespace iter {
             class IterYield {
                 public:
                     std::size_t index;
-                    contained_iter_ret element;
-                    IterYield(std::size_t i, contained_iter_ret elem) : 
+                    typename IterDef::contained_iter_ret element;
+                    IterYield(std::size_t i, typename IterDef::contained_iter_ret elem): 
                         index(i),
                         element(elem)
                     { }
@@ -73,10 +71,10 @@ namespace iter {
             //  Each dereference returns an IterYield.
             class Iterator {
                 private:
-                    contained_iter_type sub_iter;
+                    typename IterDef::contained_iter_type sub_iter;
                     std::size_t index;
                 public:
-                    Iterator (contained_iter_type si) :
+                    Iterator (typename IterDef::contained_iter_type si) :
                         sub_iter(si),
                         index(0) { } 
 

From 4d797e34e8b7b42d97d2c394ba6a7fbe916933e2 Mon Sep 17 00:00:00 2001
From: Ben Jones <ben.james.jones@gmail.com>
Date: Wed, 8 Jan 2014 15:34:17 -0700
Subject: [PATCH 0262/1866] added specialization of range w/ unsigned types

---
 range.hpp           | 15 +++++++++++----
 tests/testrange.cpp | 25 +++++++++++++++++++++++++
 2 files changed, 36 insertions(+), 4 deletions(-)

diff --git a/range.hpp b/range.hpp
index 175f3bac..15e27ec8 100644
--- a/range.hpp
+++ b/range.hpp
@@ -94,10 +94,17 @@ namespace iter {
                     // 2) (stop - start) % step != 0.  For
                     // example Range(1, 10, 2).  The iterator will never be
                     // exactly equal to the stop value.
-                    bool operator!=(const Range::Iterator & other) const {
-                        return !(this->step > 0 && this->value >= other.value) 
-                            && !(this->step < 0 && this->value <= other.value);
-                    }
+                    bool operator!=(const Range::Iterator & other) const { 
+				         return not_equal_to(other, typename std::is_unsigned<T>::type());
+			        }
+			  private:
+			        bool not_equal_to(const Range::Iterator& other, std::true_type /*unsigned*/) const{
+					     return this->value < other.value;
+			        }
+			        bool not_equal_to(const Range::Iterator& other, std::false_type /*signed*/) const{
+					     return !(this->step > 0 && this->value >= other.value) 
+						   && !(this->step < 0 && this->value <= other.value);
+			        }
             };
 
             Iterator begin() const {
diff --git a/tests/testrange.cpp b/tests/testrange.cpp
index fd7a294f..9404ae57 100644
--- a/tests/testrange.cpp
+++ b/tests/testrange.cpp
@@ -38,6 +38,31 @@ int main()
     for(auto i : range(5.0, 10.0, 0.5)) {
         std::cout << i << std::endl;
     }
+	std::cout << "test unsigned" << std::endl;
+	std::cout << "empty range: " << std::endl;
+	size_t len = 0;
+	for(auto i : range(len)){
+	  std::cout << i << std::endl;
+	}
+	std::cout << "stop only" << std::endl;
+	len = 3;
+	for(auto i : range(len)){
+	  std::cout << i << std::endl;
+	}
+	std::cout << "start stop" << std::endl;
+	size_t start = 1;
+	for(auto i : range(start, len)){
+	  std::cout << i << std::endl;
+	}
+
+	std::cout << "start stop skip" << std::endl;
+	len = 10;
+	size_t skip = 3;
+	for(auto i : range(start, len, skip)){
+	  std::cout << i << std::endl;
+	}
+	
+
 
     // invalid ranges:
     std::cout << "Should not print anything after this line until exception\n";

From b88e7e5749fcfea0295e90854f1592701cc29799 Mon Sep 17 00:00:00 2001
From: Ben Jones <ben.james.jones@gmail.com>
Date: Sat, 11 Jan 2014 18:15:19 -0700
Subject: [PATCH 0263/1866] added include for type_traits

---
 range.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/range.hpp b/range.hpp
index 15e27ec8..c570ad34 100644
--- a/range.hpp
+++ b/range.hpp
@@ -16,6 +16,7 @@
 // If a step of 0 is provided, a RangeException will be thrown
 
 #include <exception>
+#include <type_traits>
 
 namespace iter {
 

From b53cd56724059fa392083fa2f0ab1d0fd58ba634 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 12 Jan 2014 12:06:38 -0500
Subject: [PATCH 0264/1866] Formatting

---
 range.hpp | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/range.hpp b/range.hpp
index c570ad34..70b57966 100644
--- a/range.hpp
+++ b/range.hpp
@@ -67,6 +67,14 @@ namespace iter {
                 private:
                     T value;
                     const T step;
+
+                    bool not_equal_to(const Range::Iterator& other, std::true_type /*unsigned*/) const{
+                        return this->value < other.value;
+                    }
+                    bool not_equal_to(const Range::Iterator& other, std::false_type /*signed*/) const{
+                        return !(this->step > 0 && this->value >= other.value) 
+                            && !(this->step < 0 && this->value <= other.value);
+                    }
                 public:
                     Iterator(T val, T step) :
                         value(val),
@@ -96,16 +104,8 @@ namespace iter {
                     // example Range(1, 10, 2).  The iterator will never be
                     // exactly equal to the stop value.
                     bool operator!=(const Range::Iterator & other) const { 
-				         return not_equal_to(other, typename std::is_unsigned<T>::type());
-			        }
-			  private:
-			        bool not_equal_to(const Range::Iterator& other, std::true_type /*unsigned*/) const{
-					     return this->value < other.value;
-			        }
-			        bool not_equal_to(const Range::Iterator& other, std::false_type /*signed*/) const{
-					     return !(this->step > 0 && this->value >= other.value) 
-						   && !(this->step < 0 && this->value <= other.value);
-			        }
+                        return not_equal_to(other, typename std::is_unsigned<T>::type());
+                    }
             };
 
             Iterator begin() const {

From ff3b45be5de3ad5691e2f09ff8132030007643a4 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 12 Jan 2014 12:07:04 -0500
Subject: [PATCH 0265/1866] removes leading underscores from include guard

---
 range.hpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/range.hpp b/range.hpp
index 70b57966..62ec6362 100644
--- a/range.hpp
+++ b/range.hpp
@@ -1,5 +1,5 @@
-#ifndef __RANGE__H__
-#define __RANGE__H__
+#ifndef RANGE__H__
+#define RANGE__H__
 
 // range() for range-based loops with start, stop, and step.
 //
@@ -137,4 +137,4 @@ namespace iter {
     }
 }
 
-#endif //ifndef __RANGE__H__
+#endif //ifndef RANGE__H__

From 789458e34c0d53dc27f666c52b0a890b18209504 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 12 Jan 2014 12:16:26 -0500
Subject: [PATCH 0266/1866] flattens with explicit using

---
 enumerate.hpp | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index 5868c92b..84a9a1cb 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -43,7 +43,10 @@ namespace iter {
             friend Enumerable<std::initializer_list<T>> enumerate(
                     std::initializer_list<T> &&);
 
-            using IterDef = IterBase<Container>;
+            using contained_iter_ret =
+                typename IterBase<Container>::contained_iter_ret;
+            using contained_iter_type =
+                typename IterBase<Container>::contained_iter_type;
 
             Enumerable(Container && container) : container(container) { }
             
@@ -59,8 +62,8 @@ namespace iter {
             class IterYield {
                 public:
                     std::size_t index;
-                    typename IterDef::contained_iter_ret element;
-                    IterYield(std::size_t i, typename IterDef::contained_iter_ret elem): 
+                    contained_iter_ret element;
+                    IterYield(std::size_t i, contained_iter_ret elem): 
                         index(i),
                         element(elem)
                     { }
@@ -71,10 +74,10 @@ namespace iter {
             //  Each dereference returns an IterYield.
             class Iterator {
                 private:
-                    typename IterDef::contained_iter_type sub_iter;
+                    contained_iter_type sub_iter;
                     std::size_t index;
                 public:
-                    Iterator (typename IterDef::contained_iter_type si) :
+                    Iterator (contained_iter_type si) :
                         sub_iter(si),
                         index(0) { } 
 

From f55c4be1b64c4a8ae7249ef70b1ea4c963b27c0f Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 12 Jan 2014 14:27:22 -0500
Subject: [PATCH 0267/1866] Removes IterBase in favor of templated usings

---
 iterbase.hpp | 30 +++++++++++++++---------------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/iterbase.hpp b/iterbase.hpp
index 55936753..a0429cbd 100644
--- a/iterbase.hpp
+++ b/iterbase.hpp
@@ -1,26 +1,26 @@
 #ifndef ITERBASE__HPP__
 #define ITERBASE__HPP__
 
+
+// This file consists of utilities used for the generic nature of the
+// iterable wrapper classes.  As such, the contents of this file should be
+// considered UNDOCUMENTED and is subject to change without warning.  This
+// also applies to the name of the file
+
 #include <utility>
 #include <iterator>
 
 namespace iter {
-    template <typename Iterable>
-    class IterBase{
-        public:
-            // Type of the Container::Iterator, but since the name of that 
-            // iterator can be anything, we have to grab it with this
-            using contained_iter_type =
-                decltype(std::begin(std::declval<Iterable&>()));
+    // iterator_type<C> is the type of C's iterator
+    template <typename Container>
+    using iterator_type =
+        decltype(std::begin(std::declval<Container&>()));
 
-            // The type returned when dereferencing the Container::Iterator
-            using contained_iter_ret =
-                decltype(*std::declval<contained_iter_type&>());
-            
-            IterBase() = default;
-            IterBase(const IterBase &) = default;
-            IterBase & operator=(const IterBase &) = delete;
-    };
+    // iterator_deref<C> is the type obtained by dereferencing an iterator
+    // to an object of type C
+    template <typename Container>
+    using iterator_deref = 
+        decltype(*std::declval<iterator_type<Container>&>());
 }
 
 #endif // #ifndef ITERBASE__HPP__

From 97e9825223501340816c16fb0debdbcee299efc8 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 12 Jan 2014 14:47:48 -0500
Subject: [PATCH 0268/1866] compress uses new type aliases

---
 compress.hpp | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/compress.hpp b/compress.hpp
index b97db516..11cb1720 100644
--- a/compress.hpp
+++ b/compress.hpp
@@ -28,7 +28,7 @@ namespace iter {
             std::initializer_list<T> &&, std::initializer_list<U> &&);
 
     template <typename Container, typename Selector>
-    class Compressed : public IterBase<Container> {
+    class Compressed  {
         private:
             Container & container;
             Selector & selectors;
@@ -50,9 +50,9 @@ namespace iter {
             friend Compressed<std::initializer_list<T>, std::initializer_list<U>> compress(
                     std::initializer_list<T> &&, std::initializer_list<U> &&);
 
-            using typename IterBase<Container>::contained_iter_type;
+            
 
-            using typename IterBase<Container>::contained_iter_ret;
+            
 
             // Selector::Iterator type
             using selector_iter_type = decltype(std::begin(selectors));
@@ -70,8 +70,8 @@ namespace iter {
 
             class Iterator {
                 private:
-                    contained_iter_type sub_iter;
-                    const contained_iter_type sub_end;
+                    iterator_type<Container> sub_iter;
+                    const iterator_type<Container> sub_end;
 
                     selector_iter_type selector_iter;
                     const selector_iter_type selector_end;
@@ -90,8 +90,8 @@ namespace iter {
                     }
 
                 public:
-                    Iterator (contained_iter_type cont_iter,
-                              contained_iter_type cont_end,
+                    Iterator (iterator_type<Container> cont_iter,
+                              iterator_type<Container> cont_end,
                               selector_iter_type sel_iter,
                               selector_iter_type sel_end) :
                         sub_iter(cont_iter),
@@ -102,7 +102,7 @@ namespace iter {
                         this->skip_failures();
                     } 
 
-                    contained_iter_ret operator*() const {
+                    iterator_deref<Container> operator*() const {
                         return *this->sub_iter;
                     }
 

From 0c51a4415df3ac99ab0401e7845d22cd719258ee Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 12 Jan 2014 14:47:58 -0500
Subject: [PATCH 0269/1866] cycle uses new type aliases

---
 cycle.hpp | 23 ++++++++++++-----------
 1 file changed, 12 insertions(+), 11 deletions(-)

diff --git a/cycle.hpp b/cycle.hpp
index bb2b7abe..20be700b 100644
--- a/cycle.hpp
+++ b/cycle.hpp
@@ -21,7 +21,7 @@ namespace iter {
             std::initializer_list<T> &&);
 
     template <typename Container>
-    class Cycle : public IterBase<Container>{
+    class Cycle {
         private:
             // The cycle function is the only thing allowed to create a Cycle
             friend Cycle cycle<Container>(Container &&);
@@ -29,9 +29,9 @@ namespace iter {
             friend Cycle<std::initializer_list<T>> cycle(
                     std::initializer_list<T> &&);
 
-            using typename IterBase<Container>::contained_iter_type;
+            
 
-            using typename IterBase<Container>::contained_iter_ret;
+            
 
             Container & container;
             
@@ -44,18 +44,19 @@ namespace iter {
             Cycle(const Cycle &) = default;
             class Iterator {
                 private:
-                    contained_iter_type sub_iter;
-                    const contained_iter_type begin;
-                    const contained_iter_type end;
+                    using iter_type = iterator_type<Container>;
+                    iterator_type<Container> sub_iter;
+                    const iterator_type<Container> begin;
+                    const iterator_type<Container> end;
                 public:
-                    Iterator (contained_iter_type iter,
-                            contained_iter_type end) :
+                    Iterator (iterator_type<Container> iter,
+                            iterator_type<Container> end) :
                         sub_iter(iter),
                         begin(iter),
                         end(end)
                     { } 
 
-                    contained_iter_ret operator*() const {
+                    iterator_deref<Container> operator*() const {
                         return *this->sub_iter;
                     }
 
@@ -65,8 +66,8 @@ namespace iter {
                         if (!(this->sub_iter != this->end)) {
                             // explicit destruction with placement new in order
                             // to support iterators with no operator=
-                            this->sub_iter.~contained_iter_type();
-                            new(&this->sub_iter) contained_iter_type(
+                            this->sub_iter.~iter_type();
+                            new(&this->sub_iter) iterator_type<Container>(
                                     this->begin);
                         }
                         return *this;

From 020c86056f6051f39a27a091df48175bba942247 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 12 Jan 2014 14:48:20 -0500
Subject: [PATCH 0270/1866] dropwhile uses new type aliases

---
 dropwhile.hpp | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/dropwhile.hpp b/dropwhile.hpp
index 1f13efc9..626ac733 100644
--- a/dropwhile.hpp
+++ b/dropwhile.hpp
@@ -21,7 +21,7 @@ namespace iter {
             FilterFunc, std::initializer_list<T> &&);
 
     template <typename FilterFunc, typename Container>
-    class DropWhile : IterBase<Container> {
+    class DropWhile  {
         private:
             Container & container;
             FilterFunc filter_func;
@@ -33,9 +33,9 @@ namespace iter {
             friend DropWhile<FF, std::initializer_list<T>> dropwhile(
                     FF, std::initializer_list<T> &&);
 
-            using typename IterBase<Container>::contained_iter_type;
+            
 
-            using typename IterBase<Container>::contained_iter_ret;
+            
 
             
             // Value constructor for use only in the dropwhile function
@@ -50,8 +50,8 @@ namespace iter {
             DropWhile(const DropWhile &) = default;
             class Iterator {
                 private:
-                    contained_iter_type sub_iter;
-                    const contained_iter_type sub_end;
+                    iterator_type<Container> sub_iter;
+                    const iterator_type<Container> sub_end;
                     FilterFunc filter_func;
 
                     // skip all values for which the predicate is true
@@ -63,8 +63,8 @@ namespace iter {
                     }
 
                 public:
-                    Iterator (contained_iter_type iter,
-                            contained_iter_type end,
+                    Iterator (iterator_type<Container> iter,
+                            iterator_type<Container> end,
                             FilterFunc filter_func) :
                         sub_iter(iter),
                         sub_end(end),
@@ -73,7 +73,7 @@ namespace iter {
                         this->skip_passes();
                     } 
 
-                    contained_iter_ret operator*() const {
+                    iterator_deref<Container> operator*() const {
                         return *this->sub_iter;
                     }
 

From f0f6378f234bb3b97bfb4628657362ac1961b403 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 12 Jan 2014 14:48:28 -0500
Subject: [PATCH 0271/1866] enumerate uses new type aliases

---
 enumerate.hpp | 13 ++++---------
 1 file changed, 4 insertions(+), 9 deletions(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index 84a9a1cb..2bb5f806 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -43,11 +43,6 @@ namespace iter {
             friend Enumerable<std::initializer_list<T>> enumerate(
                     std::initializer_list<T> &&);
 
-            using contained_iter_ret =
-                typename IterBase<Container>::contained_iter_ret;
-            using contained_iter_type =
-                typename IterBase<Container>::contained_iter_type;
-
             Enumerable(Container && container) : container(container) { }
             
         public:
@@ -62,8 +57,8 @@ namespace iter {
             class IterYield {
                 public:
                     std::size_t index;
-                    contained_iter_ret element;
-                    IterYield(std::size_t i, contained_iter_ret elem): 
+                    iterator_deref<Container> element;
+                    IterYield(std::size_t i, iterator_deref<Container> elem): 
                         index(i),
                         element(elem)
                     { }
@@ -74,10 +69,10 @@ namespace iter {
             //  Each dereference returns an IterYield.
             class Iterator {
                 private:
-                    contained_iter_type sub_iter;
+                    iterator_type<Container> sub_iter;
                     std::size_t index;
                 public:
-                    Iterator (contained_iter_type si) :
+                    Iterator (iterator_type<Container> si) :
                         sub_iter(si),
                         index(0) { } 
 

From 86e8753705020e41f5aecb5f07f7ed2215dad108 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 12 Jan 2014 14:48:37 -0500
Subject: [PATCH 0272/1866] filter uses new type aliases

---
 filter.hpp | 22 +++++++++-------------
 1 file changed, 9 insertions(+), 13 deletions(-)

diff --git a/filter.hpp b/filter.hpp
index 3e51d2d9..2decb950 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -21,7 +21,7 @@ namespace iter {
             FilterFunc, std::initializer_list<T> &&);
 
     template <typename FilterFunc, typename Container>
-    class Filter : IterBase<Container>{
+    class Filter {
         private:
             Container & container;
             FilterFunc filter_func;
@@ -33,9 +33,9 @@ namespace iter {
             template <typename FF, typename T>
             friend Filter<FF, std::initializer_list<T>> filter(
                     FF, std::initializer_list<T> &&);
-            using typename IterBase<Container>::contained_iter_type;
+            
 
-            using typename IterBase<Container>::contained_iter_ret;
+            
             
             // Value constructor for use only in the filter function
             Filter(FilterFunc filter_func, Container && container) :
@@ -50,8 +50,8 @@ namespace iter {
 
             class Iterator {
                 protected:
-                    contained_iter_type sub_iter;
-                    const contained_iter_type sub_end;
+                    iterator_type<Container> sub_iter;
+                    const iterator_type<Container> sub_end;
                     FilterFunc filter_func;
 
                     // increment until the iterator points to is true on the 
@@ -64,8 +64,8 @@ namespace iter {
                     }
 
                 public:
-                    Iterator (contained_iter_type iter,
-                            contained_iter_type end,
+                    Iterator (iterator_type<Container> iter,
+                            iterator_type<Container> end,
                             FilterFunc filter_func) :
                         sub_iter(iter),
                         sub_end(end),
@@ -74,7 +74,7 @@ namespace iter {
                         this->skip_failures();
                     } 
 
-                    contained_iter_ret operator*() const {
+                    iterator_deref<Container> operator*() const {
                         return *this->sub_iter;
                     }
 
@@ -131,12 +131,8 @@ namespace iter {
 
         template <typename Container>
         class BoolTester {
-            protected:
-                using contained_iter_ret =
-                    typename IterBase<Container>::contained_iter_ret;
-
             public:
-                bool operator() (const contained_iter_ret item) const {
+                bool operator() (const iterator_deref<Container> item) const {
                     return bool(item);
                 }
         };

From 63c1f8d44a859d3f610787fbaaa1ef1f884b76e1 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 12 Jan 2014 14:48:49 -0500
Subject: [PATCH 0273/1866] filterfalse uses new type aliases

---
 filterfalse.hpp | 13 +++----------
 1 file changed, 3 insertions(+), 10 deletions(-)

diff --git a/filterfalse.hpp b/filterfalse.hpp
index 02c3b9b7..dfd2716c 100644
--- a/filterfalse.hpp
+++ b/filterfalse.hpp
@@ -17,9 +17,6 @@ namespace iter {
             private:
                 FilterFunc filter_func;
 
-                using contained_iter_ret =
-                    typename IterBase<Container>::contained_iter_ret;
-
             public:
                 PredicateFlipper(FilterFunc filter_func) :
                     filter_func(filter_func)
@@ -29,7 +26,7 @@ namespace iter {
                 PredicateFlipper(const PredicateFlipper &) = default;
 
                 // Calls the filter_func 
-                bool operator() (const contained_iter_ret item) const {
+                bool operator() (const iterator_deref<Container> item) const {
                     return !bool(filter_func(item));
                 }
         };
@@ -37,13 +34,9 @@ namespace iter {
         // Reverses the bool() conversion result of anything that supports a
         // bool conversion
         template <typename Container>
-        class BoolFlipper : public BoolTester<Container> {
-            private:
-                using contained_iter_ret = 
-                    typename BoolTester<Container>::contained_iter_ret;
-
+        class BoolFlipper {
             public:
-                bool operator() (const contained_iter_ret item) const {
+                bool operator() (const iterator_deref<Container> item) const {
                     return !bool(item);
                 }
         };

From 5e323d44dd62a176affa5a10845b32c8c8983222 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 12 Jan 2014 14:49:05 -0500
Subject: [PATCH 0274/1866] groupby uses new type aliases

---
 groupby.hpp | 28 +++++++++++++---------------
 1 file changed, 13 insertions(+), 15 deletions(-)

diff --git a/groupby.hpp b/groupby.hpp
index e42b6755..ed6fe0d0 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -20,7 +20,7 @@ namespace iter {
             std::initializer_list<T> &&, KeyFunc);
 
     template <typename Container, typename KeyFunc>
-    class GroupBy : IterBase<Container> {
+    class GroupBy  {
         private:
             Container & container;
             KeyFunc key_func;
@@ -31,13 +31,13 @@ namespace iter {
             friend GroupBy<std::initializer_list<T>, KF> groupby(
                     std::initializer_list<T> &&, KF);
 
-            using typename IterBase<Container>::contained_iter_type;
+            
 
-            using typename IterBase<Container>::contained_iter_ret;
+            
 
             using key_func_ret =
                 decltype(std::declval<KeyFunc>()(
-                            std::declval<contained_iter_ret>()));
+                            std::declval<iterator_deref<Container>>()));
 
             GroupBy(Container && container, KeyFunc key_func) :
                 container(container),
@@ -57,17 +57,17 @@ namespace iter {
 
             class Iterator {
                 private:
-                    contained_iter_type sub_iter;
-                    contained_iter_type sub_iter_peek;
-                    const contained_iter_type sub_end;
+                    iterator_type<Container> sub_iter;
+                    iterator_type<Container> sub_iter_peek;
+                    const iterator_type<Container> sub_end;
                     KeyFunc key_func;
 
                     using KeyGroupPair =
                         std::pair<key_func_ret, Group>;
 
                 public:
-                    Iterator (contained_iter_type si,
-                              contained_iter_type end,
+                    Iterator (iterator_type<Container> si,
+                              iterator_type<Container> end,
                               KeyFunc key_func) :
                         sub_iter(si),
                         sub_end(end),
@@ -100,7 +100,7 @@ namespace iter {
                         return this->sub_iter == this->sub_end;
                     }
 
-                    contained_iter_ret current() const {
+                    iterator_deref<Container> current() const {
                         return *this->sub_iter;
                     }
 
@@ -188,7 +188,7 @@ namespace iter {
                                 return *this;
                             }
 
-                            contained_iter_ret operator*() const {
+                            iterator_deref<Container> operator*() const {
                                 return this->group.owner.current();
                             }
                     };
@@ -224,12 +224,10 @@ namespace iter {
     // items in the sequence directly
     template <typename Container>
     class ItemReturner {
-        private:
-            using contained_iter_ret =
-                typename IterBase<Container>::contained_iter_ret;
         public:
             ItemReturner() = default;
-            contained_iter_ret operator() (contained_iter_ret item) const {
+            iterator_deref<Container> operator() (
+                    iterator_deref<Container> item) const {
                 return item;
             }
     };

From b504566e11bcab2d7e312fdbb2acfdbb21b36859 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 12 Jan 2014 14:49:22 -0500
Subject: [PATCH 0275/1866] slice uses new type aliases

---
 slice.hpp | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/slice.hpp b/slice.hpp
index b6c84db0..2415225e 100644
--- a/slice.hpp
+++ b/slice.hpp
@@ -52,7 +52,7 @@ namespace iter {
 
 
     template <typename Container, typename DifferenceType>
-    class Slice : public IterBase<Container>{
+    class Slice {
         private:
             Container & container;
             DifferenceType start;
@@ -65,9 +65,9 @@ namespace iter {
             //template <typename T>
             //friend Slice<std::initializer_list<T>> slice(std::initializer_list<T> &&);
 
-            using typename IterBase<Container>::contained_iter_type;
+            
 
-            using typename IterBase<Container>::contained_iter_ret;
+            
 
             
         public:
@@ -99,13 +99,13 @@ namespace iter {
 
             class Iterator {
                 private:
-                    contained_iter_type sub_iter;
+                    iterator_type<Container> sub_iter;
                     DifferenceType current;
                     const DifferenceType stop;
                     const DifferenceType step;
 
                 public:
-                    Iterator (contained_iter_type si, DifferenceType start,
+                    Iterator (iterator_type<Container> si, DifferenceType start,
                             DifferenceType stop, DifferenceType step) :
                         sub_iter(si),
                         current(start),
@@ -113,7 +113,7 @@ namespace iter {
                         step(step)
                     { }
 
-                    contained_iter_ret operator*() const {
+                    iterator_deref<Container> operator*() const {
                         return *this->sub_iter;
                     }
 

From 8081dd37532535a5043e141c192a5979bb1e33e8 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 12 Jan 2014 14:49:30 -0500
Subject: [PATCH 0276/1866] sorted uses new type aliases

---
 sorted.hpp | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/sorted.hpp b/sorted.hpp
index 1e5cd20c..6a0c518a 100644
--- a/sorted.hpp
+++ b/sorted.hpp
@@ -15,16 +15,16 @@ namespace iter {
     Sorted<Container, CompareFunc> sorted(Container &, CompareFunc);
 
     template <typename Container, typename CompareFunc>
-    class Sorted : IterBase<Container> {
+    class Sorted  {
         private:
             friend Sorted
                 sorted<Container, CompareFunc>(Container &, CompareFunc);
 
-            using typename IterBase<Container>::contained_iter_type;
+            
 
-            using typename IterBase<Container>::contained_iter_ret;
+            
 
-            std::vector<contained_iter_type> sorted_iters;
+            std::vector<iterator_type<Container>> sorted_iters;
 
             using sorted_iter_type = decltype(std::begin(sorted_iters));
 
@@ -42,8 +42,8 @@ namespace iter {
 
                 // sort by comparing the elements that the iterators point to
                 std::sort(std::begin(sorted_iters), std::end(sorted_iters),
-                        [&] (const contained_iter_type & it1,
-                            const contained_iter_type & it2)
+                        [&] (const iterator_type<Container> & it1,
+                            const iterator_type<Container> & it2)
                         { return compare_func(*it1, *it2); });
             }
 
@@ -61,7 +61,7 @@ namespace iter {
                     IteratorIterator(const IteratorIterator &) = default;
 
                     // Dereference the current iterator before returning
-                    contained_iter_ret operator*() {
+                    iterator_deref<Container> operator*() {
                         return *sorted_iter_type::operator*();
                     }
             };

From 5b34bcae027b783136f72513fed084cf24baaf9a Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 12 Jan 2014 14:49:42 -0500
Subject: [PATCH 0277/1866] takewhile uses new type aliases

---
 takewhile.hpp | 21 +++++++++++----------
 1 file changed, 11 insertions(+), 10 deletions(-)

diff --git a/takewhile.hpp b/takewhile.hpp
index 58ca4bd3..caf135d3 100644
--- a/takewhile.hpp
+++ b/takewhile.hpp
@@ -21,7 +21,7 @@ namespace iter {
             FilterFunc, std::initializer_list<T> &&);
 
     template <typename FilterFunc, typename Container>
-    class TakeWhile : IterBase<Container>{
+    class TakeWhile {
         private:
             Container & container;
             FilterFunc filter_func;
@@ -33,9 +33,9 @@ namespace iter {
             friend TakeWhile<FF, std::initializer_list<T>> takewhile(
                     FF, std::initializer_list<T> &&);
 
-            using typename IterBase<Container>::contained_iter_type;
+            
 
-            using typename IterBase<Container>::contained_iter_ret;
+            
 
             // Value constructor for use only in the takewhile function
             TakeWhile(FilterFunc filter_func, Container && container) :
@@ -51,8 +51,9 @@ namespace iter {
 
             class Iterator {
                 private:
-                    contained_iter_type sub_iter;
-                    const contained_iter_type sub_end;
+                    using iter_type = iterator_type<Container>;
+                    iterator_type<Container> sub_iter;
+                    const iterator_type<Container> sub_end;
                     FilterFunc filter_func;
 
                     // check if the current value is true under the predicate
@@ -61,15 +62,15 @@ namespace iter {
                     // having an operator=
                     void check_current() {
                         if (!this->filter_func(*this->sub_iter)) {
-                            this->sub_iter.~contained_iter_type();
-                            new(&this->sub_iter) contained_iter_type(
+                            this->sub_iter.~iter_type();
+                            new(&this->sub_iter) iterator_type<Container>(
                                     this->sub_end);
                         }
                     }
 
                 public:
-                    Iterator (contained_iter_type iter,
-                            contained_iter_type end,
+                    Iterator (iterator_type<Container> iter,
+                            iterator_type<Container> end,
                             FilterFunc filter_func) :
                         sub_iter(iter),
                         sub_end(end),
@@ -81,7 +82,7 @@ namespace iter {
                         }
                     } 
 
-                    contained_iter_ret operator*() const {
+                    iterator_deref<Container> operator*() const {
                         return *this->sub_iter;
                     }
 

From 60936e99c381d9b82c89f7d447f2e367f1fb7548 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 12 Jan 2014 14:50:01 -0500
Subject: [PATCH 0278/1866] comments expanded

---
 iterbase.hpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/iterbase.hpp b/iterbase.hpp
index a0429cbd..84fa8c32 100644
--- a/iterbase.hpp
+++ b/iterbase.hpp
@@ -5,7 +5,8 @@
 // This file consists of utilities used for the generic nature of the
 // iterable wrapper classes.  As such, the contents of this file should be
 // considered UNDOCUMENTED and is subject to change without warning.  This
-// also applies to the name of the file
+// also applies to the name of the file.  No user code should include
+// this file directly.
 
 #include <utility>
 #include <iterator>

From 0e25b272a4ef767f801ec8cbd99b2807fc394409 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 12 Jan 2014 15:07:54 -0500
Subject: [PATCH 0279/1866] removes extra qualifiers

---
 range.hpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/range.hpp b/range.hpp
index 62ec6362..5aac5e61 100644
--- a/range.hpp
+++ b/range.hpp
@@ -68,10 +68,10 @@ namespace iter {
                     T value;
                     const T step;
 
-                    bool not_equal_to(const Range::Iterator& other, std::true_type /*unsigned*/) const{
+                    bool not_equal_to(const Iterator& other, std::true_type /*unsigned*/) const{
                         return this->value < other.value;
                     }
-                    bool not_equal_to(const Range::Iterator& other, std::false_type /*signed*/) const{
+                    bool not_equal_to(const Iterator& other, std::false_type /*signed*/) const{
                         return !(this->step > 0 && this->value >= other.value) 
                             && !(this->step < 0 && this->value <= other.value);
                     }
@@ -103,7 +103,7 @@ namespace iter {
                     // 2) (stop - start) % step != 0.  For
                     // example Range(1, 10, 2).  The iterator will never be
                     // exactly equal to the stop value.
-                    bool operator!=(const Range::Iterator & other) const { 
+                    bool operator!=(const Iterator & other) const { 
                         return not_equal_to(other, typename std::is_unsigned<T>::type());
                     }
             };

From a073bac42feeb63d117ae2b63c4f381cc5ee9e26 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 12 Jan 2014 15:09:49 -0500
Subject: [PATCH 0280/1866] formatting in range.hpp

---
 range.hpp | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/range.hpp b/range.hpp
index 5aac5e61..c82dffa6 100644
--- a/range.hpp
+++ b/range.hpp
@@ -68,10 +68,15 @@ namespace iter {
                     T value;
                     const T step;
 
-                    bool not_equal_to(const Iterator& other, std::true_type /*unsigned*/) const{
+                    // compare unsigned values
+                    bool not_equal_to(
+                            const Iterator& other, std::true_type ) const {
                         return this->value < other.value;
                     }
-                    bool not_equal_to(const Iterator& other, std::false_type /*signed*/) const{
+
+                    // compare signed values
+                    bool not_equal_to(
+                            const Iterator& other, std::false_type) const {
                         return !(this->step > 0 && this->value >= other.value) 
                             && !(this->step < 0 && this->value <= other.value);
                     }
@@ -104,7 +109,8 @@ namespace iter {
                     // example Range(1, 10, 2).  The iterator will never be
                     // exactly equal to the stop value.
                     bool operator!=(const Iterator & other) const { 
-                        return not_equal_to(other, typename std::is_unsigned<T>::type());
+                        return not_equal_to(
+                                other, typename std::is_unsigned<T>::type());
                     }
             };
 

From 569e6a63c21de55ac950aa7a26a65a743e9f5528 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 24 Jan 2014 02:54:08 -0500
Subject: [PATCH 0281/1866] Updates to use uniform initialization

---
 enumerate.hpp | 22 ++++++++++++----------
 1 file changed, 12 insertions(+), 10 deletions(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index 2bb5f806..9ac24737 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -43,7 +43,7 @@ namespace iter {
             friend Enumerable<std::initializer_list<T>> enumerate(
                     std::initializer_list<T> &&);
 
-            Enumerable(Container && container) : container(container) { }
+            Enumerable(Container && container) : container{container} { }
             
         public:
             // Value constructor for use only in the enumerate function
@@ -58,9 +58,9 @@ namespace iter {
                 public:
                     std::size_t index;
                     iterator_deref<Container> element;
-                    IterYield(std::size_t i, iterator_deref<Container> elem): 
-                        index(i),
-                        element(elem)
+                    IterYield(std::size_t i, iterator_deref<Container> elem)
+                        : index{i},
+                        element{elem}
                     { }
             };
 
@@ -72,9 +72,10 @@ namespace iter {
                     iterator_type<Container> sub_iter;
                     std::size_t index;
                 public:
-                    Iterator (iterator_type<Container> si) :
-                        sub_iter(si),
-                        index(0) { } 
+                    Iterator (iterator_type<Container> si)
+                        : sub_iter{si},
+                        index{0}
+                    { } 
 
                     IterYield operator*() const {
                         return IterYield(this->index, *this->sub_iter);
@@ -104,13 +105,14 @@ namespace iter {
     // Helper function to instantiate an Enumerable
     template <typename Container>
     Enumerable<Container> enumerate(Container && container) {
-        return Enumerable<Container>(std::forward<Container>(container));
+        return {std::forward<Container>(container)};
     }
 
     template <typename T>
-    Enumerable<std::initializer_list<T>> enumerate(std::initializer_list<T> && il)
+    Enumerable<std::initializer_list<T>> enumerate(
+            std::initializer_list<T> && il)
     {
-        return Enumerable<std::initializer_list<T>>(std::move(il));
+        return {std::move(il)};
     }
 
 }

From ddfe6ad010688e447c20705957e25cad971d9c8b Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 24 Jan 2014 03:05:33 -0500
Subject: [PATCH 0282/1866] more brace updates

---
 enumerate.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index 9ac24737..7cb61263 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -93,11 +93,11 @@ namespace iter {
             };
 
             Iterator begin() const {
-                return Iterator(std::begin(this->container));
+                return {std::begin(this->container)};
             }
 
             Iterator end() const {
-                return Iterator(std::end(this->container));
+                return {std::end(this->container)};
             }
 
     };

From 1d27f39f835c0ac03777e83a71f0565612740ea3 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 24 Jan 2014 03:06:34 -0500
Subject: [PATCH 0283/1866] uniform initialization updates

---
 range.hpp | 32 ++++++++++++++++----------------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/range.hpp b/range.hpp
index c82dffa6..28d3e6a7 100644
--- a/range.hpp
+++ b/range.hpp
@@ -48,16 +48,16 @@ namespace iter {
             const T stop;
             const T step;
 
-            Range(T stop) :
-                start(0),
-                stop(stop),
-                step(1)
+            Range(T stop)
+                : start{0},
+                stop{stop},
+                step{1}
             { }
 
-            Range(T start, T stop, T step=1) :
-                start(start),
-                stop(stop),
-                step(step)
+            Range(T start, T stop, T step =1)
+                : start{start},
+                stop{stop},
+                step{step}
             { }
 
         public:
@@ -81,9 +81,9 @@ namespace iter {
                             && !(this->step < 0 && this->value <= other.value);
                     }
                 public:
-                    Iterator(T val, T step) :
-                        value(val),
-                        step(step)
+                    Iterator(T val, T step)
+                        : value{val},
+                        step{step}
                     { }
 
                     T operator*() const {
@@ -115,23 +115,23 @@ namespace iter {
             };
 
             Iterator begin() const {
-                return Iterator(start, step);
+                return {start, step};
             }
 
             Iterator end() const { 
-                return Iterator(stop, step);
+                return {stop, step};
             }
     };
 
 
     template <typename T>
     Range<T> range(T stop) {
-        return Range<T>(stop);
+        return {stop};
     }
 
     template <typename T>
     Range<T> range(T start, T stop) {
-        return Range<T>(start, stop);
+        return {start, stop};
     }
 
     template <typename T>
@@ -139,7 +139,7 @@ namespace iter {
         if (step == 0) {
             throw RangeException();
         }
-        return Range<T>(start, stop, step);
+        return {start, stop, step};
     }
 }
 

From 0113564b8bcb2db57d965fed8564684951921c37 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 24 Jan 2014 03:11:33 -0500
Subject: [PATCH 0284/1866] uniform initialization updates

---
 compress.hpp | 49 ++++++++++++++++++++-----------------------------
 1 file changed, 20 insertions(+), 29 deletions(-)

diff --git a/compress.hpp b/compress.hpp
index 11cb1720..376f432a 100644
--- a/compress.hpp
+++ b/compress.hpp
@@ -51,16 +51,13 @@ namespace iter {
                     std::initializer_list<T> &&, std::initializer_list<U> &&);
 
             
-
-            
-
             // Selector::Iterator type
             using selector_iter_type = decltype(std::begin(selectors));
             
             // Value constructor for use only in the compress function
-            Compressed(Container && container, Selector && selectors) :
-                container(container),
-                selectors(selectors)
+            Compressed(Container && container, Selector && selectors)
+                : container{container},
+                selectors{selectors}
             { }
             Compressed () = delete;
             Compressed & operator=(const Compressed &) = delete;
@@ -93,11 +90,11 @@ namespace iter {
                     Iterator (iterator_type<Container> cont_iter,
                               iterator_type<Container> cont_end,
                               selector_iter_type sel_iter,
-                              selector_iter_type sel_end) :
-                        sub_iter(cont_iter),
-                        sub_end(cont_end),
-                        selector_iter(sel_iter),
-                        selector_end(sel_end)
+                              selector_iter_type sel_end)
+                        : sub_iter{cont_iter},
+                        sub_end{cont_end},
+                        selector_iter{sel_iter},
+                        selector_end{sel_end}
                     { 
                         this->skip_failures();
                     } 
@@ -119,15 +116,13 @@ namespace iter {
             };
 
             Iterator begin() const {
-                return Iterator(
-                        std::begin(this->container), std::end(this->container),
-                        std::begin(this->selectors), std::end(this->selectors));
+                return {std::begin(this->container), std::end(this->container),
+                    std::begin(this->selectors), std::end(this->selectors)};
             }
 
             Iterator end() const {
-                return Iterator(
-                        std::end(this->container), std::end(this->container),
-                        std::end(this->selectors), std::end(this->selectors));
+                return {std::end(this->container), std::end(this->container),
+                        std::end(this->selectors), std::end(this->selectors)};
             }
 
     };
@@ -136,34 +131,30 @@ namespace iter {
     template <typename Container, typename Selector>
     Compressed<Container, Selector> compress(
             Container && container, Selector && selectors) {
-        return Compressed<Container, Selector>(
-                std::forward<Container>(container),
-                std::forward<Selector>(selectors));
+        return {std::forward<Container>(container),
+                std::forward<Selector>(selectors)};
     }
 
     template <typename T, typename Selector>
     Compressed<std::initializer_list<T>, Selector> compress(
             std::initializer_list<T> && data, Selector && selectors) {
-        return Compressed<std::initializer_list<T>, Selector>(
-                std::move(data),
-                std::forward<Selector>(selectors));
+        return {std::move(data),
+                std::forward<Selector>(selectors)};
     }
 
     template <typename Container, typename T>
     Compressed<Container, std::initializer_list<T>> compress(
             Container && container, std::initializer_list<T> && selectors) {
-        return Compressed<Container, std::initializer_list<T>>(
-                std::forward<Container>(container),
-                std::move(selectors));
+        return {std::forward<Container>(container),
+                std::move(selectors)};
     }
 
     template <typename T, typename U>
     Compressed<std::initializer_list<T>, std::initializer_list<U>> compress(
             std::initializer_list<T> && data,
             std::initializer_list<U> && selectors) {
-        return Compressed<std::initializer_list<T>, std::initializer_list<U>>(
-                std::move(data),
-                std::move(selectors));
+        return {std::move(data),
+                std::move(selectors)};
     }
 }
 

From e2d85cd64aea225427414dae0d952b8ac8f77179 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 24 Jan 2014 03:13:38 -0500
Subject: [PATCH 0285/1866] replaces typedef with using

---
 count.hpp | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/count.hpp b/count.hpp
index 15119e8b..4945d88f 100644
--- a/count.hpp
+++ b/count.hpp
@@ -7,9 +7,7 @@
 
 namespace iter {
 
-    namespace {
-        typedef long DefaultRangeType;
-    }
+    using DefaultRangeType = long;
 
     Range<DefaultRangeType> count() {
         return range(DefaultRangeType(0),

From ec69f569dc4d0d9c9bbcbd1c4c88653cc52dcd5c Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 24 Jan 2014 03:20:13 -0500
Subject: [PATCH 0286/1866] replaces typedef with using

---
 cycle.hpp | 26 +++++++++++---------------
 1 file changed, 11 insertions(+), 15 deletions(-)

diff --git a/cycle.hpp b/cycle.hpp
index 20be700b..605aa2ab 100644
--- a/cycle.hpp
+++ b/cycle.hpp
@@ -29,14 +29,10 @@ namespace iter {
             friend Cycle<std::initializer_list<T>> cycle(
                     std::initializer_list<T> &&);
 
-            
-
-            
-
             Container & container;
             
             // Value constructor for use only in the cycle function
-            Cycle(Container && container) : container(container) { }
+            Cycle(Container && container) : container{container} { }
             Cycle () = delete;
             Cycle & operator=(const Cycle &) = delete;
 
@@ -50,10 +46,10 @@ namespace iter {
                     const iterator_type<Container> end;
                 public:
                     Iterator (iterator_type<Container> iter,
-                            iterator_type<Container> end) :
-                        sub_iter(iter),
-                        begin(iter),
-                        end(end)
+                            iterator_type<Container> end)
+                        : sub_iter{iter},
+                        begin{iter},
+                        end{end}
                     { } 
 
                     iterator_deref<Container> operator*() const {
@@ -79,13 +75,13 @@ namespace iter {
             };
 
             Iterator begin() const {
-                return Iterator(std::begin(this->container),
-                        std::end(this->container));
+                return {std::begin(this->container),
+                        std::end(this->container)};
             }
 
             Iterator end() const {
-                return Iterator(std::end(this->container),
-                    std::end(this->container));
+                return {std::end(this->container),
+                        std::end(this->container)};
             }
 
     };
@@ -93,13 +89,13 @@ namespace iter {
     // Helper function to instantiate an Filter
     template <typename Container>
     Cycle<Container> cycle(Container && container) {
-        return Cycle<Container>(std::forward<Container>(container));
+        return {std::forward<Container>(container)};
     }
 
     template <typename T>
     Cycle<std::initializer_list<T>> cycle(std::initializer_list<T> && il)
     {
-        return Cycle<std::initializer_list<T>>(std::move(il));
+        return {std::move(il)};
     }
 }
 

From 18443899f35a8ffbe5edeca791f5c3a119cbb29f Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 24 Jan 2014 03:26:29 -0500
Subject: [PATCH 0287/1866] uniform initialization updates

---
 dropwhile.hpp | 33 +++++++++++----------------------
 1 file changed, 11 insertions(+), 22 deletions(-)

diff --git a/dropwhile.hpp b/dropwhile.hpp
index 626ac733..2d298425 100644
--- a/dropwhile.hpp
+++ b/dropwhile.hpp
@@ -32,15 +32,10 @@ namespace iter {
             template <typename FF, typename T>
             friend DropWhile<FF, std::initializer_list<T>> dropwhile(
                     FF, std::initializer_list<T> &&);
-
-            
-
-            
-
             
             // Value constructor for use only in the dropwhile function
-            DropWhile(FilterFunc filter_func, Container && container) :
-                container(container),
+            DropWhile(FilterFunc filter_func, Container && container)
+                : container{container},
                 filter_func(filter_func)
             { }
             DropWhile () = delete;
@@ -65,9 +60,9 @@ namespace iter {
                 public:
                     Iterator (iterator_type<Container> iter,
                             iterator_type<Container> end,
-                            FilterFunc filter_func) :
-                        sub_iter(iter),
-                        sub_end(end),
+                            FilterFunc filter_func)
+                        : sub_iter{iter},
+                        sub_end{end},
                         filter_func(filter_func)
                     { 
                         this->skip_passes();
@@ -88,17 +83,15 @@ namespace iter {
             };
 
             Iterator begin() const {
-                return Iterator(
-                        std::begin(this->container),
+                return {std::begin(this->container),
                         std::end(this->container),
-                        this->filter_func);
+                        this->filter_func};
             }
 
             Iterator end() const {
-                return Iterator(
-                        std::end(this->container),
+                return {std::end(this->container),
                         std::end(this->container),
-                        this->filter_func);
+                        this->filter_func};
             }
 
     };
@@ -107,18 +100,14 @@ namespace iter {
     template <typename FilterFunc, typename Container>
     DropWhile<FilterFunc, Container> dropwhile(
             FilterFunc filter_func, Container && container) {
-        return DropWhile<FilterFunc, Container>(
-                filter_func, 
-                std::forward<Container>(container));
+        return {filter_func, std::forward<Container>(container)};
     }
 
     template <typename FilterFunc, typename T>
     DropWhile<FilterFunc, std::initializer_list<T>> dropwhile(
             FilterFunc filter_func, std::initializer_list<T> && il)
     {
-        return DropWhile<FilterFunc, std::initializer_list<T>>(
-                filter_func,
-                std::move(il));
+        return {filter_func, std::move(il)};
     }
 }
 

From 2c91f0558ec1da1888ffce6659f635813d6043dd Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 24 Jan 2014 14:45:02 -0500
Subject: [PATCH 0288/1866] uniform initialization updates

---
 filter.hpp | 29 +++++++++++------------------
 1 file changed, 11 insertions(+), 18 deletions(-)

diff --git a/filter.hpp b/filter.hpp
index 2decb950..143cc9e8 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -34,12 +34,9 @@ namespace iter {
             friend Filter<FF, std::initializer_list<T>> filter(
                     FF, std::initializer_list<T> &&);
             
-
-            
-            
             // Value constructor for use only in the filter function
-            Filter(FilterFunc filter_func, Container && container) :
-                container(container),
+            Filter(FilterFunc filter_func, Container && container)
+                : container{container},
                 filter_func(filter_func)
             { }
             Filter () = delete;
@@ -66,9 +63,9 @@ namespace iter {
                 public:
                     Iterator (iterator_type<Container> iter,
                             iterator_type<Container> end,
-                            FilterFunc filter_func) :
-                        sub_iter(iter),
-                        sub_end(end),
+                            FilterFunc filter_func)
+                        : sub_iter{iter},
+                        sub_end{end},
                         filter_func(filter_func)
                     { 
                         this->skip_failures();
@@ -90,17 +87,15 @@ namespace iter {
             };
 
             Iterator begin() const {
-                return Iterator(
-                        std::begin(this->container),
+                return {std::begin(this->container),
                         std::end(this->container),
-                        this->filter_func);
+                        this->filter_func};
             }
 
             Iterator end() const {
-                return Iterator(
-                        std::end(this->container),
+                return {std::end(this->container),
                         std::end(this->container),
-                        this->filter_func);
+                        this->filter_func};
             }
 
     };
@@ -109,8 +104,7 @@ namespace iter {
     template <typename FilterFunc, typename Container>
     Filter<FilterFunc, Container> filter(
             FilterFunc filter_func, Container && container) {
-        return Filter<FilterFunc, Container>(
-                filter_func, std::forward<Container>(container));
+        return {filter_func, std::forward<Container>(container)};
     }
 
     template <typename FilterFunc, typename T>
@@ -118,8 +112,7 @@ namespace iter {
             FilterFunc filter_func,
             std::initializer_list<T> && il)
     {
-        return Filter<FilterFunc, std::initializer_list<T>>(
-                filter_func, std::move(il));
+        return {filter_func, std::move(il)};
     }
 
     namespace detail {

From bd278b59c333b78f7ba05e245b0771fdf8bb6ade Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 24 Jan 2014 14:52:23 -0500
Subject: [PATCH 0289/1866] uniform initialization updates

---
 groupby.hpp | 46 ++++++++++++++++++++--------------------------
 1 file changed, 20 insertions(+), 26 deletions(-)

diff --git a/groupby.hpp b/groupby.hpp
index ed6fe0d0..c4868897 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -39,8 +39,8 @@ namespace iter {
                 decltype(std::declval<KeyFunc>()(
                             std::declval<iterator_deref<Container>>()));
 
-            GroupBy(Container && container, KeyFunc key_func) :
-                container(container),
+            GroupBy(Container && container, KeyFunc key_func)
+                : container{container},
                 key_func(key_func)
             { }
 
@@ -68,9 +68,9 @@ namespace iter {
                 public:
                     Iterator (iterator_type<Container> si,
                               iterator_type<Container> end,
-                              KeyFunc key_func) :
-                        sub_iter(si),
-                        sub_end(end),
+                              KeyFunc key_func)
+                        : sub_iter{si},
+                        sub_end{end},
                         key_func(key_func)
                     { }
 
@@ -148,10 +148,10 @@ namespace iter {
                     Group & operator=(const Group &) = delete;
 
                     Group & operator=(Group &&) = default;
-                    Group (Group && other) :
-                            owner(other.owner),
-                            key(other.key),
-                            completed(other.completed) {
+                    Group (Group && other)
+                            : owner{other.owner},
+                            key{other.key},
+                            completed{other.completed} {
                         other.completed = true;
                     }
 
@@ -167,9 +167,9 @@ namespace iter {
 
                         public:
                             GroupIterator(const Group & group,
-                                          key_func_ret key) :
-                                key(key),
-                                group(group)
+                                          key_func_ret key)
+                                : key{key},
+                                group{group}
                             { }
 
                             GroupIterator(const GroupIterator &) = default;
@@ -194,28 +194,26 @@ namespace iter {
                     };
 
                     GroupIterator begin() const {
-                        return GroupIterator(*this, key);
+                        return {*this, key};
                     }
 
                     GroupIterator end() const {
-                        return GroupIterator(*this, key);
+                        return {*this, key};
                     }
 
             };
 
 
             Iterator begin() const {
-                return Iterator(
-                        std::begin(this->container),
+                return {std::begin(this->container),
                         std::end(this->container),
-                        this->key_func);
+                        this->key_func};
             }
 
             Iterator end() const {
-                return Iterator(
+                return {std::end(this->container),
                         std::end(this->container),
-                        std::end(this->container),
-                        this->key_func);
+                        this->key_func};
             }
 
     };
@@ -236,9 +234,7 @@ namespace iter {
     template <typename Container, typename KeyFunc>
     GroupBy<Container, KeyFunc> groupby(
             Container && container, KeyFunc key_func) {
-        return GroupBy<Container, KeyFunc>(
-                std::forward<Container>(container),
-                key_func);
+        return {std::forward<Container>(container), key_func};
     }
 
 
@@ -254,9 +250,7 @@ namespace iter {
     template <typename T, typename KeyFunc>
     GroupBy<std::initializer_list<T>, KeyFunc> groupby(
             std::initializer_list<T> && il, KeyFunc key_func) {
-        return GroupBy<std::initializer_list<T>, KeyFunc>(
-                std::move(il),
-                key_func);
+        return {std::move(il), key_func};
     }
 
 

From ca3d108e93c44d10636a14ab142c69f930c0140c Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 24 Jan 2014 14:54:50 -0500
Subject: [PATCH 0290/1866] uniform initialization updates

---
 imap.hpp | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/imap.hpp b/imap.hpp
index ea447f81..6eeaaae8 100644
--- a/imap.hpp
+++ b/imap.hpp
@@ -125,11 +125,11 @@ namespace iter {
             };
 
             Iterator begin() const {
-                return Iterator(this->map_func, this->zipped.begin());
+                return {this->map_func, this->zipped.begin()};
             }
 
             Iterator end() const {
-                return Iterator(this->map_func, this->zipped.end());
+                return {this->map_func, this->zipped.end()};
             }
 
     };
@@ -138,9 +138,7 @@ namespace iter {
     template <typename MapFunc, typename... Containers>
     IMap<MapFunc, Containers...> imap(
             MapFunc map_func, Containers && ... containers) {
-        return IMap<MapFunc, Containers...>(
-                map_func,
-                std::forward<Containers>(containers)...);
+        return {map_func, std::forward<Containers>(containers)...};
     }
 
 }

From 7937edde6f81be4bc7e4efd92266d4608612e1e8 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 24 Jan 2014 14:57:45 -0500
Subject: [PATCH 0291/1866] uniform initialization updates

---
 slice.hpp | 41 ++++++++++++++++++-----------------------
 1 file changed, 18 insertions(+), 23 deletions(-)

diff --git a/slice.hpp b/slice.hpp
index 2415225e..f7a074a4 100644
--- a/slice.hpp
+++ b/slice.hpp
@@ -72,11 +72,11 @@ namespace iter {
             
         public:
             Slice(Container & container, DifferenceType start,
-                  DifferenceType stop, DifferenceType step) :
-                container(container),
-                start(start),
-                stop(stop),
-                step(step)
+                  DifferenceType stop, DifferenceType step)
+                : container{container},
+                start{start},
+                stop{stop},
+                step{step}
             { 
                 // sets stop = start if the range is empty
                 if ((start < stop && step <=0) ||
@@ -106,11 +106,11 @@ namespace iter {
 
                 public:
                     Iterator (iterator_type<Container> si, DifferenceType start,
-                            DifferenceType stop, DifferenceType step) :
-                        sub_iter(si),
-                        current(start),
-                        stop(stop),
-                        step(step)
+                            DifferenceType stop, DifferenceType step)
+                        : sub_iter{si},
+                        current{start},
+                        stop{stop},
+                        step{step}
                     { }
 
                     iterator_deref<Container> operator*() const {
@@ -130,15 +130,13 @@ namespace iter {
             };
 
             Iterator begin() const {
-                return Iterator(
-                        std::next(std::begin(this->container), this->start),
-                        this->start, this->stop, this->step);
+                return {std::next(std::begin(this->container), this->start),
+                        this->start, this->stop, this->step};
             }
 
             Iterator end() const {
-                return Iterator(
-                        std::next(std::begin(this->container), this->stop),
-                        this->stop, this->stop, this->step);
+                return {std::next(std::begin(this->container), this->stop),
+                        this->stop, this->stop, this->step};
             }
 
     };
@@ -148,30 +146,27 @@ namespace iter {
     Slice<Container, DifferenceType> slice(
             Container && container, DifferenceType start,
             DifferenceType stop, DifferenceType step=1) {
-        return Slice<Container, DifferenceType>(
-                std::forward<Container>(container), start, stop, step);
+        return {std::forward<Container>(container), start, stop, step};
     }
 
     //only give the end as an arg and assume step  is 1 and begin is 0
     template <typename Container, typename DifferenceType>
     Slice<Container, DifferenceType> slice(
             Container && container, DifferenceType stop) {
-        return Slice<Container, DifferenceType>(
-                std::forward<Container>(container), 0, stop, 1);
+        return {std::forward<Container>(container), 0, stop, 1};
     }
 
     template <typename T, typename DifferenceType>
     Slice<std::initializer_list<T>, DifferenceType> slice(
             std::initializer_list<T> && il, DifferenceType start,
             DifferenceType stop, DifferenceType step=1) {
-        return Slice<std::initializer_list<T>, DifferenceType>(
-                il, start, stop, step);
+        return {il, start, stop, step};
     }
 
     template <typename T, typename DifferenceType>
     Slice<std::initializer_list<T>, DifferenceType> slice(
             std::initializer_list<T> && il, DifferenceType stop) {
-        return Slice<std::initializer_list<T>, DifferenceType>(il, 0, stop, 1);
+        return {il, 0, stop, 1};
     }
 }
 

From c8f9dfec4162a1f8591d845fb4f26ba38eeed1e1 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 24 Jan 2014 16:30:49 -0500
Subject: [PATCH 0292/1866] uniform initialization updates

---
 sorted.hpp | 17 ++++++-----------
 1 file changed, 6 insertions(+), 11 deletions(-)

diff --git a/sorted.hpp b/sorted.hpp
index 6a0c518a..ce824541 100644
--- a/sorted.hpp
+++ b/sorted.hpp
@@ -20,10 +20,6 @@ namespace iter {
             friend Sorted
                 sorted<Container, CompareFunc>(Container &, CompareFunc);
 
-            
-
-            
-
             std::vector<iterator_type<Container>> sorted_iters;
 
             using sorted_iter_type = decltype(std::begin(sorted_iters));
@@ -55,8 +51,8 @@ namespace iter {
             // them when accessed with operator *
             class IteratorIterator : public sorted_iter_type {
                 public:
-                    IteratorIterator(sorted_iter_type iter) :
-                        sorted_iter_type(iter)
+                    IteratorIterator(sorted_iter_type iter)
+                        : sorted_iter_type{iter}
                     { }
                     IteratorIterator(const IteratorIterator &) = default;
 
@@ -67,20 +63,19 @@ namespace iter {
             };
 
             IteratorIterator begin() {
-                IteratorIterator iteriter(std::begin(sorted_iters));
-                return iteriter;
+                return {std::begin(sorted_iters)};
+                
             }
 
             IteratorIterator end() {
-                IteratorIterator iteriter(std::end(sorted_iters));
-                return iteriter;
+                return {std::end(sorted_iters)};
             }
     };
 
     template <typename Container, typename CompareFunc>
     Sorted<Container, CompareFunc> sorted(
             Container & container, CompareFunc compare_func) {
-        return Sorted<Container, CompareFunc>(container, compare_func);
+        return {container, compare_func};
     }
 
     template <typename Container>

From a129fc7d632c1bd9f19462438a291a07c3eadc8a Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 24 Jan 2014 16:33:50 -0500
Subject: [PATCH 0293/1866] uniform initialization updates

---
 takewhile.hpp | 32 +++++++++++---------------------
 1 file changed, 11 insertions(+), 21 deletions(-)

diff --git a/takewhile.hpp b/takewhile.hpp
index caf135d3..92937e20 100644
--- a/takewhile.hpp
+++ b/takewhile.hpp
@@ -33,13 +33,9 @@ namespace iter {
             friend TakeWhile<FF, std::initializer_list<T>> takewhile(
                     FF, std::initializer_list<T> &&);
 
-            
-
-            
-
             // Value constructor for use only in the takewhile function
-            TakeWhile(FilterFunc filter_func, Container && container) :
-                container(container),
+            TakeWhile(FilterFunc filter_func, Container && container)
+                : container{container},
                 filter_func(filter_func)
             { }
 
@@ -71,9 +67,9 @@ namespace iter {
                 public:
                     Iterator (iterator_type<Container> iter,
                             iterator_type<Container> end,
-                            FilterFunc filter_func) :
-                        sub_iter(iter),
-                        sub_end(end),
+                            FilterFunc filter_func)
+                        : sub_iter{iter},
+                        sub_end{end},
                         filter_func(filter_func)
                     { 
                         if (this->sub_iter != this->sub_end) {
@@ -98,17 +94,15 @@ namespace iter {
             };
 
             Iterator begin() const {
-                return Iterator(
-                        std::begin(this->container),
+                return {std::begin(this->container),
                         std::end(this->container),
-                        this->filter_func);
+                        this->filter_func};
             }
 
             Iterator end() const {
-                return Iterator(
-                        std::end(this->container),
+                return {std::end(this->container),
                         std::end(this->container),
-                        this->filter_func);
+                        this->filter_func};
             }
 
     };
@@ -117,18 +111,14 @@ namespace iter {
     template <typename FilterFunc, typename Container>
     TakeWhile<FilterFunc, Container> takewhile(
             FilterFunc filter_func, Container && container) {
-        return TakeWhile<FilterFunc, Container>(
-                filter_func,
-                std::forward<Container>(container));
+        return {filter_func, std::forward<Container>(container)};
     }
 
     template <typename FilterFunc, typename T>
     TakeWhile<FilterFunc, std::initializer_list<T>> takewhile(
             FilterFunc filter_func, std::initializer_list<T> && il)
     {
-        return TakeWhile<FilterFunc, std::initializer_list<T>>(
-                filter_func,
-                std::move(il));
+        return {filter_func, std::move(il)};
     }
 
 }

From 87b3f990569d753a8abdb6c170f7bdde1bf7cbbe Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 6 Mar 2014 10:13:41 -0500
Subject: [PATCH 0294/1866] Renames "moving_section" to "sliding_window"

Inspired by the networking algorithm.   This name better conveys the
purpose and functionality of the iterable.
---
 README.md                                     |  6 ++--
 grouper.hpp                                   |  2 +-
 itertools.hpp                                 |  2 +-
 moving_section.hpp => sliding_window.hpp      | 30 +++++++++----------
 tests/.gitignore                              |  2 +-
 tests/SConstruct                              |  4 +--
 tests/testcommand_chains.cpp                  |  2 +-
 ...ing_section.cpp => testsliding_window.cpp} |  6 ++--
 8 files changed, 27 insertions(+), 27 deletions(-)
 rename moving_section.hpp => sliding_window.hpp (74%)
 rename tests/{testmoving_section.cpp => testsliding_window.cpp} (71%)

diff --git a/README.md b/README.md
index 20eee131..a4a1770d 100644
--- a/README.md
+++ b/README.md
@@ -23,7 +23,7 @@ library.
 [chain](#chain)<br />
 [reverse](#reverse)<br />
 [slice](#slice)<br />
-[moving_section](#moving_section)<br />
+[sliding_window](#sliding_window)<br />
 [grouper](#grouper)<br />
 
 ##### Combinatoric fuctions
@@ -350,7 +350,7 @@ for (auto i : slice(a,0,15,3)) {
 }
 ```
 
-moving_section
+sliding_window
 -------------
 
 Takes a section from a range and increments the whole section.  
@@ -371,7 +371,7 @@ take a section of size 4, output is:
 Example Usage:
 ```c++
 std::vector<int> v = {1,2,3,4,5,6,7,8,9};                                      
-for (auto sec : moving_section(v,4)) {                                         
+for (auto sec : sliding_window(v,4)) {                                         
     for (auto i : sec) {                                                       
         std::cout << i << " ";                                                 
         i.get() = 90; 
diff --git a/grouper.hpp b/grouper.hpp
index eb885e27..192fd255 100644
--- a/grouper.hpp
+++ b/grouper.hpp
@@ -63,7 +63,7 @@ namespace iter {
                   //  this->group.push_back(this->container.begin() + i);
             }
 
-            //seems like conclassor is same as moving_section_iter
+            //seems like conclassor is same as sliding_window_iter
             grouper_iter(Container && c) :
                 container(std::forward<Container>(c))
             {
diff --git a/itertools.hpp b/itertools.hpp
index 4129c4c7..5b038ef8 100644
--- a/itertools.hpp
+++ b/itertools.hpp
@@ -15,7 +15,7 @@
 #include "grouper.hpp"
 #include "imap.hpp"
 #include "iterator_range.hpp"
-#include "moving_section.hpp"
+#include "sliding_window.hpp"
 #include "permutations.hpp"
 #include "powerset.hpp"
 #include "product.hpp"
diff --git a/moving_section.hpp b/sliding_window.hpp
similarity index 74%
rename from moving_section.hpp
rename to sliding_window.hpp
index 3ee6eb9b..a7bea87e 100644
--- a/moving_section.hpp
+++ b/sliding_window.hpp
@@ -1,5 +1,5 @@
-#ifndef MOVING_SECTION_HPP
-#define MOVING_SECTION_HPP
+#ifndef SLIDING_WINDOW_HPP
+#define SLIDING_WINDOW_HPP
 
 #include "iterator_range.hpp"
 
@@ -12,17 +12,17 @@
 
 namespace iter {
     template <typename Container>
-        struct moving_section_iter;
+        struct sliding_window_iter;
     template <typename Container>
-        iterator_range<moving_section_iter<Container>>
-        moving_section(Container && container, size_t s) {
-            auto begin = moving_section_iter<Container>(std::forward<Container>(container),s);
-            auto end = moving_section_iter<Container>(std::forward<Container>(container));
-            return iterator_range<moving_section_iter<Container>>(begin,end);
+        iterator_range<sliding_window_iter<Container>>
+        sliding_window(Container && container, size_t s) {
+            auto begin = sliding_window_iter<Container>(std::forward<Container>(container),s);
+            auto end = sliding_window_iter<Container>(std::forward<Container>(container));
+            return iterator_range<sliding_window_iter<Container>>(begin,end);
         }
 
     template <typename Container>
-        struct moving_section_iter {
+        struct sliding_window_iter {
             typename 
                 std::conditional<std::is_lvalue_reference<Container>::value,
                 Container&,
@@ -32,7 +32,7 @@ namespace iter {
             using Iterator = decltype(std::begin(container));
             std::vector<Iterator> section;
             size_t section_size = 0;
-            moving_section_iter(Container && c, size_t s) :
+            sliding_window_iter(Container && c, size_t s) :
                 container(std::forward<Container>(c)),section_size(s) {
                     size_t i = 0;
                     for (auto iter = std::begin(container); i < section_size;++iter,++i) {
@@ -41,20 +41,20 @@ namespace iter {
                     //for (size_t i = 0; i < section_size; ++i) 
                       //  section.push_back(container.begin()+i);
                 }
-            moving_section_iter(Container && c) : container(std::forward<Container>(c))
+            sliding_window_iter(Container && c) : container(std::forward<Container>(c))
             //creates the end iterator
             {
                 section.push_back(std::end(container));
             }
 
-            moving_section_iter & operator++() {
+            sliding_window_iter & operator++() {
                 for (auto & iter : section) {
                     ++iter;
                 }
                 return *this;
                 //std::for_each(section.begin(),section.end(),[](Iterator & i){++i;});
             }
-            bool operator!=(const moving_section_iter & rhs) {
+            bool operator!=(const sliding_window_iter & rhs) {
                return this->section.back() != rhs.section.back();
             }
             using Deref_type = std::vector<std::reference_wrapper<typename std::remove_reference<decltype(*std::declval<Iterator>())>::type>>;
@@ -70,9 +70,9 @@ namespace iter {
 }
 namespace std {
     template <typename Container>
-        struct iterator_traits<iter::moving_section_iter<Container>> {
+        struct iterator_traits<iter::sliding_window_iter<Container>> {
             using difference_type = ptrdiff_t;
             using iterator_category = input_iterator_tag;
         };
 }
-#endif //MOVING_SECTION_HPP
+#endif //SLIDING_WINDOW_HPP
diff --git a/tests/.gitignore b/tests/.gitignore
index 3daf97d6..a78678de 100644
--- a/tests/.gitignore
+++ b/tests/.gitignore
@@ -18,7 +18,7 @@ testcombinations_with_replacement
 testtakewhile
 testcombinations
 testpowerset
-testmoving_section
+testsliding_window
 testimap
 testfilterfalse
 testcount
diff --git a/tests/SConstruct b/tests/SConstruct
index 56b5aa44..17e40444 100644
--- a/tests/SConstruct
+++ b/tests/SConstruct
@@ -2,7 +2,7 @@ import platform
 import os
 
 env = Environment(
-    CXX='c++',
+    CXX='g++',
     CXXFLAGS= ['-g', '-Wall', '-Wextra',
                '-pedantic', '-std=c++11',
                '-I/usr/local/include'],
@@ -30,7 +30,7 @@ progs = Split('''
               combinations_with_replacement 
               combinations 
               powerset
-              moving_section
+              sliding_window
               imap
               count
               filterfalse
diff --git a/tests/testcommand_chains.cpp b/tests/testcommand_chains.cpp
index 76aca6f4..07cae5c5 100644
--- a/tests/testcommand_chains.cpp
+++ b/tests/testcommand_chains.cpp
@@ -47,7 +47,7 @@ int main() {
     {
         std::vector<int> vec1{1,2,3,4,5,6};
         std::vector<int> vec2{7,8,9,10};
-        for (auto s : moving_section(chain(vec1,vec2),4)) {
+        for (auto s : sliding_window(chain(vec1,vec2),4)) {
             for (auto i : s) std::cout << i << " ";
             std::cout<<std::endl;
         }
diff --git a/tests/testmoving_section.cpp b/tests/testsliding_window.cpp
similarity index 71%
rename from tests/testmoving_section.cpp
rename to tests/testsliding_window.cpp
index 3faf21e7..33f0e88d 100644
--- a/tests/testmoving_section.cpp
+++ b/tests/testsliding_window.cpp
@@ -1,10 +1,10 @@
-#include "moving_section.hpp"
+#include "sliding_window.hpp"
 #include <iostream>
 #include <vector>
-using iter::moving_section;
+using iter::sliding_window;
 int main() {
     std::vector<int> v = {1,2,3,4,5,6,7,8,9}; 
-    for (auto sec : moving_section(v,4)) {
+    for (auto sec : sliding_window(v,4)) {
         for (auto i : sec) {
             std::cout << i << " ";
             i.get() = 90;

From 4447a1aba42f3d6a0871ab9bfcbb7cdef66842af Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 1 May 2014 10:31:12 -0400
Subject: [PATCH 0295/1866] adds missing "if" to README

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index a4a1770d..07b24d3f 100644
--- a/README.md
+++ b/README.md
@@ -230,7 +230,7 @@ for (auto gb : groupby(vec, [] (const string &s) {return s.length(); })) {
 ```
 *Note*: Just like Python's `itertools.groupby`, this doesn't do any sorting.
 It just iterates through, making a new group each time there is a key change.
-Thus, the the group is unsorted, the same key may appear multiple times.
+Thus, if the the group is unsorted, the same key may appear multiple times.
 
 zip
 ---

From a91a8138be1ffdd7853c5674da95e4543133bf15 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 1 May 2014 10:34:11 -0400
Subject: [PATCH 0296/1866] adds note about lazy evaluation

---
 README.md | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 07b24d3f..03dcf0ff 100644
--- a/README.md
+++ b/README.md
@@ -1,8 +1,9 @@
 CPPItertools
 ============
 
-range-based for loop add-ons inspired by the python builtins and itertools
-library.
+range-based for loop add-ons inspired by the Python builtins and itertools
+library.  Like itertools and the Python3 builtins, this library uses lazy
+evaluation wherever possible.
 
 *Note*: Everthing is inside the `iter` namespace.
 

From bddd463189d1ae500a6ecba5f4e63145f41ab0a1 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 25 May 2014 12:59:45 -0700
Subject: [PATCH 0297/1866] adds non-functional accumulate

---
 accumulate.hpp | 114 +++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 114 insertions(+)
 create mode 100644 accumulate.hpp

diff --git a/accumulate.hpp b/accumulate.hpp
new file mode 100644
index 00000000..cb189ea6
--- /dev/null
+++ b/accumulate.hpp
@@ -0,0 +1,114 @@
+#ifndef accumulate__H__
+#define accumulate__H__
+
+#include "iterbase.hpp"
+
+#include <utility>
+#include <iterator>
+#include <initializer_list>
+
+namespace iter {
+
+    //Forward declarations of Accumulator and accumulate
+    template <typename AccumulateFunc, typename Container>
+    class Accumulator;
+
+    template <typename Container, typename AccumulateFunc>
+    Accumulator<AccumulateFunc, Container> accumulate(
+            Container &&, AccumulateFunc);
+
+    template <typename AccumulateFunc, typename T>
+    Accumulator<AccumulateFunc, std::initializer_list<T>> accumulate(
+            std::initializer_list<T> &&, AccumulateFunc);
+
+    template <typename AccumulateFunc, typename Container>
+    class Accumulator {
+        private:
+            Container & container;
+            AccumulateFunc accumulate_func;
+
+            // The accumulate function is the only thing allowed to create a Accumulator
+            friend Accumulator accumulate<Container, AccumulateFunc>(
+                    Container &&, AccumulateFunc);
+
+            template <typename AF, typename T>
+            friend Accumulator<std::initializer_list<T>, AF> accumulate(
+                    std::initializer_list<T> &&, AF);
+            
+            // Value constructor for use only in the accumulate function
+            Accumulator(AccumulateFunc accumulate_func, Container && container)
+                : container{container},
+                accumulate_func(accumulate_func)
+            { }
+            Accumulator () = delete;
+            Accumulator & operator=(const Accumulator &) = delete;
+
+        public:
+            Accumulator(const Accumulator &) = default;
+
+            class Iterator {
+                using AccumVal =
+                    typename std::result_of<AccumulateFunc(
+                            iterator_deref<Container>, iterator_deref<Container>)>::type;
+                private:
+                    iterator_type<Container> sub_iter;
+                    const iterator_type<Container> sub_end;
+                    AccumulateFunc accumulate_func;
+                public:
+                    Iterator (iterator_type<Container> iter,
+                            iterator_type<Container> end,
+                            AccumulateFunc accumulate_func)
+                        : sub_iter{iter},
+                        sub_end{end},
+                        accumulate_func(accumulate_func)
+                    { } 
+
+                    iterator_deref<Container> operator*() const {
+                        return *this->sub_iter;
+                    }
+
+                    Iterator & operator++() { 
+                        ++this->sub_iter;
+                        // TODO
+                        return *this;
+                    }
+
+                    bool operator!=(const Iterator & other) const {
+                        return this->sub_iter != other.sub_iter;
+                    }
+            };
+
+            Iterator begin() const {
+                return {std::begin(this->container),
+                        std::end(this->container),
+                        this->accumulate_func};
+            }
+
+            Iterator end() const {
+                return {std::end(this->container),
+                        std::end(this->container),
+                        this->accumulate_func};
+            }
+
+    };
+
+    // Helper function to instantiate an Accumulator
+    template <typename Container, typename AccumulateFunc>
+    Accumulator<AccumulateFunc, Container> accumulate(
+            Container && container,
+            AccumulateFunc accumulate_func)
+    {
+        return {accumulate_func, std::forward<Container>(container)};
+    }
+
+    template <typename T, typename AccumulateFunc>
+    Accumulator<AccumulateFunc, std::initializer_list<T>> accumulate(
+            std::initializer_list<T> && il,
+            AccumulateFunc accumulate_func)
+    {
+        return {accumulate_func, std::move(il)};
+    }
+
+}
+
+#endif //ifndef accumulate__H__

From f2b4d26705579c02780ca996c1b89cd8829d6bc3 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 25 May 2014 14:34:29 -0700
Subject: [PATCH 0298/1866] accumulate actually works

---
 accumulate.hpp | 17 ++++++++++++-----
 1 file changed, 12 insertions(+), 5 deletions(-)

diff --git a/accumulate.hpp b/accumulate.hpp
index cb189ea6..f67e048a 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -47,29 +47,36 @@ namespace iter {
             Accumulator(const Accumulator &) = default;
 
             class Iterator {
+                // NOTE can AccumVal and iterator_deref<> be different?
                 using AccumVal =
                     typename std::result_of<AccumulateFunc(
-                            iterator_deref<Container>, iterator_deref<Container>)>::type;
+                            iterator_deref<Container>,
+                            iterator_deref<Container>)>::type;
                 private:
                     iterator_type<Container> sub_iter;
                     const iterator_type<Container> sub_end;
                     AccumulateFunc accumulate_func;
+                    AccumVal acc_val;
                 public:
                     Iterator (iterator_type<Container> iter,
                             iterator_type<Container> end,
                             AccumulateFunc accumulate_func)
                         : sub_iter{iter},
                         sub_end{end},
-                        accumulate_func(accumulate_func)
+                        accumulate_func(accumulate_func),
+                        acc_val(iter == end ? AccumVal{} : *iter)
                     { } 
 
-                    iterator_deref<Container> operator*() const {
-                        return *this->sub_iter;
+                    AccumVal operator*() const {
+                        return this->acc_val;
                     }
 
                     Iterator & operator++() { 
                         ++this->sub_iter;
-                        // TODO
+                        if (this->sub_iter != this->sub_end) {
+                            this->acc_val = accumulate_func(
+                                    this->acc_val, *this->sub_iter);
+                        }
                         return *this;
                     }
 

From faf79aaef04f6e782f094678e8ce31fc487dbe0c Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 25 May 2014 15:10:45 -0700
Subject: [PATCH 0299/1866] rearranges template args

---
 accumulate.hpp | 25 ++++++++++++-------------
 1 file changed, 12 insertions(+), 13 deletions(-)

diff --git a/accumulate.hpp b/accumulate.hpp
index f67e048a..f64f4924 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -1,5 +1,5 @@
-#ifndef accumulate__H__
-#define accumulate__H__
+#ifndef ACCUMULATE__H__
+#define ACCUMULATE__H__
 
 #include "iterbase.hpp"
 
@@ -10,18 +10,18 @@
 namespace iter {
 
     //Forward declarations of Accumulator and accumulate
-    template <typename AccumulateFunc, typename Container>
+    template <typename Container, typename AccumulateFunc>
     class Accumulator;
 
     template <typename Container, typename AccumulateFunc>
-    Accumulator<AccumulateFunc, Container> accumulate(
+    Accumulator<Container, AccumulateFunc> accumulate(
             Container &&, AccumulateFunc);
 
     template <typename AccumulateFunc, typename T>
-    Accumulator<AccumulateFunc, std::initializer_list<T>> accumulate(
+    Accumulator<std::initializer_list<T>, AccumulateFunc> accumulate(
             std::initializer_list<T> &&, AccumulateFunc);
 
-    template <typename AccumulateFunc, typename Container>
+    template <typename Container, typename AccumulateFunc>
     class Accumulator {
         private:
             Container & container;
@@ -36,7 +36,7 @@ namespace iter {
                     std::initializer_list<T> &&, AF);
             
             // Value constructor for use only in the accumulate function
-            Accumulator(AccumulateFunc accumulate_func, Container && container)
+            Accumulator(Container && container, AccumulateFunc accumulate_func)
                 : container{container},
                 accumulate_func(accumulate_func)
             { }
@@ -47,7 +47,6 @@ namespace iter {
             Accumulator(const Accumulator &) = default;
 
             class Iterator {
-                // NOTE can AccumVal and iterator_deref<> be different?
                 using AccumVal =
                     typename std::result_of<AccumulateFunc(
                             iterator_deref<Container>,
@@ -101,21 +100,21 @@ namespace iter {
 
     // Helper function to instantiate an Accumulator
     template <typename Container, typename AccumulateFunc>
-    Accumulator<AccumulateFunc, Container> accumulate(
+    Accumulator<Container, AccumulateFunc> accumulate(
             Container && container,
             AccumulateFunc accumulate_func)
     {
-        return {accumulate_func, std::forward<Container>(container)};
+        return {std::forward<Container>(container), accumulate_func};
     }
 
     template <typename T, typename AccumulateFunc>
-    Accumulator<AccumulateFunc, std::initializer_list<T>> accumulate(
+    Accumulator<std::initializer_list<T>, AccumulateFunc> accumulate(
             std::initializer_list<T> && il,
             AccumulateFunc accumulate_func)
     {
-        return {accumulate_func, std::move(il)};
+        return {std::move(il), accumulate_func};
     }
 
 }
 
-#endif //ifndef accumulate__H__
+#endif //ifndef ACCUMULATE__H__

From 91b2f7d0adb803edb26a472c087fa880014dd468 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 25 May 2014 15:13:47 -0700
Subject: [PATCH 0300/1866] removes use of iterator == iterator

uses !(iterator != iterator) instead
---
 accumulate.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/accumulate.hpp b/accumulate.hpp
index f64f4924..ce48c9d8 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -63,7 +63,7 @@ namespace iter {
                         : sub_iter{iter},
                         sub_end{end},
                         accumulate_func(accumulate_func),
-                        acc_val(iter == end ? AccumVal{} : *iter)
+                        acc_val(!(iter != end) ? AccumVal{} : *iter)
                     { } 
 
                     AccumVal operator*() const {

From 843b7563b60d56d24fbd34b714759ef90aab34f5 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 25 May 2014 15:21:06 -0700
Subject: [PATCH 0301/1866] Support for initializer lists

---
 accumulate.hpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/accumulate.hpp b/accumulate.hpp
index ce48c9d8..dd3eee69 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -17,7 +17,7 @@ namespace iter {
     Accumulator<Container, AccumulateFunc> accumulate(
             Container &&, AccumulateFunc);
 
-    template <typename AccumulateFunc, typename T>
+    template <typename T, typename AccumulateFunc>
     Accumulator<std::initializer_list<T>, AccumulateFunc> accumulate(
             std::initializer_list<T> &&, AccumulateFunc);
 
@@ -31,7 +31,7 @@ namespace iter {
             friend Accumulator accumulate<Container, AccumulateFunc>(
                     Container &&, AccumulateFunc);
 
-            template <typename AF, typename T>
+            template <typename T, typename AF>
             friend Accumulator<std::initializer_list<T>, AF> accumulate(
                     std::initializer_list<T> &&, AF);
             
@@ -47,6 +47,7 @@ namespace iter {
             Accumulator(const Accumulator &) = default;
 
             class Iterator {
+                // AccumVal must be default constructible
                 using AccumVal =
                     typename std::result_of<AccumulateFunc(
                             iterator_deref<Container>,

From 19207660ca59a4e1c6b79f6c827fbb19f3a166c9 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 25 May 2014 15:36:59 -0700
Subject: [PATCH 0302/1866] AccumulateFunc defaults to std::plus

---
 accumulate.hpp | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/accumulate.hpp b/accumulate.hpp
index dd3eee69..ddb03dce 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -6,6 +6,7 @@
 #include <utility>
 #include <iterator>
 #include <initializer_list>
+#include <functional>
 
 namespace iter {
 
@@ -108,6 +109,15 @@ namespace iter {
         return {std::forward<Container>(container), accumulate_func};
     }
 
+    template <typename Container>
+    auto accumulate(Container && container) -> 
+        decltype(accumulate(std::forward<Container>(container),
+                    std::plus<iterator_deref<Container>>{}))
+    {
+        return accumulate(std::forward<Container>(container),
+                std::plus<iterator_deref<Container>>{});
+    }
+
     template <typename T, typename AccumulateFunc>
     Accumulator<std::initializer_list<T>, AccumulateFunc> accumulate(
             std::initializer_list<T> && il,
@@ -116,6 +126,13 @@ namespace iter {
         return {std::move(il), accumulate_func};
     }
 
+    template <typename T>
+    auto accumulate(std::initializer_list<T> && il) ->
+        decltype(accumulate(std::move(il), std::plus<T>{}))
+    {
+        return accumulate(std::move(il), std::plus<T>{});
+    }
+
 }
 
 #endif //ifndef ACCUMULATE__H__

From 5352d52e5ffb7ec1fda2fa75ec44a3c247f6cc55 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 25 May 2014 15:37:21 -0700
Subject: [PATCH 0303/1866] adds testaccumulate

---
 tests/testaccumulate.cpp | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 tests/testaccumulate.cpp

diff --git a/tests/testaccumulate.cpp b/tests/testaccumulate.cpp
new file mode 100644
index 00000000..a65bf7b9
--- /dev/null
+++ b/tests/testaccumulate.cpp
@@ -0,0 +1,29 @@
+#include <accumulate.hpp>
+#include <range.hpp>
+
+#include <iostream>
+#include <vector>
+
+int main() {
+    std::vector<int> vec = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+    for (auto v : iter::accumulate(vec, [](int a, int b){return a - b;})) {
+        std::cout << v << '\n';
+    }
+    for (auto v : iter::accumulate(iter::range(10),
+                [](int a, int b){return a - b;})) {
+        std::cout << v << '\n';
+    }
+    for (auto v : iter::accumulate({0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
+                [](int a, int b){return a - b;})) {
+        std::cout << v << '\n';
+    }
+
+    for (auto v : iter::accumulate(iter::range(10))) {
+        std::cout << v << '\n';
+    }
+    for (auto v : iter::accumulate({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})) {
+        std::cout << v << '\n';
+    }
+
+    return 0;
+}

From a32308971b51f9a5c87def5d4883dcb352a56400 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 25 May 2014 17:53:08 -0700
Subject: [PATCH 0304/1866] adds accumulate to the SConstruct

---
 tests/SConstruct | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tests/SConstruct b/tests/SConstruct
index 17e40444..e38c0914 100644
--- a/tests/SConstruct
+++ b/tests/SConstruct
@@ -2,7 +2,7 @@ import platform
 import os
 
 env = Environment(
-    CXX='g++',
+    CXX='c++',
     CXXFLAGS= ['-g', '-Wall', '-Wextra',
                '-pedantic', '-std=c++11',
                '-I/usr/local/include'],
@@ -13,6 +13,7 @@ env = Environment(
 env['ENV']['TERM'] = os.environ['TERM']
 
 progs = Split('''
+              accumulate
               cycle 
               enumerate 
               range 

From 693cf5aa2b2336d93d7e8d63e93e85b473ed3bc4 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 25 May 2014 17:56:03 -0700
Subject: [PATCH 0305/1866] adds accumulate to .gitignore

---
 tests/.gitignore | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tests/.gitignore b/tests/.gitignore
index a78678de..de362625 100644
--- a/tests/.gitignore
+++ b/tests/.gitignore
@@ -1,5 +1,6 @@
 *.o
 *.swp
+testaccumulate
 testchain
 testcycle
 testenumerate

From 0c4602081fe23a346d423cc9b4916ebebd27303e Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 25 May 2014 21:33:28 -0400
Subject: [PATCH 0306/1866] adds accumulate to README

---
 README.md | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/README.md b/README.md
index 03dcf0ff..f16cc894 100644
--- a/README.md
+++ b/README.md
@@ -20,6 +20,7 @@ evaluation wherever possible.
 [dropwhile](#dropwhile)<br />
 [cycle](#cycle)<br />
 [groupby](#groupby)<br />
+[accumulate](#accumulate)<br />
 [compress](#compress)<br />
 [chain](#chain)<br />
 [reverse](#reverse)<br />
@@ -233,6 +234,31 @@ for (auto gb : groupby(vec, [] (const string &s) {return s.length(); })) {
 It just iterates through, making a new group each time there is a key change.
 Thus, if the the group is unsorted, the same key may appear multiple times.
 
+accumulate
+-------
+Differs from `std::accumulate` (which in my humble opinion should be named 
+`std::reduce` or `std::foldl`).  It is imilar to a functional reduce where one 
+can see all of the intermediate results.  By default, it keeps a running sum.
+Prints: `1 3 6 10 15`
+```c++
+for (auto i : accumulate(range(1, 6))) {
+    cout << i << '\n';
+}
+```
+A second, optional argument may provide an alternative binary function 
+to compute results.  The following example multiplies the numbers, rather
+than adding them.
+Prints: `1 2 6 24 120`
+
+```c++
+for (auto i : accumulate(range(1, 6), std::multiplies<int>{})) {
+    cout << i << '\n';
+}
+```
+
+Note: The intermediate result type must support default construction
+and assignment.
+
 zip
 ---
 

From 23def64dc5fa948bc183eed0f0d891f44fe3c04c Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 25 May 2014 21:34:16 -0400
Subject: [PATCH 0307/1866] typo

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index f16cc894..d8a4bd0b 100644
--- a/README.md
+++ b/README.md
@@ -237,7 +237,7 @@ Thus, if the the group is unsorted, the same key may appear multiple times.
 accumulate
 -------
 Differs from `std::accumulate` (which in my humble opinion should be named 
-`std::reduce` or `std::foldl`).  It is imilar to a functional reduce where one 
+`std::reduce` or `std::foldl`).  It is similar to a functional reduce where one 
 can see all of the intermediate results.  By default, it keeps a running sum.
 Prints: `1 3 6 10 15`
 ```c++

From ce794cfee9119e36d376d1f723a4b2b29c60ec85 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 26 May 2014 12:10:22 -0700
Subject: [PATCH 0308/1866] formats enumerate

---
 enumerate.hpp | 19 +++++++++----------
 1 file changed, 9 insertions(+), 10 deletions(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index 7cb61263..fb34d534 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -25,11 +25,10 @@ namespace iter {
     class Enumerable;
 
     template <typename T>
-    Enumerable<std::initializer_list<T>> enumerate(
-            std::initializer_list<T> &&);
+    Enumerable<std::initializer_list<T>> enumerate(std::initializer_list<T>&&);
 
     template <typename Container>
-    Enumerable<Container> enumerate(Container &&);
+    Enumerable<Container> enumerate(Container&&);
 
     template <typename Container>
     class Enumerable {
@@ -38,19 +37,19 @@ namespace iter {
 
             // The only thing allowed to directly instantiate an Enumerable is
             // the enumerate function
-            friend Enumerable enumerate<Container>(Container &&);
+            friend Enumerable enumerate<Container>(Container&&);
             template <typename T>
             friend Enumerable<std::initializer_list<T>> enumerate(
-                    std::initializer_list<T> &&);
+                    std::initializer_list<T>&&);
 
-            Enumerable(Container && container) : container{container} { }
+            Enumerable(Container&& container) : container{container} { }
             
         public:
             // Value constructor for use only in the enumerate function
             Enumerable () = delete;
-            Enumerable & operator=(const Enumerable &) = delete;
+            Enumerable & operator=(const Enumerable&) = delete;
 
-            Enumerable(const Enumerable &) = default;
+            Enumerable(const Enumerable&) = default;
 
             // "yielded" by the Enumerable::Iterator.  Has a .index, and a 
             // .element referencing the value yielded by the subiterator
@@ -104,13 +103,13 @@ namespace iter {
 
     // Helper function to instantiate an Enumerable
     template <typename Container>
-    Enumerable<Container> enumerate(Container && container) {
+    Enumerable<Container> enumerate(Container&& container) {
         return {std::forward<Container>(container)};
     }
 
     template <typename T>
     Enumerable<std::initializer_list<T>> enumerate(
-            std::initializer_list<T> && il)
+            std::initializer_list<T>&& il)
     {
         return {std::move(il)};
     }

From a871e252b275a9a98195109bd777a90f574d8dc4 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 26 May 2014 12:11:12 -0700
Subject: [PATCH 0309/1866] formats accumulate

---
 accumulate.hpp | 23 ++++++++++++-----------
 1 file changed, 12 insertions(+), 11 deletions(-)

diff --git a/accumulate.hpp b/accumulate.hpp
index ddb03dce..d690dd74 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -16,11 +16,11 @@ namespace iter {
 
     template <typename Container, typename AccumulateFunc>
     Accumulator<Container, AccumulateFunc> accumulate(
-            Container &&, AccumulateFunc);
+            Container&&, AccumulateFunc);
 
     template <typename T, typename AccumulateFunc>
     Accumulator<std::initializer_list<T>, AccumulateFunc> accumulate(
-            std::initializer_list<T> &&, AccumulateFunc);
+            std::initializer_list<T>&&, AccumulateFunc);
 
     template <typename Container, typename AccumulateFunc>
     class Accumulator {
@@ -30,22 +30,22 @@ namespace iter {
 
             // The accumulate function is the only thing allowed to create a Accumulator
             friend Accumulator accumulate<Container, AccumulateFunc>(
-                    Container &&, AccumulateFunc);
+                    Container&&, AccumulateFunc);
 
             template <typename T, typename AF>
             friend Accumulator<std::initializer_list<T>, AF> accumulate(
-                    std::initializer_list<T> &&, AF);
+                    std::initializer_list<T>&&, AF);
             
             // Value constructor for use only in the accumulate function
-            Accumulator(Container && container, AccumulateFunc accumulate_func)
+            Accumulator(Container&& container, AccumulateFunc accumulate_func)
                 : container{container},
                 accumulate_func(accumulate_func)
             { }
             Accumulator () = delete;
-            Accumulator & operator=(const Accumulator &) = delete;
+            Accumulator & operator=(const Accumulator&) = delete;
 
         public:
-            Accumulator(const Accumulator &) = default;
+            Accumulator(const Accumulator&) = default;
 
             class Iterator {
                 // AccumVal must be default constructible
@@ -65,6 +65,7 @@ namespace iter {
                         : sub_iter{iter},
                         sub_end{end},
                         accumulate_func(accumulate_func),
+                        // only get first value if not an end iterator
                         acc_val(!(iter != end) ? AccumVal{} : *iter)
                     { } 
 
@@ -103,14 +104,14 @@ namespace iter {
     // Helper function to instantiate an Accumulator
     template <typename Container, typename AccumulateFunc>
     Accumulator<Container, AccumulateFunc> accumulate(
-            Container && container,
+            Container&& container,
             AccumulateFunc accumulate_func)
     {
         return {std::forward<Container>(container), accumulate_func};
     }
 
     template <typename Container>
-    auto accumulate(Container && container) -> 
+    auto accumulate(Container&& container) -> 
         decltype(accumulate(std::forward<Container>(container),
                     std::plus<iterator_deref<Container>>{}))
     {
@@ -120,14 +121,14 @@ namespace iter {
 
     template <typename T, typename AccumulateFunc>
     Accumulator<std::initializer_list<T>, AccumulateFunc> accumulate(
-            std::initializer_list<T> && il,
+            std::initializer_list<T>&& il,
             AccumulateFunc accumulate_func)
     {
         return {std::move(il), accumulate_func};
     }
 
     template <typename T>
-    auto accumulate(std::initializer_list<T> && il) ->
+    auto accumulate(std::initializer_list<T>&& il) ->
         decltype(accumulate(std::move(il), std::plus<T>{}))
     {
         return accumulate(std::move(il), std::plus<T>{});

From a0cba79f8f1e0f3145faf07408c98890eb963eea Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 26 May 2014 12:29:20 -0700
Subject: [PATCH 0310/1866] formats compress

---
 compress.hpp | 34 +++++++++++++++++-----------------
 1 file changed, 17 insertions(+), 17 deletions(-)

diff --git a/compress.hpp b/compress.hpp
index 376f432a..be56bec1 100644
--- a/compress.hpp
+++ b/compress.hpp
@@ -13,19 +13,19 @@ namespace iter {
     class Compressed;
 
     template <typename Container, typename Selector>
-    Compressed<Container, Selector> compress(Container &&, Selector &&);
+    Compressed<Container, Selector> compress(Container&&, Selector&&);
 
     template <typename T, typename Selector>
     Compressed<std::initializer_list<T>, Selector> compress(
-            std::initializer_list<T> &&, Selector &&);
+            std::initializer_list<T>&&, Selector&&);
 
     template <typename Container, typename T>
     Compressed<Container, std::initializer_list<T>> compress(
-            Container &&, std::initializer_list<T> &&);
+            Container&&, std::initializer_list<T>&&);
 
     template <typename T, typename U>
     Compressed<std::initializer_list<T>, std::initializer_list<U>> compress(
-            std::initializer_list<T> &&, std::initializer_list<U> &&);
+            std::initializer_list<T>&&, std::initializer_list<U>&&);
 
     template <typename Container, typename Selector>
     class Compressed  {
@@ -36,34 +36,34 @@ namespace iter {
             // The only thing allowed to directly instantiate an Compressed is
             // the compress function
             friend Compressed compress<Container, Selector>(
-                    Container &&, Selector &&);
+                    Container&&, Selector&&);
 
             template <typename T, typename Sel>
             friend Compressed<std::initializer_list<T>, Sel> compress(
-                    std::initializer_list<T> &&, Sel &&);
+                    std::initializer_list<T>&&, Sel&&);
 
             template <typename Con, typename T>
             friend Compressed<Con, std::initializer_list<T>> compress(
-                    Con &&, std::initializer_list<T> &&);
+                    Con&&, std::initializer_list<T>&&);
 
             template <typename T, typename U>
             friend Compressed<std::initializer_list<T>, std::initializer_list<U>> compress(
-                    std::initializer_list<T> &&, std::initializer_list<U> &&);
+                    std::initializer_list<T>&&, std::initializer_list<U>&&);
 
             
             // Selector::Iterator type
             using selector_iter_type = decltype(std::begin(selectors));
             
             // Value constructor for use only in the compress function
-            Compressed(Container && container, Selector && selectors)
+            Compressed(Container&& container, Selector&& selectors)
                 : container{container},
                 selectors{selectors}
             { }
-            Compressed () = delete;
-            Compressed & operator=(const Compressed &) = delete;
+            Compressed() = delete;
+            Compressed& operator=(const Compressed&) = delete;
 
         public:
-            Compressed (const Compressed &) = default;
+            Compressed(const Compressed&) = default;
 
             class Iterator {
                 private:
@@ -130,29 +130,29 @@ namespace iter {
     // Helper function to instantiate an Compressed
     template <typename Container, typename Selector>
     Compressed<Container, Selector> compress(
-            Container && container, Selector && selectors) {
+            Container&& container, Selector&& selectors) {
         return {std::forward<Container>(container),
                 std::forward<Selector>(selectors)};
     }
 
     template <typename T, typename Selector>
     Compressed<std::initializer_list<T>, Selector> compress(
-            std::initializer_list<T> && data, Selector && selectors) {
+            std::initializer_list<T>&& data, Selector&& selectors) {
         return {std::move(data),
                 std::forward<Selector>(selectors)};
     }
 
     template <typename Container, typename T>
     Compressed<Container, std::initializer_list<T>> compress(
-            Container && container, std::initializer_list<T> && selectors) {
+            Container&& container, std::initializer_list<T>&& selectors) {
         return {std::forward<Container>(container),
                 std::move(selectors)};
     }
 
     template <typename T, typename U>
     Compressed<std::initializer_list<T>, std::initializer_list<U>> compress(
-            std::initializer_list<T> && data,
-            std::initializer_list<U> && selectors) {
+            std::initializer_list<T>&& data,
+            std::initializer_list<U>&& selectors) {
         return {std::move(data),
                 std::move(selectors)};
     }

From 6b03d9b05caae961ad3b38ca445a5662c8a58d79 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 26 May 2014 12:31:19 -0700
Subject: [PATCH 0311/1866] formats cycle

---
 cycle.hpp | 21 ++++++++++-----------
 1 file changed, 10 insertions(+), 11 deletions(-)

diff --git a/cycle.hpp b/cycle.hpp
index 605aa2ab..8d5245bf 100644
--- a/cycle.hpp
+++ b/cycle.hpp
@@ -14,30 +14,29 @@ namespace iter {
     class Cycle;
 
     template <typename Container>
-    Cycle<Container> cycle(Container &&);
+    Cycle<Container> cycle(Container&&);
 
     template <typename T>
-    Cycle<std::initializer_list<T>> cycle(
-            std::initializer_list<T> &&);
+    Cycle<std::initializer_list<T>> cycle(std::initializer_list<T>&&);
 
     template <typename Container>
     class Cycle {
         private:
             // The cycle function is the only thing allowed to create a Cycle
-            friend Cycle cycle<Container>(Container &&);
+            friend Cycle cycle<Container>(Container&&);
             template <typename T>
             friend Cycle<std::initializer_list<T>> cycle(
-                    std::initializer_list<T> &&);
+                    std::initializer_list<T>&&);
 
             Container & container;
             
             // Value constructor for use only in the cycle function
-            Cycle(Container && container) : container{container} { }
-            Cycle () = delete;
-            Cycle & operator=(const Cycle &) = delete;
+            Cycle(Container&& container) : container{container} { }
+            Cycle() = delete;
+            Cycle& operator=(const Cycle&) = delete;
 
         public:
-            Cycle(const Cycle &) = default;
+            Cycle(const Cycle&) = default;
             class Iterator {
                 private:
                     using iter_type = iterator_type<Container>;
@@ -88,12 +87,12 @@ namespace iter {
 
     // Helper function to instantiate an Filter
     template <typename Container>
-    Cycle<Container> cycle(Container && container) {
+    Cycle<Container> cycle(Container&& container) {
         return {std::forward<Container>(container)};
     }
 
     template <typename T>
-    Cycle<std::initializer_list<T>> cycle(std::initializer_list<T> && il)
+    Cycle<std::initializer_list<T>> cycle(std::initializer_list<T>&& il)
     {
         return {std::move(il)};
     }

From 2e166a3fc5eefedec17edc91ce1cd59e5fd29528 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 26 May 2014 12:38:25 -0700
Subject: [PATCH 0312/1866] formats enumerate

---
 enumerate.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index fb34d534..849c7533 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -33,7 +33,7 @@ namespace iter {
     template <typename Container>
     class Enumerable {
         private:
-            Container & container;
+            Container& container;
 
             // The only thing allowed to directly instantiate an Enumerable is
             // the enumerate function

From 4abe724a9341d3e7f4faad907b13e5c37a7d3235 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 26 May 2014 12:38:50 -0700
Subject: [PATCH 0313/1866] formats accumulate

---
 accumulate.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/accumulate.hpp b/accumulate.hpp
index d690dd74..0e07bf47 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -25,7 +25,7 @@ namespace iter {
     template <typename Container, typename AccumulateFunc>
     class Accumulator {
         private:
-            Container & container;
+            Container& container;
             AccumulateFunc accumulate_func;
 
             // The accumulate function is the only thing allowed to create a Accumulator

From 096fc81b89e4f64c953e0197b2f62962dc1a9541 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 26 May 2014 12:39:13 -0700
Subject: [PATCH 0314/1866] formats compress

---
 compress.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compress.hpp b/compress.hpp
index be56bec1..b18d7d0b 100644
--- a/compress.hpp
+++ b/compress.hpp
@@ -30,7 +30,7 @@ namespace iter {
     template <typename Container, typename Selector>
     class Compressed  {
         private:
-            Container & container;
+            Container& container;
             Selector & selectors;
 
             // The only thing allowed to directly instantiate an Compressed is

From 5e566820cb9f829de114205c1f5b8c8e2a3ac0c8 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 26 May 2014 12:39:38 -0700
Subject: [PATCH 0315/1866] formats cycle

---
 cycle.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cycle.hpp b/cycle.hpp
index 8d5245bf..13c4b1f0 100644
--- a/cycle.hpp
+++ b/cycle.hpp
@@ -28,7 +28,7 @@ namespace iter {
             friend Cycle<std::initializer_list<T>> cycle(
                     std::initializer_list<T>&&);
 
-            Container & container;
+            Container& container;
             
             // Value constructor for use only in the cycle function
             Cycle(Container&& container) : container{container} { }

From 65477d6606846534578ff2d19cb47044b57001b3 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 26 May 2014 12:40:36 -0700
Subject: [PATCH 0316/1866] formats dropwhile

---
 dropwhile.hpp | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/dropwhile.hpp b/dropwhile.hpp
index 2d298425..0393845e 100644
--- a/dropwhile.hpp
+++ b/dropwhile.hpp
@@ -14,35 +14,35 @@ namespace iter {
     class DropWhile;
 
     template <typename FilterFunc, typename Container>
-    DropWhile<FilterFunc, Container> dropwhile(FilterFunc, Container &&);
+    DropWhile<FilterFunc, Container> dropwhile(FilterFunc, Container&&);
 
     template <typename FilterFunc, typename T>
     DropWhile<FilterFunc, std::initializer_list<T>> dropwhile(
-            FilterFunc, std::initializer_list<T> &&);
+            FilterFunc, std::initializer_list<T>&&);
 
     template <typename FilterFunc, typename Container>
     class DropWhile  {
         private:
-            Container & container;
+            Container& container;
             FilterFunc filter_func;
 
             friend DropWhile dropwhile<FilterFunc, Container>(
-                    FilterFunc, Container &&);
+                    FilterFunc, Container&&);
 
             template <typename FF, typename T>
             friend DropWhile<FF, std::initializer_list<T>> dropwhile(
-                    FF, std::initializer_list<T> &&);
+                    FF, std::initializer_list<T>&&);
             
             // Value constructor for use only in the dropwhile function
-            DropWhile(FilterFunc filter_func, Container && container)
+            DropWhile(FilterFunc filter_func, Container&& container)
                 : container{container},
                 filter_func(filter_func)
             { }
-            DropWhile () = delete;
-            DropWhile & operator=(const DropWhile &) = delete;
+            DropWhile() = delete;
+            DropWhile& operator=(const DropWhile&) = delete;
 
         public:
-            DropWhile(const DropWhile &) = default;
+            DropWhile(const DropWhile&) = default;
             class Iterator {
                 private:
                     iterator_type<Container> sub_iter;
@@ -99,13 +99,13 @@ namespace iter {
     // Helper function to instantiate a DropWhile
     template <typename FilterFunc, typename Container>
     DropWhile<FilterFunc, Container> dropwhile(
-            FilterFunc filter_func, Container && container) {
+            FilterFunc filter_func, Container&& container) {
         return {filter_func, std::forward<Container>(container)};
     }
 
     template <typename FilterFunc, typename T>
     DropWhile<FilterFunc, std::initializer_list<T>> dropwhile(
-            FilterFunc filter_func, std::initializer_list<T> && il)
+            FilterFunc filter_func, std::initializer_list<T>&& il)
     {
         return {filter_func, std::move(il)};
     }

From 6bafad489ae453419d02d5266c981a71b85d63a0 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 26 May 2014 12:42:48 -0700
Subject: [PATCH 0317/1866] formats filterfalse

---
 filterfalse.hpp | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/filterfalse.hpp b/filterfalse.hpp
index dfd2716c..3beaaef3 100644
--- a/filterfalse.hpp
+++ b/filterfalse.hpp
@@ -23,7 +23,7 @@ namespace iter {
                 { }
 
                 PredicateFlipper() = delete;
-                PredicateFlipper(const PredicateFlipper &) = default;
+                PredicateFlipper(const PredicateFlipper&) = default;
 
                 // Calls the filter_func 
                 bool operator() (const iterator_deref<Container> item) const {
@@ -48,7 +48,7 @@ namespace iter {
     // the bool result of the function.  The PredicateFlipper is then passed
     // to the normal filter() function
     template <typename FilterFunc, typename Container>
-    auto filterfalse(FilterFunc filter_func, Container && container) ->
+    auto filterfalse(FilterFunc filter_func, Container&& container) ->
             decltype(filter(
                         detail::PredicateFlipper<FilterFunc, Container>(
                             filter_func),
@@ -61,7 +61,7 @@ namespace iter {
     // Single argument version, uses a BoolFlipper to reverse the truthiness
     // of an object
     template <typename Container>
-    auto filterfalse(Container && container) ->
+    auto filterfalse(Container&& container) ->
             decltype(filter(
                         detail::BoolFlipper<Container>(),
                         std::forward<Container>(container))) {
@@ -74,7 +74,7 @@ namespace iter {
 
     //specializations for initializer_lists
     template <typename FilterFunc, typename T>
-    auto filterfalse(FilterFunc filter_func, std::initializer_list<T> && container) ->
+    auto filterfalse(FilterFunc filter_func, std::initializer_list<T>&& container) ->
             decltype(filter(
                         detail::PredicateFlipper<FilterFunc, std::initializer_list<T>>(
                             filter_func),
@@ -87,7 +87,7 @@ namespace iter {
     // Single argument version, uses a BoolFlipper to reverse the truthiness
     // of an object
     template <typename T>
-    auto filterfalse(std::initializer_list<T> && container) ->
+    auto filterfalse(std::initializer_list<T>&& container) ->
             decltype(filter(
                         detail::BoolFlipper<std::initializer_list<T>>(),
                         std::move(container))) {

From f8e51d05cb262141ed503a49bf224c8e02847c3f Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 26 May 2014 12:48:32 -0700
Subject: [PATCH 0318/1866] formats accumulate

---
 accumulate.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/accumulate.hpp b/accumulate.hpp
index 0e07bf47..792a27aa 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -73,7 +73,7 @@ namespace iter {
                         return this->acc_val;
                     }
 
-                    Iterator & operator++() { 
+                    Iterator& operator++() { 
                         ++this->sub_iter;
                         if (this->sub_iter != this->sub_end) {
                             this->acc_val = accumulate_func(
@@ -82,7 +82,7 @@ namespace iter {
                         return *this;
                     }
 
-                    bool operator!=(const Iterator & other) const {
+                    bool operator!=(const Iterator& other) const {
                         return this->sub_iter != other.sub_iter;
                     }
             };

From c140d44a80f74746bb2714d073b25e32513bf100 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 26 May 2014 12:48:46 -0700
Subject: [PATCH 0319/1866] formats compress.hpp

---
 compress.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/compress.hpp b/compress.hpp
index b18d7d0b..34aa22cf 100644
--- a/compress.hpp
+++ b/compress.hpp
@@ -103,13 +103,13 @@ namespace iter {
                         return *this->sub_iter;
                     }
 
-                    Iterator & operator++() { 
+                    Iterator& operator++() { 
                         this->increment_iterators();
                         this->skip_failures();
                         return *this;
                     }
 
-                    bool operator!=(const Iterator & other) const {
+                    bool operator!=(const Iterator& other) const {
                         return this->sub_iter != other.sub_iter &&
                             this->selector_iter != other.selector_iter;
                     }

From 1c60e66e4f8e78cb98cc0edf7690be8a11b2f75d Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 26 May 2014 12:49:01 -0700
Subject: [PATCH 0320/1866] formats cycle

---
 cycle.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/cycle.hpp b/cycle.hpp
index 13c4b1f0..7dc76424 100644
--- a/cycle.hpp
+++ b/cycle.hpp
@@ -55,7 +55,7 @@ namespace iter {
                         return *this->sub_iter;
                     }
 
-                    Iterator & operator++() { 
+                    Iterator& operator++() { 
                         ++this->sub_iter;
                         // reset to beginning upon reaching the end
                         if (!(this->sub_iter != this->end)) {
@@ -68,7 +68,7 @@ namespace iter {
                         return *this;
                     }
 
-                    constexpr bool operator!=(const Iterator &) const {
+                    constexpr bool operator!=(const Iterator&) const {
                         return true;
                     }
             };

From 30cf448b1889ca025e896e84854324f66f00e12c Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 26 May 2014 12:49:17 -0700
Subject: [PATCH 0321/1866] formats dropwhile

---
 dropwhile.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/dropwhile.hpp b/dropwhile.hpp
index 0393845e..724f0122 100644
--- a/dropwhile.hpp
+++ b/dropwhile.hpp
@@ -72,12 +72,12 @@ namespace iter {
                         return *this->sub_iter;
                     }
 
-                    Iterator & operator++() { 
+                    Iterator& operator++() { 
                         ++this->sub_iter;
                         return *this;
                     }
 
-                    bool operator!=(const Iterator & other) const {
+                    bool operator!=(const Iterator& other) const {
                         return this->sub_iter != other.sub_iter;
                     }
             };

From bcd74f84cdb819d71dac5ade32bee0fdca39f564 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 26 May 2014 12:49:25 -0700
Subject: [PATCH 0322/1866] formats enumerate

---
 enumerate.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index 849c7533..6ff3faae 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -80,13 +80,13 @@ namespace iter {
                         return IterYield(this->index, *this->sub_iter);
                     }
 
-                    Iterator & operator++() { 
+                    Iterator& operator++() { 
                         ++this->sub_iter;
                         ++this->index;
                         return *this;
                     }
 
-                    bool operator!=(const Iterator & other) const {
+                    bool operator!=(const Iterator& other) const {
                         return this->sub_iter != other.sub_iter;
                     }
             };

From 53756ab579e9f93ba19c822b5abd2083d831675d Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 26 May 2014 12:49:58 -0700
Subject: [PATCH 0323/1866] formats filter

---
 filter.hpp | 32 ++++++++++++++++----------------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/filter.hpp b/filter.hpp
index 143cc9e8..f6695d44 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -14,36 +14,36 @@ namespace iter {
     class Filter;
 
     template <typename FilterFunc, typename Container>
-    Filter<FilterFunc, Container> filter(FilterFunc, Container &&);
+    Filter<FilterFunc, Container> filter(FilterFunc, Container&&);
 
     template <typename FilterFunc, typename T>
     Filter<FilterFunc, std::initializer_list<T>> filter(
-            FilterFunc, std::initializer_list<T> &&);
+            FilterFunc, std::initializer_list<T>&&);
 
     template <typename FilterFunc, typename Container>
     class Filter {
         private:
-            Container & container;
+            Container& container;
             FilterFunc filter_func;
 
             // The filter function is the only thing allowed to create a Filter
             friend Filter filter<FilterFunc, Container>(
-                    FilterFunc, Container &&);
+                    FilterFunc, Container&&);
 
             template <typename FF, typename T>
             friend Filter<FF, std::initializer_list<T>> filter(
-                    FF, std::initializer_list<T> &&);
+                    FF, std::initializer_list<T>&&);
             
             // Value constructor for use only in the filter function
-            Filter(FilterFunc filter_func, Container && container)
+            Filter(FilterFunc filter_func, Container&& container)
                 : container{container},
                 filter_func(filter_func)
             { }
-            Filter () = delete;
-            Filter & operator=(const Filter &) = delete;
+            Filter() = delete;
+            Filter& operator=(const Filter&) = delete;
 
         public:
-            Filter(const Filter &) = default;
+            Filter(const Filter&) = default;
 
             class Iterator {
                 protected:
@@ -75,13 +75,13 @@ namespace iter {
                         return *this->sub_iter;
                     }
 
-                    Iterator & operator++() { 
+                    Iterator& operator++() { 
                         ++this->sub_iter;
                         this->skip_failures();
                         return *this;
                     }
 
-                    bool operator!=(const Iterator & other) const {
+                    bool operator!=(const Iterator& other) const {
                         return this->sub_iter != other.sub_iter;
                     }
             };
@@ -103,14 +103,14 @@ namespace iter {
     // Helper function to instantiate a Filter
     template <typename FilterFunc, typename Container>
     Filter<FilterFunc, Container> filter(
-            FilterFunc filter_func, Container && container) {
+            FilterFunc filter_func, Container&& container) {
         return {filter_func, std::forward<Container>(container)};
     }
 
     template <typename FilterFunc, typename T>
     Filter<FilterFunc, std::initializer_list<T>> filter(
             FilterFunc filter_func,
-            std::initializer_list<T> && il)
+            std::initializer_list<T>&& il)
     {
         return {filter_func, std::move(il)};
     }
@@ -118,7 +118,7 @@ namespace iter {
     namespace detail {
 
         template <typename T>
-        bool boolean_cast(const T & t) {
+        bool boolean_cast(const T& t) {
             return bool(t);
         }
 
@@ -133,7 +133,7 @@ namespace iter {
 
 
     template <typename Container>
-    auto filter(Container && container) ->
+    auto filter(Container&& container) ->
             decltype(filter(
                         detail::BoolTester<Container>(),
                         std::forward<Container>(container))) {
@@ -143,7 +143,7 @@ namespace iter {
     }
 
     template <typename T>
-    auto filter(std::initializer_list<T> && il) ->
+    auto filter(std::initializer_list<T>&& il) ->
             decltype(filter(
                         detail::BoolTester<std::initializer_list<T>>(),
                         std::move(il))) {

From d0b4c03f95af6c3c2a51d669842a385dd3905756 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 26 May 2014 12:55:02 -0700
Subject: [PATCH 0324/1866] formats groupby

---
 groupby.hpp | 60 ++++++++++++++++++++++++++---------------------------
 1 file changed, 30 insertions(+), 30 deletions(-)

diff --git a/groupby.hpp b/groupby.hpp
index c4868897..8c63f0f4 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -13,23 +13,23 @@ namespace iter {
     class GroupBy;
 
     template <typename Container, typename KeyFunc>
-    GroupBy<Container, KeyFunc> groupby(Container &&, KeyFunc);
+    GroupBy<Container, KeyFunc> groupby(Container&&, KeyFunc);
 
     template <typename T, typename KeyFunc>
     GroupBy<std::initializer_list<T>, KeyFunc> groupby(
-            std::initializer_list<T> &&, KeyFunc);
+            std::initializer_list<T>&&, KeyFunc);
 
     template <typename Container, typename KeyFunc>
     class GroupBy  {
         private:
-            Container & container;
+            Container& container;
             KeyFunc key_func;
 
-            friend GroupBy groupby<Container, KeyFunc>(Container &&, KeyFunc);
+            friend GroupBy groupby<Container, KeyFunc>(Container&&, KeyFunc);
 
             template <typename T, typename KF>
             friend GroupBy<std::initializer_list<T>, KF> groupby(
-                    std::initializer_list<T> &&, KF);
+                    std::initializer_list<T>&&, KF);
 
             
 
@@ -39,18 +39,18 @@ namespace iter {
                 decltype(std::declval<KeyFunc>()(
                             std::declval<iterator_deref<Container>>()));
 
-            GroupBy(Container && container, KeyFunc key_func)
+            GroupBy(Container&& container, KeyFunc key_func)
                 : container{container},
                 key_func(key_func)
             { }
 
         public:
-            GroupBy () = delete;
-            GroupBy(const GroupBy &) = delete;
-            GroupBy& operator=(const GroupBy &) = delete;
+            GroupBy() = delete;
+            GroupBy(const GroupBy&) = delete;
+            GroupBy& operator=(const GroupBy&) = delete;
 
-            GroupBy (GroupBy &&) = default;
-            GroupBy & operator=(GroupBy &&) = default;
+            GroupBy(GroupBy&&) = default;
+            GroupBy& operator=(GroupBy&&) = default;
 
             class Iterator;
             class Group;
@@ -82,11 +82,11 @@ namespace iter {
                                     this->key_func(*this->sub_iter)));
                     }
 
-                    Iterator & operator++() { 
+                    Iterator& operator++() { 
                         return *this;
                     }
 
-                    bool operator!=(const Iterator &) const {
+                    bool operator!=(const Iterator&) const {
                         return !this->exhausted();
                     }
 
@@ -114,7 +114,7 @@ namespace iter {
                 private:
                     friend Iterator;
                     friend class GroupIterator;
-                    Iterator & owner;
+                    Iterator& owner;
                     key_func_ret key;
 
                     // completed is set if a Group is iterated through
@@ -128,7 +128,7 @@ namespace iter {
                     // when called.
                     mutable bool completed = false;
 
-                    Group(Iterator & owner, key_func_ret key) :
+                    Group(Iterator& owner, key_func_ret key) :
                         owner(owner),
                         key(key)
                     { }
@@ -143,12 +143,12 @@ namespace iter {
                     }
                            
                     // movable, non-copyable
-                    Group () = delete;
-                    Group (const Group &) = delete;
-                    Group & operator=(const Group &) = delete;
+                    Group() = delete;
+                    Group(const Group&) = delete;
+                    Group& operator=(const Group&) = delete;
 
-                    Group & operator=(Group &&) = default;
-                    Group (Group && other)
+                    Group& operator=(Group&&) = default;
+                    Group(Group&& other)
                             : owner{other.owner},
                             key{other.key},
                             completed{other.completed} {
@@ -158,23 +158,23 @@ namespace iter {
                     class GroupIterator {
                         private:
                             const key_func_ret key;
-                            const Group & group;
+                            const Group& group;
 
                             bool not_at_end() const {
-                                return !this->group.owner.exhausted() &&
+                                return !this->group.owner.exhausted()&&
                                     this->group.owner.next_key() == this->key;
                             }
 
                         public:
-                            GroupIterator(const Group & group,
+                            GroupIterator(const Group& group,
                                           key_func_ret key)
                                 : key{key},
                                 group{group}
                             { }
 
-                            GroupIterator(const GroupIterator &) = default;
+                            GroupIterator(const GroupIterator&) = default;
 
-                            bool operator!=(const GroupIterator &) const {
+                            bool operator!=(const GroupIterator&) const {
                                 if (this->not_at_end()) {
                                     return true;
                                 } else {
@@ -183,7 +183,7 @@ namespace iter {
                                 }
                             }
 
-                            GroupIterator & operator++() {
+                            GroupIterator& operator++() {
                                 this->group.owner.increment_iterator();
                                 return *this;
                             }
@@ -233,13 +233,13 @@ namespace iter {
 
     template <typename Container, typename KeyFunc>
     GroupBy<Container, KeyFunc> groupby(
-            Container && container, KeyFunc key_func) {
+            Container&& container, KeyFunc key_func) {
         return {std::forward<Container>(container), key_func};
     }
 
 
     template <typename Container>
-    auto groupby(Container && container) ->
+    auto groupby(Container&& container) ->
             decltype(groupby(std::forward<Container>(container),
                         ItemReturner<Container>())) {
         return groupby(std::forward<Container>(container),
@@ -249,13 +249,13 @@ namespace iter {
     
     template <typename T, typename KeyFunc>
     GroupBy<std::initializer_list<T>, KeyFunc> groupby(
-            std::initializer_list<T> && il, KeyFunc key_func) {
+            std::initializer_list<T>&& il, KeyFunc key_func) {
         return {std::move(il), key_func};
     }
 
 
     template <typename T>
-    auto groupby(std::initializer_list<T> && il) ->
+    auto groupby(std::initializer_list<T>&& il) ->
             decltype(groupby(std::move(il),
                         ItemReturner<std::initializer_list<T>>())) {
         return groupby(

From 8378aa2183b9a466b848c6e460433b03159211d9 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 26 May 2014 13:01:02 -0700
Subject: [PATCH 0325/1866] Removes move assignment from GroupBy

---
 groupby.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/groupby.hpp b/groupby.hpp
index 8c63f0f4..39cce2f8 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -48,9 +48,9 @@ namespace iter {
             GroupBy() = delete;
             GroupBy(const GroupBy&) = delete;
             GroupBy& operator=(const GroupBy&) = delete;
+            GroupBy& operator=(GroupBy&&) = delete;
 
             GroupBy(GroupBy&&) = default;
-            GroupBy& operator=(GroupBy&&) = default;
 
             class Iterator;
             class Group;
@@ -146,8 +146,8 @@ namespace iter {
                     Group() = delete;
                     Group(const Group&) = delete;
                     Group& operator=(const Group&) = delete;
+                    Group& operator=(Group&&) = delete;
 
-                    Group& operator=(Group&&) = default;
                     Group(Group&& other)
                             : owner{other.owner},
                             key{other.key},

From 33d5c6dcaf83d1b5ea120e9aa99b36b79571786a Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 26 May 2014 13:03:17 -0700
Subject: [PATCH 0326/1866] formats imap

---
 imap.hpp | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/imap.hpp b/imap.hpp
index 6eeaaae8..40003417 100644
--- a/imap.hpp
+++ b/imap.hpp
@@ -18,7 +18,7 @@ namespace iter {
         template <typename F, typename Tuple, bool Done, int Total, int... N>
         struct call_impl
         {
-            static auto call(F f, Tuple && t) -> 
+            static auto call(F f, Tuple&& t) -> 
                 decltype(call_impl<F,
                     Tuple,
                     Total == 1 + sizeof...(N),
@@ -38,7 +38,7 @@ namespace iter {
         template <typename F, typename Tuple, int Total, int... N>
         struct call_impl<F, Tuple, true, Total, N...>
         {
-            static auto call(F f, Tuple && t) -> 
+            static auto call(F f, Tuple&& t) -> 
                 decltype(f(std::get<N>(std::forward<Tuple>(t))...))
             {
                 return f(std::get<N>(std::forward<Tuple>(t))...);
@@ -47,7 +47,7 @@ namespace iter {
 
         // user invokes this
         template <typename F, typename Tuple>
-        auto call(F f, Tuple && t) -> 
+        auto call(F f, Tuple&& t) -> 
             decltype(call_impl<F,
                 Tuple,
                 0 == std::tuple_size<typename std::decay<Tuple>::type>::value,
@@ -67,12 +67,12 @@ namespace iter {
     class IMap;
 
     template <typename MapFunc, typename... Containers>
-    IMap<MapFunc, Containers...> imap(MapFunc, Containers &&...);
+    IMap<MapFunc, Containers...> imap(MapFunc, Containers&&...);
 
     template <typename MapFunc, typename... Containers>
     class IMap {
         // The imap function is the only thing allowed to create a IMap
-        friend IMap imap<MapFunc, Containers...>(MapFunc, Containers && ...);
+        friend IMap imap<MapFunc, Containers...>(MapFunc, Containers&& ...);
 
         // The type returned when dereferencing the Containers...::Iterator
         // XXX depends on zip using iterator_range.  would be nice if it didn't
@@ -87,15 +87,15 @@ namespace iter {
             Zipped zipped;
             
             // Value constructor for use only in the imap function
-            IMap(MapFunc map_func, Containers && ... containers) :
+            IMap(MapFunc map_func, Containers&& ... containers) :
                 map_func(map_func),
                 zipped(zip(std::forward<Containers>(containers)...))
             { }
-            IMap () = delete;
-            IMap & operator=(const IMap &) = delete;
+            IMap() = delete;
+            IMap& operator=(const IMap&) = delete;
 
         public:
-            IMap (const IMap &) = default;
+            IMap(const IMap&) = default;
 
             class Iterator {
                 private:
@@ -114,12 +114,12 @@ namespace iter {
                         return detail::call(this->map_func, *(this->zipiter));
                     }
 
-                    Iterator & operator++() { 
+                    Iterator& operator++() { 
                         ++this->zipiter;
                         return *this;
                     }
 
-                    bool operator!=(const Iterator & other) const {
+                    bool operator!=(const Iterator& other) const {
                         return this->zipiter != other.zipiter;
                     }
             };
@@ -137,7 +137,7 @@ namespace iter {
     // Helper function to instantiate a IMap
     template <typename MapFunc, typename... Containers>
     IMap<MapFunc, Containers...> imap(
-            MapFunc map_func, Containers && ... containers) {
+            MapFunc map_func, Containers&& ... containers) {
         return {map_func, std::forward<Containers>(containers)...};
     }
 

From 24192e769096401eefb30f54be192e2025404e2d Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 26 May 2014 13:04:28 -0700
Subject: [PATCH 0327/1866] formats range

---
 range.hpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/range.hpp b/range.hpp
index 28d3e6a7..5359379c 100644
--- a/range.hpp
+++ b/range.hpp
@@ -62,7 +62,7 @@ namespace iter {
 
         public:
             Range() = delete;
-            Range(const Range &) = default;
+            Range(const Range&) = default;
             class Iterator {
                 private:
                     T value;
@@ -90,7 +90,7 @@ namespace iter {
                         return this->value;
                     }
 
-                    Iterator & operator++() {
+                    Iterator& operator++() {
                         this->value += this->step;
                         return *this;
                     }
@@ -108,7 +108,7 @@ namespace iter {
                     // 2) (stop - start) % step != 0.  For
                     // example Range(1, 10, 2).  The iterator will never be
                     // exactly equal to the stop value.
-                    bool operator!=(const Iterator & other) const { 
+                    bool operator!=(const Iterator& other) const { 
                         return not_equal_to(
                                 other, typename std::is_unsigned<T>::type());
                     }

From d4a7bc827164a48ab9bb346c192534dadb21dea3 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 26 May 2014 13:05:45 -0700
Subject: [PATCH 0328/1866] formats sorted

---
 sorted.hpp | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/sorted.hpp b/sorted.hpp
index ce824541..15d36b22 100644
--- a/sorted.hpp
+++ b/sorted.hpp
@@ -12,22 +12,22 @@ namespace iter {
     class Sorted;
 
     template <typename Container, typename CompareFunc>
-    Sorted<Container, CompareFunc> sorted(Container &, CompareFunc);
+    Sorted<Container, CompareFunc> sorted(Container&, CompareFunc);
 
     template <typename Container, typename CompareFunc>
     class Sorted  {
         private:
             friend Sorted
-                sorted<Container, CompareFunc>(Container &, CompareFunc);
+                sorted<Container, CompareFunc>(Container&, CompareFunc);
 
             std::vector<iterator_type<Container>> sorted_iters;
 
             using sorted_iter_type = decltype(std::begin(sorted_iters));
 
             Sorted() = delete;
-            Sorted & operator=(const Sorted &) = delete;
+            Sorted& operator=(const Sorted&) = delete;
 
-            Sorted(Container & container, CompareFunc compare_func) {
+            Sorted(Container& container, CompareFunc compare_func) {
                 // Fill the sorted_iters vector with an iterator to each
                 // element in the container
                 for (auto iter = std::begin(container);
@@ -38,14 +38,14 @@ namespace iter {
 
                 // sort by comparing the elements that the iterators point to
                 std::sort(std::begin(sorted_iters), std::end(sorted_iters),
-                        [&] (const iterator_type<Container> & it1,
-                            const iterator_type<Container> & it2)
+                        [&] (const iterator_type<Container>& it1,
+                            const iterator_type<Container>& it2)
                         { return compare_func(*it1, *it2); });
             }
 
         public:
 
-            Sorted(const Sorted &) = default;
+            Sorted(const Sorted&) = default;
 
             // Iterates over a series of Iterators, automatically dereferencing
             // them when accessed with operator *
@@ -54,7 +54,7 @@ namespace iter {
                     IteratorIterator(sorted_iter_type iter)
                         : sorted_iter_type{iter}
                     { }
-                    IteratorIterator(const IteratorIterator &) = default;
+                    IteratorIterator(const IteratorIterator&) = default;
 
                     // Dereference the current iterator before returning
                     iterator_deref<Container> operator*() {
@@ -74,12 +74,12 @@ namespace iter {
 
     template <typename Container, typename CompareFunc>
     Sorted<Container, CompareFunc> sorted(
-            Container & container, CompareFunc compare_func) {
+            Container& container, CompareFunc compare_func) {
         return {container, compare_func};
     }
 
     template <typename Container>
-    auto sorted(Container & container) ->
+    auto sorted(Container& container) ->
              decltype(sorted(
                          container,
                          std::less<decltype(

From 27a1c6789b134c8c068bd390c102f67ceddc189f Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 26 May 2014 13:06:37 -0700
Subject: [PATCH 0329/1866] formats takewhile

---
 takewhile.hpp | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/takewhile.hpp b/takewhile.hpp
index 92937e20..d534b2f2 100644
--- a/takewhile.hpp
+++ b/takewhile.hpp
@@ -14,36 +14,36 @@ namespace iter {
     class TakeWhile;
 
     template <typename FilterFunc, typename Container>
-    TakeWhile<FilterFunc, Container> takewhile(FilterFunc, Container &&);
+    TakeWhile<FilterFunc, Container> takewhile(FilterFunc, Container&&);
 
     template <typename FilterFunc, typename T>
     TakeWhile<FilterFunc, std::initializer_list<T>> takewhile(
-            FilterFunc, std::initializer_list<T> &&);
+            FilterFunc, std::initializer_list<T>&&);
 
     template <typename FilterFunc, typename Container>
     class TakeWhile {
         private:
-            Container & container;
+            Container& container;
             FilterFunc filter_func;
 
             friend TakeWhile takewhile<FilterFunc, Container>(
-                    FilterFunc, Container &&);
+                    FilterFunc, Container&&);
 
             template <typename FF, typename T>
             friend TakeWhile<FF, std::initializer_list<T>> takewhile(
-                    FF, std::initializer_list<T> &&);
+                    FF, std::initializer_list<T>&&);
 
             // Value constructor for use only in the takewhile function
-            TakeWhile(FilterFunc filter_func, Container && container)
+            TakeWhile(FilterFunc filter_func, Container&& container)
                 : container{container},
                 filter_func(filter_func)
             { }
 
             TakeWhile () = delete;
-            TakeWhile & operator=(const TakeWhile &) = delete;
+            TakeWhile& operator=(const TakeWhile&) = delete;
 
         public:
-            TakeWhile(const TakeWhile &) = default;
+            TakeWhile(const TakeWhile&) = default;
 
             class Iterator {
                 private:
@@ -82,13 +82,13 @@ namespace iter {
                         return *this->sub_iter;
                     }
 
-                    Iterator & operator++() { 
+                    Iterator& operator++() { 
                         ++this->sub_iter;
                         this->check_current();
                         return *this;
                     }
 
-                    bool operator!=(const Iterator & other) const {
+                    bool operator!=(const Iterator& other) const {
                         return this->sub_iter != other.sub_iter;
                     }
             };
@@ -110,13 +110,13 @@ namespace iter {
     // Helper function to instantiate a TakeWhile
     template <typename FilterFunc, typename Container>
     TakeWhile<FilterFunc, Container> takewhile(
-            FilterFunc filter_func, Container && container) {
+            FilterFunc filter_func, Container&& container) {
         return {filter_func, std::forward<Container>(container)};
     }
 
     template <typename FilterFunc, typename T>
     TakeWhile<FilterFunc, std::initializer_list<T>> takewhile(
-            FilterFunc filter_func, std::initializer_list<T> && il)
+            FilterFunc filter_func, std::initializer_list<T>&& il)
     {
         return {filter_func, std::move(il)};
     }

From 0321946b0081ffff7375290d13df9d94771e1abc Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 26 May 2014 14:41:54 -0700
Subject: [PATCH 0330/1866] replaces .begin and .end with std::begin/std::end

there were a couple still in there preventing static sized array
compatibility
---
 zip.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/zip.hpp b/zip.hpp
index 200a9328..351135d0 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -15,10 +15,10 @@ namespace iter {
             iterator_range<zip_iter<decltype(std::begin(containers))...>>
     {
         auto begin =
-            zip_iter<decltype(containers.begin())...>(std::begin(containers)...);
+            zip_iter<decltype(std::begin(containers))...>(std::begin(containers)...);
 
         auto end =
-            zip_iter<decltype(containers.end())...>(std::end(containers)...);
+            zip_iter<decltype(std::begin(containers))...>(std::end(containers)...);
 
         return iterator_range<decltype(begin)>(begin,end);
     }

From 2baae9fbe85eef3c99ba21eb97c816490c740bb1 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 26 May 2014 15:00:43 -0700
Subject: [PATCH 0331/1866] uniform initialization update

---
 zip.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/zip.hpp b/zip.hpp
index 351135d0..2ef13689 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -20,7 +20,7 @@ namespace iter {
         auto end =
             zip_iter<decltype(std::begin(containers))...>(std::end(containers)...);
 
-        return iterator_range<decltype(begin)>(begin,end);
+        return {begin,end};
     }
 
 

From 532a764a479c54fd897df049cf353040dc23a3c6 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 26 May 2014 19:27:53 -0700
Subject: [PATCH 0332/1866] Incomplete, alternative zip implementation

Works with everything except the last testcase in testzip.  The last zip
causes a seg fault.
---
 zip.hpp | 194 +++++++++++++++++++++++++++-----------------------------
 1 file changed, 94 insertions(+), 100 deletions(-)

diff --git a/zip.hpp b/zip.hpp
index 2ef13689..610e12a4 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -1,119 +1,113 @@
-#ifndef ZIP_HPP
-#define ZIP_HPP
+#include "iterbase.hpp"
 
-#include "iterator_range.hpp"
-
-#include <tuple>
 #include <iterator>
+#include <tuple>
+#include <utility>
 
 namespace iter {
-    template <typename ... Rest>
-    class zip_iter;
-
-    template <typename ... Containers>
-    auto zip(Containers && ... containers) ->
-            iterator_range<zip_iter<decltype(std::begin(containers))...>>
-    {
-        auto begin =
-            zip_iter<decltype(std::begin(containers))...>(std::begin(containers)...);
-
-        auto end =
-            zip_iter<decltype(std::begin(containers))...>(std::end(containers)...);
-
-        return {begin,end};
-    }
-
-
-    template <typename Iterator>
-    class zip_iter<Iterator> {
+    template <typename Container, typename... RestContainers>
+    class Zipped {
         private:
-            Iterator iter;
-
+            Container& container;
+            Zipped<RestContainers...> rest_zipped;
         public:
-            using elem_type = decltype(*iter);
-            zip_iter(const Iterator & i) :
-                iter(i){ }
-
-            auto operator*() -> decltype(std::forward_as_tuple(*iter))
-            {
-                return std::forward_as_tuple(*iter);
-            }
-            zip_iter & operator++() {
-                ++iter;
-                return *this;
+            Zipped(Container&& container, RestContainers&&... rest)
+                : container{container},
+                rest_zipped{std::forward<RestContainers>(rest)...}
+            { }
+
+            class Iterator {
+                private:
+                    using RestIter =
+                        typename Zipped<RestContainers...>::Iterator;
+
+                    iterator_type<Container> iter;
+                    RestIter rest_iter;
+                public:
+                    Iterator(iterator_type<Container> it, const RestIter& rest)
+                        : iter{it},
+                        rest_iter{rest}
+                    { }
+
+                    Iterator& operator++() {
+                        ++this->iter;
+                        ++this->rest_iter;
+                        return *this;
+                    }
+
+                    bool operator!=(const Iterator& other) const {
+                        return this->iter != other.iter &&
+                            this->rest_iter != other.rest_iter;
+                    }
+
+                    auto operator*() ->
+                        decltype(std::tuple_cat(std::make_tuple(
+                                        *this->iter), *this->rest_iter))
+                    {
+                        return std::tuple_cat(std::make_tuple(
+                                    *this->iter), *this->rest_iter);
+                    }
+            };
+
+            Iterator begin() const {
+                return {std::begin(this->container),
+                    std::begin(this->rest_zipped)};
             }
-            bool operator!=(const zip_iter & rhs) const {
-                return (this->iter != rhs.iter);
+
+            Iterator end() const {
+                return {std::end(this->container),
+                    std::end(this->rest_zipped)};
             }
     };
-#if 0
-    template <typename First, typename Second>
-        struct zip_iter<First,Second> {
 
-        private:
-            First iter1;
-            Second iter2;
 
-        public:
-            using Elem1_t = decltype(*iter1);
-            using Elem2_t = decltype(*iter2);
-            zip_iter(const First & f, const Second & s) :
-                iter1(f),iter2(s) { }
-
-            auto operator*() -> decltype(std::forward_as_tuple(*iter1,*iter2))
-            {
-                return std::forward_as_tuple(*iter1,*iter2);
-            }
-            zip_iter & operator++() {
-                ++iter1;
-                ++iter2;
-                return *this;
-            }
-            bool operator!=(const zip_iter & rhs) const {
-                return (this->iter1 != rhs.iter1) && (this->iter2 != rhs.iter2);
-            }
-        };
-#endif
-    //this specialization commented out 
-    template <typename First, typename ... Rest>
-    class zip_iter<First,Rest...> {
+    template <typename Container>
+    class Zipped<Container> {
         private:
-            First iter;
-            zip_iter<Rest...> inner_iter;
-            
+            Container& container;
         public:
-            using elem_type = decltype(*iter);
-            using tuple_type = 
-                decltype(std::tuple_cat(std::forward_as_tuple(*iter),*inner_iter));
-
-            zip_iter(const First & f, const Rest & ... rest) :
-                iter(f),
-                inner_iter(rest...) {}
-
-
-            tuple_type operator*()
-            {
-                return std::tuple_cat(std::forward_as_tuple(*iter),*inner_iter);
-            }
-
-            zip_iter & operator++() {
-                ++iter;
-                ++inner_iter;
-                return *this;
+            Zipped(Container&& container)
+                : container{container}
+            { }
+
+            class Iterator {
+                private:
+                    iterator_type<Container> iter;
+                public:
+                    Iterator(iterator_type<Container> it)
+                        : iter{it}
+                    { }
+
+                    Iterator& operator++() {
+                        ++this->iter;
+                        return *this;
+                    }
+
+                    bool operator!=(const Iterator& other) const {
+                        // if this->iter == other.iter, then won't every other
+                        // level have to be the same? 
+                        // in other words, I should only have to compare iter,
+                        // and not rest as well
+                        return this->iter != other.iter;
+                    }
+
+                    auto operator*() -> decltype(std::make_tuple(*this->iter))
+                    {
+                        return std::make_tuple(*this->iter);
+                    }
+            };
+
+            Iterator begin() const {
+                return {std::begin(this->container)};
             }
 
-            bool operator!=(const zip_iter & rhs) const {
-                return (this->iter != rhs.iter) &&
-                    (this->inner_iter != rhs.inner_iter);
+            Iterator end() const {
+                return {std::end(this->container)};
             }
     };
-}
 
-namespace std {
-    template <typename ... Containers>
-        struct iterator_traits<iter::zip_iter<Containers...>> {
-            using difference_type = ptrdiff_t;
-            using iterator_category = input_iterator_tag;
-        };
+    template <typename... Containers>
+    Zipped<Containers...> zip(Containers&&... containers) {
+        return {std::forward<Containers>(containers)...};
+    }
 }
-#endif //ZIP_HPP

From 5a16f79e3b4e0da6a372b5a28efb2ec6f165b1c8 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 26 May 2014 19:32:09 -0700
Subject: [PATCH 0333/1866] adds zip test with statically sized array

---
 tests/testzip.cpp | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/tests/testzip.cpp b/tests/testzip.cpp
index 65254030..66e5eda5 100644
--- a/tests/testzip.cpp
+++ b/tests/testzip.cpp
@@ -21,7 +21,6 @@ int main() {
             i = 69;
             std::cout << std::get<1>(e) << std::endl;
         }
-
         for (auto e : zip(ivec, svec)) {
             std::cout << std::get<0>(e) << std::endl;
             std::cout << std::get<1>(e) << std::endl;
@@ -31,6 +30,13 @@ int main() {
             std::cout << std::get<0>(e) << '\n';
             std::cout << std::get<1>(e) << '\n';
         }
+
+        int arr[] = {1,2,3,3,4};
+        for (auto e : zip(iter::range(10), arr)) {
+            std::cout << std::get<0>(e) << '\n';
+            std::cout << std::get<1>(e) << '\n';
+        }
+            
     }
     //Aaron's test
     {
@@ -89,8 +95,6 @@ int main() {
     }
 
 
-
-
     return 0;
 }
 

From d63c17ba87cec35a4d555665ed996ca021d976af Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 26 May 2014 19:35:39 -0700
Subject: [PATCH 0334/1866] formats the last test in testzip

---
 tests/testzip.cpp | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/tests/testzip.cpp b/tests/testzip.cpp
index 66e5eda5..ed8066ec 100644
--- a/tests/testzip.cpp
+++ b/tests/testzip.cpp
@@ -83,8 +83,11 @@ int main() {
         }
         std::cout<<std::endl;
         const std::vector<double> constvector{1.1,2.2,3.3,4.4};
-        for (auto e : zip(iter::chain(std::vector<int>(5,5),std::array<int,2>{{1,2}}),
-                    std::initializer_list<std::string>{"asdfas","aaron","ryan","apple","juice"},
+        for (auto e : zip(
+                    iter::chain(std::vector<int>(5,5),
+                                std::array<int,2>{{1,2}}),
+                    std::initializer_list<std::string>{
+                        "asdfas","aaron","ryan","apple","juice"},
                     constvector)) 
         { 
 

From 20bcf7f7f7d62c20bea1a9e306b12b618b73ccf5 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 26 May 2014 22:12:23 -0700
Subject: [PATCH 0335/1866] Makes imap compatible with new zip (much nicer)

The old version relied on an implentation detail of zip and (at the time
at least) I couldn't get rid of that reliance.  The use of the new zip
is oblivious to the implementation.  This rules.
---
 imap.hpp | 13 +++----------
 1 file changed, 3 insertions(+), 10 deletions(-)

diff --git a/imap.hpp b/imap.hpp
index 40003417..42fba58b 100644
--- a/imap.hpp
+++ b/imap.hpp
@@ -74,17 +74,10 @@ namespace iter {
         // The imap function is the only thing allowed to create a IMap
         friend IMap imap<MapFunc, Containers...>(MapFunc, Containers&& ...);
 
-        // The type returned when dereferencing the Containers...::Iterator
-        // XXX depends on zip using iterator_range.  would be nice if it didn't
-        using Zipped = 
-            iterator_range<zip_iter<decltype(std::declval<Containers>().begin())...>>;
-
-        using ZippedIterType = decltype(std::declval<Zipped>().begin());
-            //typename std::remove_const<decltype(std::declval<Zipped>().begin())>::type;
-
+        using ZippedIterType = iterator_type<Zipped<Containers...>>;
         private:
             MapFunc map_func;
-            Zipped zipped;
+            Zipped<Containers...> zipped;
             
             // Value constructor for use only in the imap function
             IMap(MapFunc map_func, Containers&& ... containers) :
@@ -103,7 +96,7 @@ namespace iter {
                     mutable ZippedIterType zipiter;
 
                 public:
-                    Iterator (MapFunc map_func, ZippedIterType zipiter) :
+                    Iterator(MapFunc map_func, ZippedIterType zipiter) :
                         map_func(map_func),
                         zipiter(zipiter)
                     { } 

From cd88f0e60a04da1cdba4b4fbac2afe6e4b430a34 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 28 May 2014 23:18:28 -0700
Subject: [PATCH 0336/1866] Safe support for temporaries in enumerate

I will need to add this to everything soon.  This works by adding an
overload to the enumerate() function.  If an lvalue is passed, the
Enumerable binds an lvalue to it.  If an rvalue is passed, the
Enumerable move constructs it.  It's easier explained in the code.

Also, must make the value constructor private again to complete this
---
 enumerate.hpp | 50 ++++++++++++++++++++++++++++++++++++--------------
 1 file changed, 36 insertions(+), 14 deletions(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index 6ff3faae..aa620daf 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -20,6 +20,7 @@
 
 namespace iter {
 
+#if 0
     //Forward declarations of Enumerable and enumerate
     template <typename Container>
     class Enumerable;
@@ -29,27 +30,37 @@ namespace iter {
 
     template <typename Container>
     Enumerable<Container> enumerate(Container&&);
+#endif
 
     template <typename Container>
     class Enumerable {
-        private:
-            Container& container;
+        //private:
+        public:
+            Container container;
 
+#if 0
             // The only thing allowed to directly instantiate an Enumerable is
             // the enumerate function
-            friend Enumerable enumerate<Container>(Container&&);
+            friend Enumerable enumerate<Container>(Container);
             template <typename T>
             friend Enumerable<std::initializer_list<T>> enumerate(
                     std::initializer_list<T>&&);
-
-            Enumerable(Container&& container) : container{container} { }
+#endif
+    
+            Enumerable(Container container)
+                : container(std::forward<Container>(container))
+            { }
             
         public:
             // Value constructor for use only in the enumerate function
-            Enumerable () = delete;
-            Enumerable & operator=(const Enumerable&) = delete;
+            Enumerable() = delete;
+            Enumerable& operator=(const Enumerable&) = delete;
+            Enumerable(const Enumerable&) = delete;
+            Enumerable& operator=(Enumerable&&) = delete;
 
-            Enumerable(const Enumerable&) = default;
+            // movable only
+            Enumerable(Enumerable&&) = default;
+            ~Enumerable() = default;
 
             // "yielded" by the Enumerable::Iterator.  Has a .index, and a 
             // .element referencing the value yielded by the subiterator
@@ -91,27 +102,38 @@ namespace iter {
                     }
             };
 
-            Iterator begin() const {
+            Iterator begin() {
                 return {std::begin(this->container)};
             }
 
-            Iterator end() const {
+            Iterator end() {
                 return {std::end(this->container)};
             }
 
     };
 
-    // Helper function to instantiate an Enumerable
+    // any lvalues passed will go here, instantiating Enumerabe<Container&>
+    // this will result in enumerate iterating over a reference to the
+    // provided value, as is the usual intention
+    template <typename Container>
+    Enumerable<Container&> enumerate(Container& container) {
+        return {container};
+    }
+
+    // any rvalue passed will go here, instantiating Enumerabel<Container>
+    // instead of binding a reference, the Enumerable ctor will move construct
+    // the temporary `container` as a data member
     template <typename Container>
     Enumerable<Container> enumerate(Container&& container) {
-        return {std::forward<Container>(container)};
+        return {std::move(container)};
     }
 
+    // for initializer lists.  copy constructs the list into the Enumerable
     template <typename T>
     Enumerable<std::initializer_list<T>> enumerate(
-            std::initializer_list<T>&& il)
+            std::initializer_list<T> il)
     {
-        return {std::move(il)};
+        return {il};
     }
 
 }

From 8f525b202fda4d35f3e346ce06e3c005f958b2bc Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 28 May 2014 23:28:49 -0700
Subject: [PATCH 0337/1866] Restores privacy to enumerate

---
 enumerate.hpp | 21 +++++++++++----------
 1 file changed, 11 insertions(+), 10 deletions(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index aa620daf..bda03e78 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -20,32 +20,33 @@
 
 namespace iter {
 
-#if 0
     //Forward declarations of Enumerable and enumerate
     template <typename Container>
     class Enumerable;
 
-    template <typename T>
-    Enumerable<std::initializer_list<T>> enumerate(std::initializer_list<T>&&);
+    template <typename Container>
+    Enumerable<Container&> enumerate(Container&);
 
     template <typename Container>
     Enumerable<Container> enumerate(Container&&);
-#endif
+
+    template <typename T>
+    Enumerable<std::initializer_list<T>> enumerate(std::initializer_list<T>);
 
     template <typename Container>
     class Enumerable {
-        //private:
-        public:
+        private:
             Container container;
 
-#if 0
             // The only thing allowed to directly instantiate an Enumerable is
             // the enumerate function
-            friend Enumerable enumerate<Container>(Container);
+            template <typename C>
+            friend Enumerable<C&> enumerate(C&);
+            template <typename C>
+            friend Enumerable<C> enumerate(C&&);
             template <typename T>
             friend Enumerable<std::initializer_list<T>> enumerate(
-                    std::initializer_list<T>&&);
-#endif
+                    std::initializer_list<T>);
     
             Enumerable(Container container)
                 : container(std::forward<Container>(container))

From 2464b19be70f8b704094cdde5cfbbeb5ad511591 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 28 May 2014 23:40:59 -0700
Subject: [PATCH 0338/1866] adds missing include guards to zip

---
 zip.hpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/zip.hpp b/zip.hpp
index 610e12a4..a57e5b73 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -1,3 +1,6 @@
+#ifndef ZIP__H__
+#define ZIP__H__
+
 #include "iterbase.hpp"
 
 #include <iterator>
@@ -111,3 +114,5 @@ namespace iter {
         return {std::forward<Containers>(containers)...};
     }
 }
+
+#endif //#ifndef ZIP__H__

From 43d455dfe972216f02490aab1afac0cce107b8ae Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 30 May 2014 22:22:31 -0700
Subject: [PATCH 0339/1866] Uses alternative scheme for supporting temps

this seems easier implemented.  If the argument to enumerate() is an
lvalue then Enumerable is templated on an lvalue reference type (just
because of how universal references work).  Otherwise it gets templated
on a non-reference type.  the std::forward in the constructor results in
a move construction when templated on a non-reference type, and an
lvalue reference bind when it is a reference type.
---
 enumerate.hpp | 34 ++++++++++++----------------------
 1 file changed, 12 insertions(+), 22 deletions(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index bda03e78..aa961fd8 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -7,6 +7,7 @@
 #include <iterator>
 #include <functional>
 #include <initializer_list>
+#include <type_traits>
 
 
 // enumerate functionality for python-style for-each enumerate loops
@@ -24,9 +25,6 @@ namespace iter {
     template <typename Container>
     class Enumerable;
 
-    template <typename Container>
-    Enumerable<Container&> enumerate(Container&);
-
     template <typename Container>
     Enumerable<Container> enumerate(Container&&);
 
@@ -35,19 +33,23 @@ namespace iter {
 
     template <typename Container>
     class Enumerable {
+        static_assert(!std::is_rvalue_reference<Container>::value,
+                "Itertools cannot be templated with rvalue references");
         private:
             Container container;
 
+            // lvalue ref if it's an lvalue, non-ref type otherwise
             // The only thing allowed to directly instantiate an Enumerable is
             // the enumerate function
-            template <typename C>
-            friend Enumerable<C&> enumerate(C&);
-            template <typename C>
-            friend Enumerable<C> enumerate(C&&);
+            friend Enumerable enumerate<Container>(Container&&);
             template <typename T>
             friend Enumerable<std::initializer_list<T>> enumerate(
                     std::initializer_list<T>);
-    
+
+            // FIXME it seems like if an rvalue is passed, Container will
+            // not be a reference type at all, which will cause this to copy
+            // construct rather than move construct.  But somehow that doesn't
+            // happen and it gets move constructed.  Must investigate further
             Enumerable(Container container)
                 : container(std::forward<Container>(container))
             { }
@@ -113,30 +115,18 @@ namespace iter {
 
     };
 
-    // any lvalues passed will go here, instantiating Enumerabe<Container&>
-    // this will result in enumerate iterating over a reference to the
-    // provided value, as is the usual intention
-    template <typename Container>
-    Enumerable<Container&> enumerate(Container& container) {
-        return {container};
-    }
-
-    // any rvalue passed will go here, instantiating Enumerabel<Container>
-    // instead of binding a reference, the Enumerable ctor will move construct
-    // the temporary `container` as a data member
     template <typename Container>
     Enumerable<Container> enumerate(Container&& container) {
-        return {std::move(container)};
+        return {std::forward<Container>(container)};
     }
 
     // for initializer lists.  copy constructs the list into the Enumerable
     template <typename T>
     Enumerable<std::initializer_list<T>> enumerate(
             std::initializer_list<T> il)
-    {
+    {   
         return {il};
     }
-
 }
 
 #endif //ifndef ENUMERABLE__H__

From 5b939c291b02413aa1d0ae1c8b31861149fd220a Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 30 May 2014 22:25:46 -0700
Subject: [PATCH 0340/1866] Adds true temporary support to zip

---
 zip.hpp | 24 ++++++++++++++----------
 1 file changed, 14 insertions(+), 10 deletions(-)

diff --git a/zip.hpp b/zip.hpp
index 610e12a4..df54ed36 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -7,12 +7,14 @@
 namespace iter {
     template <typename Container, typename... RestContainers>
     class Zipped {
+        static_assert(!std::is_rvalue_reference<Container>::value,
+                "Itertools cannot be templated with rvalue references");
         private:
-            Container& container;
+            Container container;
             Zipped<RestContainers...> rest_zipped;
         public:
-            Zipped(Container&& container, RestContainers&&... rest)
-                : container{container},
+            Zipped(Container container, RestContainers&&... rest)
+                : container(std::forward<Container>(container)),
                 rest_zipped{std::forward<RestContainers>(rest)...}
             { }
 
@@ -49,12 +51,12 @@ namespace iter {
                     }
             };
 
-            Iterator begin() const {
+            Iterator begin() {
                 return {std::begin(this->container),
                     std::begin(this->rest_zipped)};
             }
 
-            Iterator end() const {
+            Iterator end() {
                 return {std::end(this->container),
                     std::end(this->rest_zipped)};
             }
@@ -63,11 +65,13 @@ namespace iter {
 
     template <typename Container>
     class Zipped<Container> {
+        static_assert(!std::is_rvalue_reference<Container>::value,
+                "Itertools cannot be templated with rvalue references");
         private:
-            Container& container;
+            Container container;
         public:
-            Zipped(Container&& container)
-                : container{container}
+            Zipped(Container container)
+                : container(std::forward<Container>(container))
             { }
 
             class Iterator {
@@ -97,11 +101,11 @@ namespace iter {
                     }
             };
 
-            Iterator begin() const {
+            Iterator begin() {
                 return {std::begin(this->container)};
             }
 
-            Iterator end() const {
+            Iterator end() {
                 return {std::end(this->container)};
             }
     };

From 186592ed18ae37a9aeb87ef6c77641bfa133a94d Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 30 May 2014 22:34:53 -0700
Subject: [PATCH 0341/1866] Makes Zipped constrctor private and zip a friend

---
 zip.hpp | 25 +++++++++++++++++++++++--
 1 file changed, 23 insertions(+), 2 deletions(-)

diff --git a/zip.hpp b/zip.hpp
index df54ed36..2922c64e 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -4,20 +4,34 @@
 #include <tuple>
 #include <utility>
 
+
 namespace iter {
+    template <typename Container, typename... RestContainers>
+    class Zipped;
+
+    template <typename... Containers>
+    Zipped<Containers...> zip(Containers&&...);
+
     template <typename Container, typename... RestContainers>
     class Zipped {
         static_assert(!std::is_rvalue_reference<Container>::value,
                 "Itertools cannot be templated with rvalue references");
+
+        friend Zipped zip<Container, RestContainers...>(
+                Container&&, RestContainers&&...);
+
+        template <typename C, typename... RC>
+        friend class Zipped;
+
         private:
             Container container;
             Zipped<RestContainers...> rest_zipped;
-        public:
             Zipped(Container container, RestContainers&&... rest)
                 : container(std::forward<Container>(container)),
                 rest_zipped{std::forward<RestContainers>(rest)...}
             { }
 
+        public:
             class Iterator {
                 private:
                     using RestIter =
@@ -67,13 +81,20 @@ namespace iter {
     class Zipped<Container> {
         static_assert(!std::is_rvalue_reference<Container>::value,
                 "Itertools cannot be templated with rvalue references");
+
+        friend Zipped zip<Container>(Container&&);
+
+        template <typename C, typename... RC>
+        friend class Zipped;
+
         private:
             Container container;
-        public:
             Zipped(Container container)
                 : container(std::forward<Container>(container))
             { }
 
+        public:
+
             class Iterator {
                 private:
                     iterator_type<Container> iter;

From cb7e9dc20e5896eeb7d55eaa728f2f0a26af8718 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 31 May 2014 23:08:20 -0700
Subject: [PATCH 0342/1866] Fixes zip so one can modify data while iterating

I was using std::make_tuple to get the type of the value in the tuple,
but I neglected to realize this would cause it to drop the reference
part of the type.  By explicitly giving it
std::tuple<iterator_deref<Container>> this is avoided.  If the iterator
derefences to a reference type, the tuple will hold a reference.
---
 zip.hpp | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/zip.hpp b/zip.hpp
index 2922c64e..f8fab45b 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -57,11 +57,15 @@ namespace iter {
                     }
 
                     auto operator*() ->
-                        decltype(std::tuple_cat(std::make_tuple(
-                                        *this->iter), *this->rest_iter))
+                        decltype(std::tuple_cat(
+                                    std::tuple<iterator_deref<Container>>{
+                                        *this->iter},
+                                    *this->rest_iter))
                     {
-                        return std::tuple_cat(std::make_tuple(
-                                    *this->iter), *this->rest_iter);
+                        return std::tuple_cat(
+                                std::tuple<iterator_deref<Container>>{
+                                    *this->iter},
+                                *this->rest_iter);
                     }
             };
 
@@ -109,16 +113,12 @@ namespace iter {
                     }
 
                     bool operator!=(const Iterator& other) const {
-                        // if this->iter == other.iter, then won't every other
-                        // level have to be the same? 
-                        // in other words, I should only have to compare iter,
-                        // and not rest as well
                         return this->iter != other.iter;
                     }
 
-                    auto operator*() -> decltype(std::make_tuple(*this->iter))
-                    {
-                        return std::make_tuple(*this->iter);
+                    std::tuple<iterator_deref<Container>> operator*() {
+                        return std::tuple<iterator_deref<Container>>{
+                            *this->iter};
                     }
             };
 

From f32a2e5bd739cae56d807519c93317163d2eadbd Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 31 May 2014 23:15:38 -0700
Subject: [PATCH 0343/1866] More intense testzip

better test for temporaries. asserts to make sure the value of the
vector was changed after iterating.
---
 tests/testzip.cpp | 28 +++++++++++++++++++++-------
 1 file changed, 21 insertions(+), 7 deletions(-)

diff --git a/tests/testzip.cpp b/tests/testzip.cpp
index ed8066ec..3003bc40 100644
--- a/tests/testzip.cpp
+++ b/tests/testzip.cpp
@@ -6,6 +6,7 @@
 #include <string>
 #include <iostream>
 #include <array>
+#include <cassert>
 
 using iter::zip;
 
@@ -15,17 +16,27 @@ int main() {
         std::vector<int> ivec{1, 4, 9, 16, 25, 36};
         std::vector<std::string> svec{"hello", "good day", "goodbye"};
 
+        constexpr int magic_value = 69;
         for (auto e : zip(ivec, svec)) {
             auto &i = std::get<0>(e);
             std::cout << i << std::endl;
-            i = 69;
+            i = magic_value;
             std::cout << std::get<1>(e) << std::endl;
         }
+        assert(ivec.at(0) == magic_value);
         for (auto e : zip(ivec, svec)) {
             std::cout << std::get<0>(e) << std::endl;
             std::cout << std::get<1>(e) << std::endl;
         }
 
+        for (auto e : zip(std::vector<int>{5,6,7})) {
+            std::cout << std::get<0>(e) << std::endl;
+        }
+        for (auto e : zip(std::vector<int>{5,6,7}, std::array<int,2>{{1,2}})){
+            std::cout << std::get<0>(e) << std::endl;
+            std::cout << std::get<1>(e) << std::endl;
+        }
+
         for (auto e : zip(iter::range(10), iter::range(10, 20))) {
             std::cout << std::get<0>(e) << '\n';
             std::cout << std::get<1>(e) << '\n';
@@ -84,16 +95,19 @@ int main() {
         std::cout<<std::endl;
         const std::vector<double> constvector{1.1,2.2,3.3,4.4};
         for (auto e : zip(
-                    iter::chain(std::vector<int>(5,5),
-                                std::array<int,2>{{1,2}}),
-                    std::initializer_list<std::string>{
-                        "asdfas","aaron","ryan","apple","juice"},
+                    // the chain test breaks it, but its chain's fault
+                    //iter::chain(std::vector<int>(5,5),
+                    //           std::array<int,2>{{1,2}}),
+                    std::initializer_list<const char *>{
+                         "asdfas","aaron","ryan","apple","juice"},
+                    std::initializer_list<int>{1, 2, 3, 4},
                     constvector)) 
         { 
 
             std::cout << std::get<0>(e) << " " 
-                << std::get<1>(e) << " " 
-                << std::get<2>(e) << std::endl;
+                << std::get<1>(e) << " "
+                //<< std::get<2>(e)
+                << '\n';
         }
     }
 

From dc821d0d71b574f40b5d9f470062c968d22b642a Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 31 May 2014 23:17:23 -0700
Subject: [PATCH 0344/1866] Adds enumerate test with temporaries

---
 tests/testenumerate.cpp | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/tests/testenumerate.cpp b/tests/testenumerate.cpp
index 498139e3..cd41bc90 100644
--- a/tests/testenumerate.cpp
+++ b/tests/testenumerate.cpp
@@ -1,3 +1,5 @@
+#include "testbase.hpp"
+
 #include <enumerate.hpp>
 #include <range.hpp>
 
@@ -36,17 +38,25 @@ int main() {
         std::cout << e.index << ": " << e.element << '\n';
     }
 
-
     std::cout << "initializer list\n";
     for (auto e : enumerate({0, 1, 4, 9, 16, 25})) {
         std::cout << e.index << "^2 = " << e.element << '\n';
     }
 
-
     std::cout << "range(10, 20, 2)\n";
     for (auto e : enumerate(range(10, 20, 2))) {
         std::cout << e.index << ": " << e.element << '\n';
     }
 
+    std::cout << "range(10, 20, 2)\n";
+    for (auto e : enumerate(enumerate(range(10, 20, 2)))) {
+        std::cout << e.index << ": " << e.element.element << '\n';
+    }
+
+    std::cout << "vector temporary\n";
+    for (auto e : enumerate(std::vector<int>(5,2))) {
+        std::cout << e.index << ": " << e.element << '\n';
+    }
+
     return 0;
 }

From f4b7069b411b7ef99f94cb1ba4e2da70f487f250 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 1 Jun 2014 09:08:53 -0700
Subject: [PATCH 0345/1866] removes old comments

---
 enumerate.hpp | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index aa961fd8..f2e63ff2 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -38,7 +38,6 @@ namespace iter {
         private:
             Container container;
 
-            // lvalue ref if it's an lvalue, non-ref type otherwise
             // The only thing allowed to directly instantiate an Enumerable is
             // the enumerate function
             friend Enumerable enumerate<Container>(Container&&);
@@ -46,16 +45,12 @@ namespace iter {
             friend Enumerable<std::initializer_list<T>> enumerate(
                     std::initializer_list<T>);
 
-            // FIXME it seems like if an rvalue is passed, Container will
-            // not be a reference type at all, which will cause this to copy
-            // construct rather than move construct.  But somehow that doesn't
-            // happen and it gets move constructed.  Must investigate further
+            // Value constructor for use only in the enumerate function
             Enumerable(Container container)
                 : container(std::forward<Container>(container))
             { }
             
         public:
-            // Value constructor for use only in the enumerate function
             Enumerable() = delete;
             Enumerable& operator=(const Enumerable&) = delete;
             Enumerable(const Enumerable&) = delete;

From b8fe3d8cdf3753eee1a0ee72005daa8b51d71229 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 1 Jun 2014 11:20:11 -0700
Subject: [PATCH 0346/1866] adds test with temporaries

---
 tests/testchain.cpp | 66 +++++++++++++++++++++++++--------------------
 1 file changed, 37 insertions(+), 29 deletions(-)

diff --git a/tests/testchain.cpp b/tests/testchain.cpp
index 46ac02a3..99d7a291 100644
--- a/tests/testchain.cpp
+++ b/tests/testchain.cpp
@@ -1,4 +1,5 @@
 #include <chain.hpp>
+#include <range.hpp>
 
 #include <vector>
 #include <string>
@@ -19,35 +20,42 @@ int main() {
         }
     }
     {
-         std::vector<int> empty{};
-         std::vector<int> vec1{1,2,3,4,5,6};
-         std::array<int,4> arr1{{7,8,9,10}};
-         std::array<int,3> arr2{{11,12,13}};
-         std::cout << std::endl << "Chain iter test" << std::endl;
-         for (auto i : iter::chain(empty,vec1,arr1)) {
-             std::cout << i << std::endl;
-         }
-         std::cout<<std::endl;
-         for (auto i : iter::chain(vec1,empty,arr1)) {
-             std::cout << i << std::endl;
-         }
-         std::cout<<std::endl;
-         for (auto i : iter::chain(vec1,arr1,empty)) {
-             std::cout << i << std::endl;
-         }
-         std::cout<<std::endl;//modifying the range
-         for (auto & i : iter::chain(vec1,arr1,arr2)) {
-             i = 0;//0 out the whole thing
-         }
-         std::cout<<std::endl;
-         for (auto i : iter::chain(vec1,arr1,arr2)) {
-             std::cout << i << std::endl;
-         }
-         //test only works with perfect forwarding
-         std::cout<<std::endl;
-         for (auto i : chain(il{1,2,3,4,5},il{6,7,8,9},il{10,11,12})) {
-             std::cout << i << std::endl;
-         }
+        std::vector<int> empty{};
+        std::vector<int> vec1{1,2,3,4,5,6};
+        std::array<int,4> arr1{{7,8,9,10}};
+        std::array<int,3> arr2{{11,12,13}};
+        std::cout << std::endl << "Chain iter test" << std::endl;
+        for (auto i : iter::chain(empty,vec1,arr1)) {
+            std::cout << i << std::endl;
+        }
+        std::cout<<std::endl;
+        for (auto i : iter::chain(vec1,empty,arr1)) {
+            std::cout << i << std::endl;
+        }
+        std::cout<<std::endl;
+        for (auto i : iter::chain(vec1,arr1,empty)) {
+            std::cout << i << std::endl;
+        }
+        std::cout<<std::endl;//modifying the range
+        for (auto & i : iter::chain(vec1,arr1,arr2)) {
+            i = 0;//0 out the whole thing
+        }
+        std::cout<<std::endl;
+        for (auto i : iter::chain(vec1,arr1,arr2)) {
+            std::cout << i << std::endl;
+        }
+        //test only works with perfect forwarding
+        std::cout<<std::endl;
+        for (auto i : chain(il{1,2,3,4,5},il{6,7,8,9},il{10,11,12})) {
+            std::cout << i << std::endl;
+        }
+
+        // test with temporaries
+        std::cout << '\n';
+        for (auto i : chain(std::vector<int>{1,2,3,4},
+                    std::array<int,4>{{5,6,7,8}})) {
+            std::cout << i << '\n';
+        }
     }
     return 0;
 }

From 32622e6fff816608ec018cd60a8eef46f6b993a6 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 1 Jun 2014 11:36:35 -0700
Subject: [PATCH 0347/1866] Complete rewrite of chain, safer, supports temps

Supports temporary values the same way zip does.  One thing I'd like to
be able to do is support a mix of types so something like
chain(std::vector<int>{1,2,3,4}, range(10)); would work
currently it doesnt because the iterators dereference to different types
(int& and int, respectively).  Idk if there's a safe way to handle this
that wouldn't be confusing outwardly.
---
 chain.hpp | 219 +++++++++++++++++++++++++++++++-----------------------
 1 file changed, 127 insertions(+), 92 deletions(-)

diff --git a/chain.hpp b/chain.hpp
index d54b1426..0e57ce09 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -1,104 +1,139 @@
-#ifndef CHAIN_HPP
-#define CHAIN_HPP
-
-#include "iterator_range.hpp"
+#include "iterbase.hpp"
 
 #include <utility>
 #include <iterator>
+#include <initializer_list>
+#include <type_traits>
 
 namespace iter {
-    template <typename ... Containers>
-        struct chain_iter;
-    template <typename Container>
-        struct chain_iter<Container> {
-
-            private:
-                //using Iterator = decltype(std::declval<Container>().begin());
-                using Iterator = decltype(std::begin(std::declval<Container>()));
-                Iterator begin;
-                const Iterator end;//never really used but kept it for consistency
-
-            public:
-                chain_iter(Container && container, bool is_end=false) :
-                    begin(std::begin(container)),end(std::end(container)) {
-                        if(is_end) begin = std::end(container);
-                    }
-                chain_iter & operator++()
-                {
-                    ++begin;
-                    return *this;
-                }
-                auto operator*()->decltype(*begin)
-                {
-                    return *begin;
-                }
-                bool operator!=(const chain_iter & rhs) const{
-                    return this->begin != rhs.begin;
-                }
-        };
-    template <typename Container, typename ... Containers>
-        struct chain_iter<Container,Containers...>
-        {
-            private:
-                //using Iterator = decltype(std::declval<Container>().begin());
-                using Iterator = decltype(std::begin(std::declval<Container>()));
-                Iterator begin;
-                const Iterator end;
-                bool end_reached = false;
-                chain_iter<Containers...> next_iter;
-
-            public:
-                chain_iter(Container && container, Containers&& ... containers, bool is_end=false) :
-                    begin(std::begin(container)),
-                    end(std::end(container)),
-                    next_iter(std::forward<Containers>(containers)...,is_end) {
-                        if(is_end)
-                            begin = std::end(container);
+    template <typename Container, typename...RestContainers>
+    class Chained;
+
+    template <typename... Containers>
+    Chained<Containers...> chain(Containers&&...);
+
+    template <typename Container, typename... RestContainers>
+    class Chained {
+        friend Chained chain<Container, RestContainers...>(
+                Container&&, RestContainers&&...);
+        template <typename C, typename... RC>
+        friend class Chained;
+
+        private:
+            Container container;
+            Chained<RestContainers...> rest_chained;
+            Chained(Container container, RestContainers&&... rest)
+                : container(std::forward<Container>(container)),
+                rest_chained{std::forward<RestContainers>(rest)...}
+            { }
+
+        public:
+            class Iterator {
+                private:
+                    using RestIter =
+                        typename Chained<RestContainers...>::Iterator;
+                    iterator_type<Container> sub_iter;
+                    const iterator_type<Container> sub_end;
+                    RestIter rest_iter;
+                    bool at_end;
+
+                public:
+                    Iterator(const iterator_type<Container>& s_begin,
+                            const iterator_type<Container>& s_end,
+                            RestIter rest_iter)
+                        : sub_iter{s_begin},
+                        sub_end{s_end},
+                        rest_iter{rest_iter},
+                        at_end{!(sub_iter != sub_end)}
+                    { }
+                    
+                    Iterator& operator++() {
+                        if (this->at_end) {
+                            ++this->rest_iter;
+                        } else {
+                            ++this->sub_iter;
+                            if (!(this->sub_iter != this->sub_end)) {
+                                this->at_end = true;
+                            }
+                        }
+                        return *this;
                     }
-                chain_iter & operator++()
-                {
-                    if (!(begin != end)) {
-                        ++next_iter;
+
+                    bool operator!=(const Iterator& other) const {
+                        return this->sub_iter != other.sub_iter ||
+                            this->rest_iter != other.rest_iter;
                     }
-                    else {
-                        ++begin;
+
+                    iterator_deref<Container> operator*() {
+                        return this->at_end ?
+                            *this->rest_iter : *this->sub_iter;
                     }
-                    return *this;               
-                }
-                auto operator*()->decltype(*begin)
-                {
-                    if (!(begin != end)) {
-                        return *next_iter;
+            };
+
+            Iterator begin() {
+                return {std::begin(this->container),
+                    std::end(this->container),
+                    std::begin(this->rest_chained)};
+            }
+
+            Iterator end() {
+                return {std::end(this->container),
+                    std::end(this->container),
+                    std::end(this->rest_chained)};
+            }
+    };
+    template <typename Container>
+    class Chained<Container> {
+        friend Chained chain<Container>(Container&&);
+        template <typename C, typename... RC>
+        friend class Chained;
+
+        private:
+            Container container;
+            Chained(Container container)
+                : container(std::forward<Container>(container))
+            { }
+
+        public:
+            class Iterator {
+                private:
+                    iterator_type<Container> sub_iter;
+                    const iterator_type<Container> sub_end;
+
+                public:
+                    Iterator(const iterator_type<Container>& s_begin,
+                            const iterator_type<Container>& s_end)
+                        : sub_iter{s_begin},
+                        sub_end{s_end}
+                    { }
+                    
+                    Iterator& operator++() {
+                        ++this->sub_iter;
+                        return *this;
                     }
-                    else {
-                        return *begin;
+
+                    bool operator!=(const Iterator& other) const {
+                        return this->sub_iter != other.sub_iter;
                     }
-                }   
-                bool operator !=(const chain_iter & rhs) const {
-                    if (!(begin != end)) {
-                        return this->next_iter != rhs.next_iter;
+
+                    iterator_deref<Container> operator*() {
+                        return *this->sub_iter;
                     }
-                    else
-                        return this->begin != rhs.begin;
-                }
-        };
-    
-    template <typename ... Containers>
-        iterator_range<chain_iter<Containers...>> chain(Containers&& ... containers)
-        {
-            auto begin = 
-                chain_iter<Containers...>(std::forward<Containers>(containers)...);
-            auto end =
-                chain_iter<Containers...>(std::forward<Containers>(containers)...,true);
-            return 
-                iterator_range<chain_iter<Containers...>>(begin,end);
-        }
-}
-namespace std {
-    template <typename ... Containers>
-        struct iterator_traits<iter::chain_iter<Containers...>> {
-            using difference_type = ptrdiff_t;
-            using iterator_category = input_iterator_tag;
-        };
+            };
+
+            Iterator begin() {
+                return {std::begin(this->container),
+                    std::end(this->container)};
+            }
+
+            Iterator end() {
+                return {std::end(this->container),
+                    std::end(this->container)};
+            }
+    };
+
+    template <typename... Containers>
+    Chained<Containers...> chain(Containers&&... containers) {
+        return {std::forward<Containers>(containers)...};
+    }
 }
-#endif //CHAIN_HPP

From 38fe87b38a31874338f69ee1f34dd6d841050633 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 1 Jun 2014 11:40:33 -0700
Subject: [PATCH 0348/1866] Adds back ziptest that uses chain

---
 tests/testzip.cpp | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/tests/testzip.cpp b/tests/testzip.cpp
index 3003bc40..06e3ebbf 100644
--- a/tests/testzip.cpp
+++ b/tests/testzip.cpp
@@ -95,9 +95,8 @@ int main() {
         std::cout<<std::endl;
         const std::vector<double> constvector{1.1,2.2,3.3,4.4};
         for (auto e : zip(
-                    // the chain test breaks it, but its chain's fault
-                    //iter::chain(std::vector<int>(5,5),
-                    //           std::array<int,2>{{1,2}}),
+                    iter::chain(std::vector<int>{5,6},
+                               std::array<int,2>{{1,2}}),
                     std::initializer_list<const char *>{
                          "asdfas","aaron","ryan","apple","juice"},
                     std::initializer_list<int>{1, 2, 3, 4},
@@ -106,7 +105,7 @@ int main() {
 
             std::cout << std::get<0>(e) << " " 
                 << std::get<1>(e) << " "
-                //<< std::get<2>(e)
+                << std::get<2>(e)
                 << '\n';
         }
     }

From 9abb598e2041195b5087da64d04741329993419b Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 1 Jun 2014 12:10:16 -0700
Subject: [PATCH 0349/1866] removes 'const' from imap begin/end

---
 imap.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/imap.hpp b/imap.hpp
index 42fba58b..3cc01371 100644
--- a/imap.hpp
+++ b/imap.hpp
@@ -117,11 +117,11 @@ namespace iter {
                     }
             };
 
-            Iterator begin() const {
+            Iterator begin() {
                 return {this->map_func, this->zipped.begin()};
             }
 
-            Iterator end() const {
+            Iterator end() {
                 return {this->map_func, this->zipped.end()};
             }
 

From 70323c5e3306df14d55f1e733a161cffc38a8ea0 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 1 Jun 2014 12:14:43 -0700
Subject: [PATCH 0350/1866] adds temporary test for imap

---
 tests/testimap.cpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/tests/testimap.cpp b/tests/testimap.cpp
index 328307b0..3d6f38ca 100644
--- a/tests/testimap.cpp
+++ b/tests/testimap.cpp
@@ -37,5 +37,9 @@ int main() {
         std::cout << i << '\n';
     }
 
+    for (auto i : imap([] (const int x) { return x*x; },
+                       std::vector<int>{1,2,3,4,5})){
+        std::cout << i << '\n';
+    }
     return 0;
 }

From 1f324105823c56ab2ef14f9c10cab75dfa5d0a7a Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 1 Jun 2014 15:30:09 -0700
Subject: [PATCH 0351/1866] removes const from begin/end

---
 accumulate.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/accumulate.hpp b/accumulate.hpp
index 792a27aa..fd671367 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -87,13 +87,13 @@ namespace iter {
                     }
             };
 
-            Iterator begin() const {
+            Iterator begin() {
                 return {std::begin(this->container),
                         std::end(this->container),
                         this->accumulate_func};
             }
 
-            Iterator end() const {
+            Iterator end() {
                 return {std::end(this->container),
                         std::end(this->container),
                         this->accumulate_func};

From 97cb78e8bf7eea6e7642034d7f846d8ec3f20e3e Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 1 Jun 2014 15:31:10 -0700
Subject: [PATCH 0352/1866] removes const from begin/end

---
 compress.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/compress.hpp b/compress.hpp
index 34aa22cf..e6c5b852 100644
--- a/compress.hpp
+++ b/compress.hpp
@@ -115,12 +115,12 @@ namespace iter {
                     }
             };
 
-            Iterator begin() const {
+            Iterator begin() {
                 return {std::begin(this->container), std::end(this->container),
                     std::begin(this->selectors), std::end(this->selectors)};
             }
 
-            Iterator end() const {
+            Iterator end() {
                 return {std::end(this->container), std::end(this->container),
                         std::end(this->selectors), std::end(this->selectors)};
             }

From b69d4f9cedead102ee3acabfdd54429ad23bf666 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 1 Jun 2014 15:31:38 -0700
Subject: [PATCH 0353/1866] removes const from begin/end

---
 cycle.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/cycle.hpp b/cycle.hpp
index 7dc76424..76ee4fee 100644
--- a/cycle.hpp
+++ b/cycle.hpp
@@ -73,12 +73,12 @@ namespace iter {
                     }
             };
 
-            Iterator begin() const {
+            Iterator begin() {
                 return {std::begin(this->container),
                         std::end(this->container)};
             }
 
-            Iterator end() const {
+            Iterator end() {
                 return {std::end(this->container),
                         std::end(this->container)};
             }

From bd3d5562e270d2cb0bb4ea99ee7d4264512c7228 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 1 Jun 2014 15:32:23 -0700
Subject: [PATCH 0354/1866] removes const from begin/end

---
 dropwhile.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/dropwhile.hpp b/dropwhile.hpp
index 724f0122..8f85a55a 100644
--- a/dropwhile.hpp
+++ b/dropwhile.hpp
@@ -82,13 +82,13 @@ namespace iter {
                     }
             };
 
-            Iterator begin() const {
+            Iterator begin() {
                 return {std::begin(this->container),
                         std::end(this->container),
                         this->filter_func};
             }
 
-            Iterator end() const {
+            Iterator end() {
                 return {std::end(this->container),
                         std::end(this->container),
                         this->filter_func};

From eb8e96443402c131f727823c823e12fc88444ed4 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 1 Jun 2014 15:33:32 -0700
Subject: [PATCH 0355/1866] removes bad include

---
 tests/testenumerate.cpp | 2 --
 1 file changed, 2 deletions(-)

diff --git a/tests/testenumerate.cpp b/tests/testenumerate.cpp
index cd41bc90..fcc1745c 100644
--- a/tests/testenumerate.cpp
+++ b/tests/testenumerate.cpp
@@ -1,5 +1,3 @@
-#include "testbase.hpp"
-
 #include <enumerate.hpp>
 #include <range.hpp>
 

From 7ef021d4b1c9a597bfb34e5c6ac4dbc01c7d65bd Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 1 Jun 2014 15:34:38 -0700
Subject: [PATCH 0356/1866] removes const from begin/end

---
 filter.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/filter.hpp b/filter.hpp
index f6695d44..d8c67218 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -86,13 +86,13 @@ namespace iter {
                     }
             };
 
-            Iterator begin() const {
+            Iterator begin() {
                 return {std::begin(this->container),
                         std::end(this->container),
                         this->filter_func};
             }
 
-            Iterator end() const {
+            Iterator end() {
                 return {std::end(this->container),
                         std::end(this->container),
                         this->filter_func};

From 78c0c9023d7b506fff8c098658e28b7b83ccf9d9 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 1 Jun 2014 15:35:29 -0700
Subject: [PATCH 0357/1866] removes const from begin/end

---
 groupby.hpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/groupby.hpp b/groupby.hpp
index 39cce2f8..ec956012 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -193,24 +193,24 @@ namespace iter {
                             }
                     };
 
-                    GroupIterator begin() const {
+                    GroupIterator begin() {
                         return {*this, key};
                     }
 
-                    GroupIterator end() const {
+                    GroupIterator end() {
                         return {*this, key};
                     }
 
             };
 
 
-            Iterator begin() const {
+            Iterator begin() {
                 return {std::begin(this->container),
                         std::end(this->container),
                         this->key_func};
             }
 
-            Iterator end() const {
+            Iterator end() {
                 return {std::end(this->container),
                         std::end(this->container),
                         this->key_func};

From c74d20a397908fcb7188801e183397f486e69145 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 1 Jun 2014 15:36:06 -0700
Subject: [PATCH 0358/1866] removes const from begin/end

---
 slice.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/slice.hpp b/slice.hpp
index f7a074a4..ec3035f1 100644
--- a/slice.hpp
+++ b/slice.hpp
@@ -129,12 +129,12 @@ namespace iter {
                     }
             };
 
-            Iterator begin() const {
+            Iterator begin() {
                 return {std::next(std::begin(this->container), this->start),
                         this->start, this->stop, this->step};
             }
 
-            Iterator end() const {
+            Iterator end() {
                 return {std::next(std::begin(this->container), this->stop),
                         this->stop, this->stop, this->step};
             }

From 33614c90f4e52a0199204c61eef6b4b3ddbadac5 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 1 Jun 2014 15:36:48 -0700
Subject: [PATCH 0359/1866] removes const from begin/end

---
 takewhile.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/takewhile.hpp b/takewhile.hpp
index d534b2f2..5fadc0ce 100644
--- a/takewhile.hpp
+++ b/takewhile.hpp
@@ -93,13 +93,13 @@ namespace iter {
                     }
             };
 
-            Iterator begin() const {
+            Iterator begin() {
                 return {std::begin(this->container),
                         std::end(this->container),
                         this->filter_func};
             }
 
-            Iterator end() const {
+            Iterator end() {
                 return {std::end(this->container),
                         std::end(this->container),
                         this->filter_func};

From 59caddfe96a3656155d439e6c91a34b7cfd936f9 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 1 Jun 2014 15:55:43 -0700
Subject: [PATCH 0360/1866] Adds accumulate test with temporary

---
 tests/testaccumulate.cpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/tests/testaccumulate.cpp b/tests/testaccumulate.cpp
index a65bf7b9..2321ffca 100644
--- a/tests/testaccumulate.cpp
+++ b/tests/testaccumulate.cpp
@@ -25,5 +25,9 @@ int main() {
         std::cout << v << '\n';
     }
 
+    for (auto v : iter::accumulate(std::vector<int>{1,2,3,4,5,6,7,8,9})) {
+        std::cout << v << '\n';
+    }
+
     return 0;
 }

From 19094116c04abfc678feffa5c43db9a8752b0828 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 1 Jun 2014 16:01:19 -0700
Subject: [PATCH 0361/1866] Corrects support for temporaries in accumulate

---
 accumulate.hpp | 35 +++++++++++++++++++++--------------
 1 file changed, 21 insertions(+), 14 deletions(-)

diff --git a/accumulate.hpp b/accumulate.hpp
index fd671367..8ba6bcba 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -7,6 +7,7 @@
 #include <iterator>
 #include <initializer_list>
 #include <functional>
+#include <type_traits>
 
 namespace iter {
 
@@ -20,29 +21,28 @@ namespace iter {
 
     template <typename T, typename AccumulateFunc>
     Accumulator<std::initializer_list<T>, AccumulateFunc> accumulate(
-            std::initializer_list<T>&&, AccumulateFunc);
+            std::initializer_list<T>, AccumulateFunc);
 
     template <typename Container, typename AccumulateFunc>
     class Accumulator {
         private:
-            Container& container;
+            Container container;
             AccumulateFunc accumulate_func;
 
-            // The accumulate function is the only thing allowed to create a Accumulator
             friend Accumulator accumulate<Container, AccumulateFunc>(
                     Container&&, AccumulateFunc);
 
             template <typename T, typename AF>
             friend Accumulator<std::initializer_list<T>, AF> accumulate(
-                    std::initializer_list<T>&&, AF);
+                    std::initializer_list<T>, AF);
             
             // Value constructor for use only in the accumulate function
             Accumulator(Container&& container, AccumulateFunc accumulate_func)
-                : container{container},
+                : container(std::forward<Container>(container)),
                 accumulate_func(accumulate_func)
             { }
-            Accumulator () = delete;
-            Accumulator & operator=(const Accumulator&) = delete;
+            Accumulator() = delete;
+            Accumulator& operator=(const Accumulator&) = delete;
 
         public:
             Accumulator(const Accumulator&) = default;
@@ -50,9 +50,14 @@ namespace iter {
             class Iterator {
                 // AccumVal must be default constructible
                 using AccumVal =
-                    typename std::result_of<AccumulateFunc(
-                            iterator_deref<Container>,
-                            iterator_deref<Container>)>::type;
+                    typename std::remove_reference<
+                        typename std::result_of<AccumulateFunc(
+                                iterator_deref<Container>,
+                                iterator_deref<Container>)>::type>::type;
+                static_assert(
+                        std::is_default_constructible<AccumVal>::value,
+                        "Cannot accumulate a non-default constructible type");
+
                 private:
                     iterator_type<Container> sub_iter;
                     const iterator_type<Container> sub_end;
@@ -113,22 +118,24 @@ namespace iter {
     template <typename Container>
     auto accumulate(Container&& container) -> 
         decltype(accumulate(std::forward<Container>(container),
-                    std::plus<iterator_deref<Container>>{}))
+                    std::plus<typename std::remove_reference<
+                        iterator_deref<Container>>::type>{}))
     {
         return accumulate(std::forward<Container>(container),
-                std::plus<iterator_deref<Container>>{});
+                    std::plus<typename std::remove_reference<
+                        iterator_deref<Container>>::type>{});
     }
 
     template <typename T, typename AccumulateFunc>
     Accumulator<std::initializer_list<T>, AccumulateFunc> accumulate(
-            std::initializer_list<T>&& il,
+            std::initializer_list<T> il,
             AccumulateFunc accumulate_func)
     {
         return {std::move(il), accumulate_func};
     }
 
     template <typename T>
-    auto accumulate(std::initializer_list<T>&& il) ->
+    auto accumulate(std::initializer_list<T> il) ->
         decltype(accumulate(std::move(il), std::plus<T>{}))
     {
         return accumulate(std::move(il), std::plus<T>{});

From 60c34f2e2e1034e876f0ce6c2ad298f4fb985e04 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 1 Jun 2014 16:14:22 -0700
Subject: [PATCH 0362/1866] Adds compress test with temporaries

---
 tests/testcompress.cpp | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/tests/testcompress.cpp b/tests/testcompress.cpp
index ebbeb642..5197f3e2 100644
--- a/tests/testcompress.cpp
+++ b/tests/testcompress.cpp
@@ -53,6 +53,14 @@ int main(void)
     {
         std::cout << i << '\n';
     }
+
+    std::cout << "Should print 0 2 4\n";
+    for (auto i : compress(std::vector<int>{0, 1, 2, 3, 4, 5},
+                std::vector<bool>{true, false, true, false, true}))
+    {
+        std::cout << i << '\n';
+    }
+
         
 
     return 0;

From 58723f241db377739cc1886b4e72fba3e695e147 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 1 Jun 2014 16:16:11 -0700
Subject: [PATCH 0363/1866] Corrects support for temporaries in compress

---
 compress.hpp | 30 +++++++++++++++---------------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/compress.hpp b/compress.hpp
index e6c5b852..94dff629 100644
--- a/compress.hpp
+++ b/compress.hpp
@@ -17,21 +17,21 @@ namespace iter {
 
     template <typename T, typename Selector>
     Compressed<std::initializer_list<T>, Selector> compress(
-            std::initializer_list<T>&&, Selector&&);
+            std::initializer_list<T>, Selector&&);
 
     template <typename Container, typename T>
     Compressed<Container, std::initializer_list<T>> compress(
-            Container&&, std::initializer_list<T>&&);
+            Container&&, std::initializer_list<T>);
 
     template <typename T, typename U>
     Compressed<std::initializer_list<T>, std::initializer_list<U>> compress(
-            std::initializer_list<T>&&, std::initializer_list<U>&&);
+            std::initializer_list<T>, std::initializer_list<U>);
 
     template <typename Container, typename Selector>
     class Compressed  {
         private:
-            Container& container;
-            Selector & selectors;
+            Container container;
+            Selector selectors;
 
             // The only thing allowed to directly instantiate an Compressed is
             // the compress function
@@ -40,24 +40,24 @@ namespace iter {
 
             template <typename T, typename Sel>
             friend Compressed<std::initializer_list<T>, Sel> compress(
-                    std::initializer_list<T>&&, Sel&&);
+                    std::initializer_list<T>, Sel&&);
 
             template <typename Con, typename T>
             friend Compressed<Con, std::initializer_list<T>> compress(
-                    Con&&, std::initializer_list<T>&&);
+                    Con&&, std::initializer_list<T>);
 
             template <typename T, typename U>
             friend Compressed<std::initializer_list<T>, std::initializer_list<U>> compress(
-                    std::initializer_list<T>&&, std::initializer_list<U>&&);
+                    std::initializer_list<T>, std::initializer_list<U>);
 
             
             // Selector::Iterator type
             using selector_iter_type = decltype(std::begin(selectors));
             
             // Value constructor for use only in the compress function
-            Compressed(Container&& container, Selector&& selectors)
-                : container{container},
-                selectors{selectors}
+            Compressed(Container container, Selector selectors)
+                : container(std::forward<Container>(container)),
+                selectors(std::forward<Selector>(selectors))
             { }
             Compressed() = delete;
             Compressed& operator=(const Compressed&) = delete;
@@ -137,22 +137,22 @@ namespace iter {
 
     template <typename T, typename Selector>
     Compressed<std::initializer_list<T>, Selector> compress(
-            std::initializer_list<T>&& data, Selector&& selectors) {
+            std::initializer_list<T> data, Selector&& selectors) {
         return {std::move(data),
                 std::forward<Selector>(selectors)};
     }
 
     template <typename Container, typename T>
     Compressed<Container, std::initializer_list<T>> compress(
-            Container&& container, std::initializer_list<T>&& selectors) {
+            Container&& container, std::initializer_list<T> selectors) {
         return {std::forward<Container>(container),
                 std::move(selectors)};
     }
 
     template <typename T, typename U>
     Compressed<std::initializer_list<T>, std::initializer_list<U>> compress(
-            std::initializer_list<T>&& data,
-            std::initializer_list<U>&& selectors) {
+            std::initializer_list<T> data,
+            std::initializer_list<U> selectors) {
         return {std::move(data),
                 std::move(selectors)};
     }

From 2bdb9bf2824aa0fa9ea282add83e103b7cb90b3d Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 1 Jun 2014 16:24:15 -0700
Subject: [PATCH 0364/1866] Adds cycle test with temporaries

---
 tests/testcycle.cpp | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/tests/testcycle.cpp b/tests/testcycle.cpp
index d7c0f91b..138692cc 100644
--- a/tests/testcycle.cpp
+++ b/tests/testcycle.cpp
@@ -57,5 +57,14 @@ int main() {
         ++count;
     }
 
+    count = 0;
+    for (auto i : std::vector<int>{1,2,3,4,5}) {
+        std::cout << i << '\n';
+        if (count == 20) {
+            break;
+        }
+        ++count;
+    }
+
     return 0;
 }

From 0e979404ebcec5a98bcab293e30152b9552c57ad Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 1 Jun 2014 16:24:27 -0700
Subject: [PATCH 0365/1866] Corrects support for temporaries in cycle

---
 cycle.hpp | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/cycle.hpp b/cycle.hpp
index 76ee4fee..7c2cd8b2 100644
--- a/cycle.hpp
+++ b/cycle.hpp
@@ -17,7 +17,7 @@ namespace iter {
     Cycle<Container> cycle(Container&&);
 
     template <typename T>
-    Cycle<std::initializer_list<T>> cycle(std::initializer_list<T>&&);
+    Cycle<std::initializer_list<T>> cycle(std::initializer_list<T>);
 
     template <typename Container>
     class Cycle {
@@ -26,12 +26,14 @@ namespace iter {
             friend Cycle cycle<Container>(Container&&);
             template <typename T>
             friend Cycle<std::initializer_list<T>> cycle(
-                    std::initializer_list<T>&&);
+                    std::initializer_list<T>);
 
-            Container& container;
+            Container container;
             
             // Value constructor for use only in the cycle function
-            Cycle(Container&& container) : container{container} { }
+            Cycle(Container container)
+                : container(std::forward<Container>(container))
+            { }
             Cycle() = delete;
             Cycle& operator=(const Cycle&) = delete;
 
@@ -92,7 +94,7 @@ namespace iter {
     }
 
     template <typename T>
-    Cycle<std::initializer_list<T>> cycle(std::initializer_list<T>&& il)
+    Cycle<std::initializer_list<T>> cycle(std::initializer_list<T> il)
     {
         return {std::move(il)};
     }

From f8f9773953110cd58bd4877601719ba5f5ef7e04 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 1 Jun 2014 16:25:31 -0700
Subject: [PATCH 0366/1866] removes extra && from ctor args

---
 accumulate.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/accumulate.hpp b/accumulate.hpp
index 8ba6bcba..ef4ed42c 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -37,7 +37,7 @@ namespace iter {
                     std::initializer_list<T>, AF);
             
             // Value constructor for use only in the accumulate function
-            Accumulator(Container&& container, AccumulateFunc accumulate_func)
+            Accumulator(Container container, AccumulateFunc accumulate_func)
                 : container(std::forward<Container>(container)),
                 accumulate_func(accumulate_func)
             { }

From 7732769d68d685bd8f8d9759051027e6a956db27 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 1 Jun 2014 16:33:54 -0700
Subject: [PATCH 0367/1866] Adds dropwhile temporary test and asserts

---
 tests/testdropwhile.cpp | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/tests/testdropwhile.cpp b/tests/testdropwhile.cpp
index 8413e291..3140f81a 100644
--- a/tests/testdropwhile.cpp
+++ b/tests/testdropwhile.cpp
@@ -3,15 +3,19 @@
 
 #include <vector>
 #include <iostream>
+#include <cassert>
 
 using iter::dropwhile;
 using iter::range;
 
 int main() {
     std::vector<int> ivec{1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4};
-    for (auto i : dropwhile([] (int i) {return i < 5;}, ivec)) {
+    for (auto& i : dropwhile([] (int i) {return i < 5;}, ivec)) {
         std::cout << i << '\n';
+        i = 69;
     }
+    assert(ivec.at(0) == 1);
+    assert(ivec.at(4) == 69);
 
     for (auto i : dropwhile([] (int i) {return i < 5;}, range(10))) {
         std::cout << i << '\n';
@@ -22,5 +26,10 @@ int main() {
         std::cout << i << '\n';
     }
 
+    for (auto i : dropwhile([] (int i) {return i < 5;}, 
+                std::vector<int>{1, 2, 3, 4, 5, 6, 7, 8, 9})) {
+        std::cout << i << '\n';
+    }
+
     return 0;
 }

From f3d24fff954ca8b40d55566468c108e034679db7 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 1 Jun 2014 16:36:20 -0700
Subject: [PATCH 0368/1866] Corrects temporary support in dropwhile

---
 dropwhile.hpp | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/dropwhile.hpp b/dropwhile.hpp
index 8f85a55a..fe727916 100644
--- a/dropwhile.hpp
+++ b/dropwhile.hpp
@@ -18,12 +18,12 @@ namespace iter {
 
     template <typename FilterFunc, typename T>
     DropWhile<FilterFunc, std::initializer_list<T>> dropwhile(
-            FilterFunc, std::initializer_list<T>&&);
+            FilterFunc, std::initializer_list<T>);
 
     template <typename FilterFunc, typename Container>
     class DropWhile  {
         private:
-            Container& container;
+            Container container;
             FilterFunc filter_func;
 
             friend DropWhile dropwhile<FilterFunc, Container>(
@@ -31,11 +31,11 @@ namespace iter {
 
             template <typename FF, typename T>
             friend DropWhile<FF, std::initializer_list<T>> dropwhile(
-                    FF, std::initializer_list<T>&&);
+                    FF, std::initializer_list<T>);
             
             // Value constructor for use only in the dropwhile function
-            DropWhile(FilterFunc filter_func, Container&& container)
-                : container{container},
+            DropWhile(FilterFunc filter_func, Container container)
+                : container(std::forward<Container>(container)),
                 filter_func(filter_func)
             { }
             DropWhile() = delete;
@@ -105,7 +105,7 @@ namespace iter {
 
     template <typename FilterFunc, typename T>
     DropWhile<FilterFunc, std::initializer_list<T>> dropwhile(
-            FilterFunc filter_func, std::initializer_list<T>&& il)
+            FilterFunc filter_func, std::initializer_list<T> il)
     {
         return {filter_func, std::move(il)};
     }

From af151faf223c95be4bb4f6e4b6c8c32e24004566 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 1 Jun 2014 16:47:26 -0700
Subject: [PATCH 0369/1866] Adds filter test with temporary

---
 tests/testfilter.cpp | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/tests/testfilter.cpp b/tests/testfilter.cpp
index 0b0b4865..e8af2aab 100644
--- a/tests/testfilter.cpp
+++ b/tests/testfilter.cpp
@@ -72,5 +72,12 @@ int main() {
         std::cout << i << '\n';
     }
 
+    std::cout << "ever numbers in vector temporary\n";
+    for (auto i : filter([] (const int i) {return i % 2 == 0;},
+                         std::vector<int>{1, 2, 3, 4, 5, 6, 7}))
+    {
+        std::cout << i << '\n';
+    }
+
     return 0;
 }

From f66ca160b8f0f8b811655c84b74a41cdf011051f Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 1 Jun 2014 16:47:42 -0700
Subject: [PATCH 0370/1866] Corrects support for temporaries in filter

---
 filter.hpp | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/filter.hpp b/filter.hpp
index d8c67218..870cc2e2 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -18,12 +18,12 @@ namespace iter {
 
     template <typename FilterFunc, typename T>
     Filter<FilterFunc, std::initializer_list<T>> filter(
-            FilterFunc, std::initializer_list<T>&&);
+            FilterFunc, std::initializer_list<T>);
 
     template <typename FilterFunc, typename Container>
     class Filter {
         private:
-            Container& container;
+            Container container;
             FilterFunc filter_func;
 
             // The filter function is the only thing allowed to create a Filter
@@ -32,11 +32,11 @@ namespace iter {
 
             template <typename FF, typename T>
             friend Filter<FF, std::initializer_list<T>> filter(
-                    FF, std::initializer_list<T>&&);
+                    FF, std::initializer_list<T>);
             
             // Value constructor for use only in the filter function
-            Filter(FilterFunc filter_func, Container&& container)
-                : container{container},
+            Filter(FilterFunc filter_func, Container container)
+                : container(std::forward<Container>(container)),
                 filter_func(filter_func)
             { }
             Filter() = delete;
@@ -110,7 +110,7 @@ namespace iter {
     template <typename FilterFunc, typename T>
     Filter<FilterFunc, std::initializer_list<T>> filter(
             FilterFunc filter_func,
-            std::initializer_list<T>&& il)
+            std::initializer_list<T> il)
     {
         return {filter_func, std::move(il)};
     }

From 6fbd9f2274bbef27dfd0f0aff93787d83b899672 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 1 Jun 2014 16:50:06 -0700
Subject: [PATCH 0371/1866] Corrects init list support in filter false

---
 filterfalse.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/filterfalse.hpp b/filterfalse.hpp
index 3beaaef3..27e8cf03 100644
--- a/filterfalse.hpp
+++ b/filterfalse.hpp
@@ -74,7 +74,7 @@ namespace iter {
 
     //specializations for initializer_lists
     template <typename FilterFunc, typename T>
-    auto filterfalse(FilterFunc filter_func, std::initializer_list<T>&& container) ->
+    auto filterfalse(FilterFunc filter_func, std::initializer_list<T> container) ->
             decltype(filter(
                         detail::PredicateFlipper<FilterFunc, std::initializer_list<T>>(
                             filter_func),
@@ -87,7 +87,7 @@ namespace iter {
     // Single argument version, uses a BoolFlipper to reverse the truthiness
     // of an object
     template <typename T>
-    auto filterfalse(std::initializer_list<T>&& container) ->
+    auto filterfalse(std::initializer_list<T> container) ->
             decltype(filter(
                         detail::BoolFlipper<std::initializer_list<T>>(),
                         std::move(container))) {

From 429d18f72195b200c458dbeb8d67e1fe03d13ca6 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 1 Jun 2014 16:51:14 -0700
Subject: [PATCH 0372/1866] removes extra &&

---
 filter.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/filter.hpp b/filter.hpp
index 870cc2e2..d8986128 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -143,7 +143,7 @@ namespace iter {
     }
 
     template <typename T>
-    auto filter(std::initializer_list<T>&& il) ->
+    auto filter(std::initializer_list<T> il) ->
             decltype(filter(
                         detail::BoolTester<std::initializer_list<T>>(),
                         std::move(il))) {

From 6abd33956c74458670ced35fd79dcf2fa4c1c39a Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 1 Jun 2014 16:53:14 -0700
Subject: [PATCH 0373/1866] Adds filterfalse test with temporaries

---
 tests/testfilterfalse.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/tests/testfilterfalse.cpp b/tests/testfilterfalse.cpp
index 0ff0fad0..9063d0bf 100644
--- a/tests/testfilterfalse.cpp
+++ b/tests/testfilterfalse.cpp
@@ -83,5 +83,11 @@ int main() {
         std::cout << i << '\n';
     }
 
+    std::cout << "vector temporary with default\n";
+    for (auto i : filterfalse(
+                std::vector<int>{-1, -2, 0, 0, 0, 0, 1, 2, 3})) {
+        std::cout << i << '\n';
+    }
+
     return 0;
 }

From 4a7fb3250f5feb8d23693f71a0d71753d5c567d8 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 1 Jun 2014 16:58:45 -0700
Subject: [PATCH 0374/1866] Add groupby test with temporary

---
 tests/testgroupby.cpp | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/tests/testgroupby.cpp b/tests/testgroupby.cpp
index 89aace14..9fc03ee3 100644
--- a/tests/testgroupby.cpp
+++ b/tests/testgroupby.cpp
@@ -89,6 +89,18 @@ int main()
         }
         std::cout << '\n';
     }
+
+    std::cout << "with vector temporary:\n";
+    for (auto gb : groupby(
+                std::vector<char>{'a', 'a', 'b', 'b', 'c', 'c', 'd', 'd'},
+                [] (const char c) {return c < 'c'; })) {
+        std::cout << "key: " << gb.first << '\n';
+        std::cout << "content: ";
+        for (auto s : gb.second) {
+            std::cout << s << "  ";
+        }
+        std::cout << '\n';
+    }
         
 
     return 0;

From fb8d17fdbbf4da77e2ca39ea399e1381c8ecc67f Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 1 Jun 2014 17:01:36 -0700
Subject: [PATCH 0375/1866] Corrects support for temporaries in groupby

---
 groupby.hpp | 18 +++++++-----------
 1 file changed, 7 insertions(+), 11 deletions(-)

diff --git a/groupby.hpp b/groupby.hpp
index ec956012..51360bfb 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -17,30 +17,26 @@ namespace iter {
 
     template <typename T, typename KeyFunc>
     GroupBy<std::initializer_list<T>, KeyFunc> groupby(
-            std::initializer_list<T>&&, KeyFunc);
+            std::initializer_list<T>, KeyFunc);
 
     template <typename Container, typename KeyFunc>
     class GroupBy  {
         private:
-            Container& container;
+            Container container;
             KeyFunc key_func;
 
             friend GroupBy groupby<Container, KeyFunc>(Container&&, KeyFunc);
 
             template <typename T, typename KF>
             friend GroupBy<std::initializer_list<T>, KF> groupby(
-                    std::initializer_list<T>&&, KF);
-
-            
-
-            
+                    std::initializer_list<T>, KF);
 
             using key_func_ret =
                 decltype(std::declval<KeyFunc>()(
                             std::declval<iterator_deref<Container>>()));
 
-            GroupBy(Container&& container, KeyFunc key_func)
-                : container{container},
+            GroupBy(Container container, KeyFunc key_func)
+                : container(std::forward<Container>(container)),
                 key_func(key_func)
             { }
 
@@ -249,13 +245,13 @@ namespace iter {
     
     template <typename T, typename KeyFunc>
     GroupBy<std::initializer_list<T>, KeyFunc> groupby(
-            std::initializer_list<T>&& il, KeyFunc key_func) {
+            std::initializer_list<T> il, KeyFunc key_func) {
         return {std::move(il), key_func};
     }
 
 
     template <typename T>
-    auto groupby(std::initializer_list<T>&& il) ->
+    auto groupby(std::initializer_list<T> il) ->
             decltype(groupby(std::move(il),
                         ItemReturner<std::initializer_list<T>>())) {
         return groupby(

From 4d7453ecddaf170500d8a00d09bf380c287c0548 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 1 Jun 2014 17:18:42 -0700
Subject: [PATCH 0376/1866] Adds sorted test with temporary

---
 tests/testsorted.cpp | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/tests/testsorted.cpp b/tests/testsorted.cpp
index 2a0bea29..aed57d32 100644
--- a/tests/testsorted.cpp
+++ b/tests/testsorted.cpp
@@ -8,7 +8,7 @@ using iter::sorted;
 
 int main()
 {
-    std::vector<int> vec = {19, 3, 45, 32, 10, 0, 90, 15, 1, 7, 5, 6, 69};
+    std::vector<int> vec = {19, 45, 32, 10, 0, 90, 15, 1, 7, 5, 6, 69};
     for (auto i : sorted(vec)) {
         std::cout << i << '\n';
     }
@@ -28,5 +28,9 @@ int main()
     }
         
 
+    for (auto i : sorted(
+                std::vector<int>{19, 45, 32, 10, 0, 90, 15, 1, 7, 5, 6, 69})) {
+        std::cout << i << '\n';
+    }
     return 0;
 }

From 46e75b4df0085b6e1e31a590a1413ad92c51cd62 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 1 Jun 2014 17:38:09 -0700
Subject: [PATCH 0377/1866] Adds support for temporaries to sorted +more

This one was weird because sorted didn't support temporaries at all
previously.  Additionally it was using the older style of getting the
iterator type and dereferencing type, rather that doing
iterator_type<Container> and deref.  It's much better now.
---
 sorted.hpp | 42 ++++++++++++++++++++----------------------
 1 file changed, 20 insertions(+), 22 deletions(-)

diff --git a/sorted.hpp b/sorted.hpp
index 15d36b22..349fc881 100644
--- a/sorted.hpp
+++ b/sorted.hpp
@@ -12,28 +12,32 @@ namespace iter {
     class Sorted;
 
     template <typename Container, typename CompareFunc>
-    Sorted<Container, CompareFunc> sorted(Container&, CompareFunc);
+    Sorted<Container, CompareFunc> sorted(Container&&, CompareFunc);
 
     template <typename Container, typename CompareFunc>
     class Sorted  {
         private:
+            Container container;
+            std::vector<iterator_type<Container>> sorted_iters;
+
             friend Sorted
-                sorted<Container, CompareFunc>(Container&, CompareFunc);
+                sorted<Container, CompareFunc>(Container&&, CompareFunc);
 
-            std::vector<iterator_type<Container>> sorted_iters;
+            using sorted_iter_type = iterator_type<decltype(sorted_iters)>;
 
-            using sorted_iter_type = decltype(std::begin(sorted_iters));
 
             Sorted() = delete;
             Sorted& operator=(const Sorted&) = delete;
 
-            Sorted(Container& container, CompareFunc compare_func) {
+            Sorted(Container in_container, CompareFunc compare_func)
+                : container(std::forward<Container>(in_container))
+            {
                 // Fill the sorted_iters vector with an iterator to each
                 // element in the container
-                for (auto iter = std::begin(container);
-                        iter != std::end(container);
+                for (auto iter = std::begin(this->container);
+                        iter != std::end(this->container);
                         ++iter) {
-                    sorted_iters.push_back(iter);
+                    this->sorted_iters.push_back(iter);
                 }
 
                 // sort by comparing the elements that the iterators point to
@@ -74,24 +78,18 @@ namespace iter {
 
     template <typename Container, typename CompareFunc>
     Sorted<Container, CompareFunc> sorted(
-            Container& container, CompareFunc compare_func) {
-        return {container, compare_func};
+            Container&& container, CompareFunc compare_func) {
+        return {std::forward<Container>(container), compare_func};
     }
 
     template <typename Container>
-    auto sorted(Container& container) ->
-             decltype(sorted(
-                         container,
-                         std::less<decltype(
-                             *std::begin(std::declval<Container>()))>()
-                         ))
+    auto sorted(Container&& container) ->
+             decltype(sorted(std::forward<Container>(container),
+                         std::less<iterator_deref<Container>>()))
      {
-         return sorted(
-                 container,
-                 std::less<decltype(
-                     *std::begin(std::declval<Container>()))>()
-                 );
-    }
+         return sorted(std::forward<Container>(container),
+                 std::less<iterator_deref<Container>>());
+     }
 
 }
 

From 395e704111f094eaa37219debc0e49c823a8a059 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 1 Jun 2014 17:47:38 -0700
Subject: [PATCH 0378/1866] Corrects support for temporaries in takewhile

---
 takewhile.hpp | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/takewhile.hpp b/takewhile.hpp
index 5fadc0ce..528f6fb0 100644
--- a/takewhile.hpp
+++ b/takewhile.hpp
@@ -18,12 +18,12 @@ namespace iter {
 
     template <typename FilterFunc, typename T>
     TakeWhile<FilterFunc, std::initializer_list<T>> takewhile(
-            FilterFunc, std::initializer_list<T>&&);
+            FilterFunc, std::initializer_list<T>);
 
     template <typename FilterFunc, typename Container>
     class TakeWhile {
         private:
-            Container& container;
+            Container container;
             FilterFunc filter_func;
 
             friend TakeWhile takewhile<FilterFunc, Container>(
@@ -31,11 +31,11 @@ namespace iter {
 
             template <typename FF, typename T>
             friend TakeWhile<FF, std::initializer_list<T>> takewhile(
-                    FF, std::initializer_list<T>&&);
+                    FF, std::initializer_list<T>);
 
             // Value constructor for use only in the takewhile function
-            TakeWhile(FilterFunc filter_func, Container&& container)
-                : container{container},
+            TakeWhile(FilterFunc filter_func, Container container)
+                : container(std::forward<Container>(container)),
                 filter_func(filter_func)
             { }
 
@@ -116,7 +116,7 @@ namespace iter {
 
     template <typename FilterFunc, typename T>
     TakeWhile<FilterFunc, std::initializer_list<T>> takewhile(
-            FilterFunc filter_func, std::initializer_list<T>&& il)
+            FilterFunc filter_func, std::initializer_list<T> il)
     {
         return {filter_func, std::move(il)};
     }

From b02bee7407d83b8ddb3191ed7df49dba6585f027 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 1 Jun 2014 20:10:33 -0700
Subject: [PATCH 0379/1866] Adds slice test with temporary

---
 tests/testslice.cpp | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/tests/testslice.cpp b/tests/testslice.cpp
index cc19f455..eaf8e1ce 100644
--- a/tests/testslice.cpp
+++ b/tests/testslice.cpp
@@ -1,7 +1,8 @@
+#include <iostream>
+
 #include <slice.hpp>
 #include <range.hpp>
 
-#include <iostream>
 #include <vector>
 #include <array>
 
@@ -71,4 +72,10 @@ int main() {
         std::cout << i << '\n';
     }
 
+    std::cout << "\nvector temporary\n";
+    for (auto i : iter::slice(
+                std::vector<int>{1, 2, 4, 8, 16, 32, 64, 128}, 2, 6)) {
+        std::cout << i << '\n';
+    }
+
 }

From 84f0cbc2018b6aa6708f882d96456fe37aeaaaaf Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 1 Jun 2014 20:11:18 -0700
Subject: [PATCH 0380/1866] Corrects slice temporary support

---
 slice.hpp | 52 +++++++++++++++++++++++++---------------------------
 1 file changed, 25 insertions(+), 27 deletions(-)

diff --git a/slice.hpp b/slice.hpp
index ec3035f1..7e1e0d26 100644
--- a/slice.hpp
+++ b/slice.hpp
@@ -15,7 +15,7 @@ namespace iter {
     //class Slice;
 
     //template <typename T>
-    //Slice<std::initializer_list<T>> slice( std::initializer_list<T> &&);
+    //Slice<std::initializer_list<T>> slice( std::initializer_list<T>);
 
     //template <typename Container, typename DifferenceType>
     //Slice<Container> slice(Container &&);
@@ -33,19 +33,19 @@ namespace iter {
         enum { value = sizeof(test<T>(0)) == sizeof(char) };
     };
     template <typename Container>
-    typename std::enable_if<has_size<Container>::value,size_t>::type 
-    size(Container & container) {
+    typename std::enable_if<has_size<Container>::value, std::size_t>::type 
+    size(const Container& container) {
         return container.size();
     }
 
     template <typename Container>
-    typename std::enable_if<!has_size<Container>::value,size_t>::type 
-    size(Container & container) {
+    typename std::enable_if<!has_size<Container>::value, std::size_t>::type 
+    size(const Container& container) {
         return std::distance(std::begin(container), std::end(container));
     }
 
-    template <typename T, size_t N>
-    size_t size(T (&)[N]) {
+    template <typename T, std::size_t N>
+    std::size_t size(const T (&)[N]) {
         return N;
     }
 
@@ -54,7 +54,7 @@ namespace iter {
     template <typename Container, typename DifferenceType>
     class Slice {
         private:
-            Container & container;
+            Container container;
             DifferenceType start;
             DifferenceType stop;
             DifferenceType step;
@@ -63,17 +63,11 @@ namespace iter {
             // the slice function
             //friend Slice slice<Container, DifferenceType>(Container &&);
             //template <typename T>
-            //friend Slice<std::initializer_list<T>> slice(std::initializer_list<T> &&);
-
-            
-
-            
-
-            
+            //friend Slice<std::initializer_list<T>> slice(std::initializer_list<T>);
         public:
-            Slice(Container & container, DifferenceType start,
+            Slice(Container in_container, DifferenceType start,
                   DifferenceType stop, DifferenceType step)
-                : container{container},
+                : container(std::forward<Container>(in_container)),
                 start{start},
                 stop{stop},
                 step{step}
@@ -83,16 +77,20 @@ namespace iter {
                         (start > stop && step >=0)){
                     this->stop = start;
                 } 
-                if (this->stop > static_cast<DifferenceType>(size(container))) {
-                    this->stop = static_cast<DifferenceType>(size(container));
+                if (this->stop > static_cast<DifferenceType>(
+                            size(this->container))) {
+                    this->stop = static_cast<DifferenceType>(size(
+                                this->container));
+                    std::cout << "stop is too large\n";
+                    std::cout << "stop is now: " << this->stop << '\n';
                 }
                 if (this->start < 0) {
                     this->start = 0; 
                 }
             }
 
-            Slice () = delete;
-            Slice & operator=(const Slice &) = delete;
+            Slice() = delete;
+            Slice& operator=(const Slice&) = delete;
 
             Slice(const Slice &) = default;
 
@@ -117,7 +115,7 @@ namespace iter {
                         return *this->sub_iter;
                     }
 
-                    Iterator & operator++() { 
+                    Iterator& operator++() { 
                         std::advance(this->sub_iter, this->step);
                         this->current += this->step;
                         return *this;
@@ -144,28 +142,28 @@ namespace iter {
     // Helper function to instantiate a Slice
     template <typename Container, typename DifferenceType>
     Slice<Container, DifferenceType> slice(
-            Container && container, DifferenceType start,
-            DifferenceType stop, DifferenceType step=1) {
+            Container&& container,
+            DifferenceType start, DifferenceType stop, DifferenceType step=1) {
         return {std::forward<Container>(container), start, stop, step};
     }
 
     //only give the end as an arg and assume step  is 1 and begin is 0
     template <typename Container, typename DifferenceType>
     Slice<Container, DifferenceType> slice(
-            Container && container, DifferenceType stop) {
+            Container&& container, DifferenceType stop) {
         return {std::forward<Container>(container), 0, stop, 1};
     }
 
     template <typename T, typename DifferenceType>
     Slice<std::initializer_list<T>, DifferenceType> slice(
-            std::initializer_list<T> && il, DifferenceType start,
+            std::initializer_list<T> il, DifferenceType start,
             DifferenceType stop, DifferenceType step=1) {
         return {il, start, stop, step};
     }
 
     template <typename T, typename DifferenceType>
     Slice<std::initializer_list<T>, DifferenceType> slice(
-            std::initializer_list<T> && il, DifferenceType stop) {
+            std::initializer_list<T> il, DifferenceType stop) {
         return {il, 0, stop, 1};
     }
 }

From 70b0668cbf1d33a102637ce7c6381ef1ab08367e Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 1 Jun 2014 20:20:20 -0700
Subject: [PATCH 0381/1866] Adds takewhile test with temporary

---
 tests/testtakewhile.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/tests/testtakewhile.cpp b/tests/testtakewhile.cpp
index 6cbd6e17..bec3aeae 100644
--- a/tests/testtakewhile.cpp
+++ b/tests/testtakewhile.cpp
@@ -22,5 +22,11 @@ int main() {
         std::cout << i << '\n';
     }
 
+    std::cout << "with temporary\n";
+    for (auto i : takewhile([] (int i) {return i < 5;}, 
+                std::vector<int>{1, 2, 3, 4, 5, 6, 7, 8, 9})) {
+        std::cout << i << '\n';
+    }
+
     return 0;
 }

From 6c962c9d0e4bac9d1558c1287607f23b60886b15 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 2 Jun 2014 22:19:12 -0700
Subject: [PATCH 0382/1866] renames reverse -> reversed

---
 reverse.hpp => reversed.hpp                 |  0
 tests/{testreverse.cpp => testreversed.cpp} | 12 ++++++------
 2 files changed, 6 insertions(+), 6 deletions(-)
 rename reverse.hpp => reversed.hpp (100%)
 rename tests/{testreverse.cpp => testreversed.cpp} (66%)

diff --git a/reverse.hpp b/reversed.hpp
similarity index 100%
rename from reverse.hpp
rename to reversed.hpp
diff --git a/tests/testreverse.cpp b/tests/testreversed.cpp
similarity index 66%
rename from tests/testreverse.cpp
rename to tests/testreversed.cpp
index 089de31b..d2ca082a 100644
--- a/tests/testreverse.cpp
+++ b/tests/testreversed.cpp
@@ -1,4 +1,4 @@
-#include <reverse.hpp>
+#include <reversed.hpp>
 
 #include <iostream>
 #include <vector>
@@ -9,23 +9,23 @@ int main () {
     {
         std::vector<int> a{1,2,3,4,5,6,7};
         std::vector<std::string> b{"hey","how","are","you","doing"};
-        std::cout << std::endl << "Reverse range test" << std::endl << std::endl;
-        for (auto i : iter::reverse(a)) {
+        std::cout << std::endl << "reversed range test" << std::endl << std::endl;
+        for (auto i : iter::reversed(a)) {
             std::cout << i << std::endl;
         }
         std::cout<<std::endl;
         //modify a
-        for (auto & i : iter::reverse(a)) {
+        for (auto & i : iter::reversed(a)) {
             std::cout << i << std::endl;
             i = 9;
         }
         std::cout<<std::endl;
-        for (auto i : iter::reverse(a)) {
+        for (auto i : iter::reversed(a)) {
             std::cout << i << std::endl;
         }
         std::cout<<std::endl;
         //try strings
-        for (auto s : iter::reverse(b)) {
+        for (auto s : iter::reversed(b)) {
             std::cout << s << std::endl;
         }
     }

From daf04eeb0f646f3324d72911b58fbbbc6236804c Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 2 Jun 2014 22:19:28 -0700
Subject: [PATCH 0383/1866] renames reverse -> reversed

---
 reversed.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/reversed.hpp b/reversed.hpp
index 14e8352c..0833f9a0 100644
--- a/reversed.hpp
+++ b/reversed.hpp
@@ -5,7 +5,7 @@
 
 namespace iter {
     template <typename Container>
-       auto reverse(Container && container) -> iterator_range<decltype(container.rbegin())>
+       auto reversed(Container && container) -> iterator_range<decltype(container.rbegin())>
        {
            return 
                iterator_range<decltype(container.rbegin())>(container.rbegin(),container.rend());

From 98fa5b8186d3ab1cba278fd6347ac0c78c30e8c7 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 2 Jun 2014 22:20:52 -0700
Subject: [PATCH 0384/1866] renames reverse in SConstruct

---
 tests/SConstruct | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/SConstruct b/tests/SConstruct
index e38c0914..7c0b7cb9 100644
--- a/tests/SConstruct
+++ b/tests/SConstruct
@@ -5,6 +5,7 @@ env = Environment(
     CXX='c++',
     CXXFLAGS= ['-g', '-Wall', '-Wextra',
                '-pedantic', '-std=c++11',
+                '-fdiagnostics-color=always',
                '-I/usr/local/include'],
     CPPPATH='..',
     LINKFLAGS='-L/usr/local/lib')
@@ -19,7 +20,7 @@ progs = Split('''
               range 
               zip 
               slice 
-              reverse 
+              reversed 
               filter 
               repeat 
               takewhile 
@@ -37,7 +38,6 @@ progs = Split('''
               filterfalse
               grouper
               chain
-              command_chains
               groupby
               sorted
               unique_justseen

From 0e82aa0272be2c22be6f9ba3c6e33775c1890453 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 2 Jun 2014 22:38:01 -0700
Subject: [PATCH 0385/1866] Adds reversed test with temporary

---
 tests/testreversed.cpp | 49 +++++++++++++++++++++++-------------------
 1 file changed, 27 insertions(+), 22 deletions(-)

diff --git a/tests/testreversed.cpp b/tests/testreversed.cpp
index d2ca082a..433e0c80 100644
--- a/tests/testreversed.cpp
+++ b/tests/testreversed.cpp
@@ -6,27 +6,32 @@
 #include <string>
 
 int main () {
-    {
-        std::vector<int> a{1,2,3,4,5,6,7};
-        std::vector<std::string> b{"hey","how","are","you","doing"};
-        std::cout << std::endl << "reversed range test" << std::endl << std::endl;
-        for (auto i : iter::reversed(a)) {
-            std::cout << i << std::endl;
-        }
-        std::cout<<std::endl;
-        //modify a
-        for (auto & i : iter::reversed(a)) {
-            std::cout << i << std::endl;
-            i = 9;
-        }
-        std::cout<<std::endl;
-        for (auto i : iter::reversed(a)) {
-            std::cout << i << std::endl;
-        }
-        std::cout<<std::endl;
-        //try strings
-        for (auto s : iter::reversed(b)) {
-            std::cout << s << std::endl;
-        }
+    std::vector<int> a{1,2,3,4,5,6,7};
+    std::vector<std::string> b{"hey","how","are","you","doing"};
+    std::cout << std::endl << "reversed range test" << std::endl << std::endl;
+    for (auto i : iter::reversed(a)) {
+        std::cout << i << std::endl;
     }
+    std::cout<<std::endl;
+    //modify a
+    for (auto & i : iter::reversed(a)) {
+        std::cout << i << std::endl;
+        i = 9;
+    }
+    std::cout<<std::endl;
+    for (auto i : iter::reversed(a)) {
+        std::cout << i << std::endl;
+    }
+    std::cout<<std::endl;
+    //try strings
+    for (auto s : iter::reversed(b)) {
+        std::cout << s << std::endl;
+    }
+
+    std::cout << "with temporary\n";
+    for (auto i : iter::reversed(std::vector<int>{1, 2, 3, 4, 5, 6, 7})) {
+        std::cout << i << std::endl;
+    }
+
+
 }

From e99a5af0748ebf780775d4658f63c6898b146d90 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 2 Jun 2014 22:38:16 -0700
Subject: [PATCH 0386/1866] Reverse support for temporaries

---
 reversed.hpp | 77 ++++++++++++++++++++++++++++++++++++++++++++++------
 1 file changed, 68 insertions(+), 9 deletions(-)

diff --git a/reversed.hpp b/reversed.hpp
index 0833f9a0..4f721f3e 100644
--- a/reversed.hpp
+++ b/reversed.hpp
@@ -1,15 +1,74 @@
-#ifndef REVERSE_HPP
-#define REVERSE_HPP
+#ifndef REVERSE_HPP__
+#define REVERSE_HPP__
 
-#include "iterator_range.hpp"
+#include "iterbase.hpp"
+
+#include <utility>
+#include <iterator>
 
 namespace iter {
+
+    //Forward declarations of Reverser and reversed
+    template <typename Container>
+    class Reverser;
+
+    template <typename Container>
+    Reverser<Container> reversed(Container&&);
+
+    template <typename Container>
+    class Reverser {
+        private:
+            Container container;
+            // The reversed function is the only thing allowed to create a
+            // Reverser
+            friend Reverser reversed<Container>(Container&&);
+            
+            // Value constructor for use only in the reversed function
+            Reverser(Container container)
+                : container(std::forward<Container>(container))
+            { }
+            Reverser() = delete;
+            Reverser& operator=(const Reverser&) = delete;
+
+        public:
+            Reverser(const Reverser&) = default;
+            class Iterator {
+                private:
+                    reverse_iterator_type<Container> sub_iter;
+                public:
+                    Iterator (reverse_iterator_type<Container> iter)
+                        : sub_iter{iter}
+                    { } 
+
+                    reverse_iterator_deref<Container> operator*() {
+                        return *this->sub_iter;
+                    }
+
+                    Iterator& operator++() { 
+                        ++this->sub_iter;
+                        return *this;
+                    }
+
+                    bool operator!=(const Iterator& other) const {
+                        return this->sub_iter != other.sub_iter;
+                    }
+            };
+
+            Iterator begin() {
+                return {this->container.rbegin()};
+            }
+
+            Iterator end() {
+                return {this->container.rend()};
+            }
+
+    };
+
+    // Helper function to instantiate an Filter
     template <typename Container>
-       auto reversed(Container && container) -> iterator_range<decltype(container.rbegin())>
-       {
-           return 
-               iterator_range<decltype(container.rbegin())>(container.rbegin(),container.rend());
-       }
+    Reverser<Container> reversed(Container&& container) {
+        return {std::forward<Container>(container)};
+    }
 }
 
-#endif //REVERSE_HPP
+#endif //REVERSE_HPP__

From c3c666071e59f6717c320fb37c7da0f65c993d7e Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 2 Jun 2014 22:54:02 -0700
Subject: [PATCH 0387/1866] small comment fix

---
 cycle.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cycle.hpp b/cycle.hpp
index 7c2cd8b2..d683b8da 100644
--- a/cycle.hpp
+++ b/cycle.hpp
@@ -87,7 +87,7 @@ namespace iter {
 
     };
 
-    // Helper function to instantiate an Filter
+    // Helper function to instantiate a Cycle
     template <typename Container>
     Cycle<Container> cycle(Container&& container) {
         return {std::forward<Container>(container)};

From 19da133195af594bd384aea86fe748f75b12dddc Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 2 Jun 2014 23:25:54 -0700
Subject: [PATCH 0388/1866] Support for statically allocated arrays in reversed

---
 reversed.hpp | 90 ++++++++++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 88 insertions(+), 2 deletions(-)

diff --git a/reversed.hpp b/reversed.hpp
index 4f721f3e..0cd836e1 100644
--- a/reversed.hpp
+++ b/reversed.hpp
@@ -7,7 +7,6 @@
 #include <iterator>
 
 namespace iter {
-
     //Forward declarations of Reverser and reversed
     template <typename Container>
     class Reverser;
@@ -15,6 +14,7 @@ namespace iter {
     template <typename Container>
     Reverser<Container> reversed(Container&&);
 
+
     template <typename Container>
     class Reverser {
         private:
@@ -64,11 +64,97 @@ namespace iter {
 
     };
 
-    // Helper function to instantiate an Filter
+    // Helper function to instantiate a Reverser
     template <typename Container>
     Reverser<Container> reversed(Container&& container) {
         return {std::forward<Container>(container)};
     }
+
+    //
+    //
+    // specialization for statically allocated arrays
+    // this involves some tricks
+    //
+    template <typename T, std::size_t N>
+    Reverser<T[N]> reversed(T (&)[N]);
+
+    template <typename T, std::size_t N>
+    class Reverser<T[N]> {
+        private:
+            T *array;
+            // The reversed function is the only thing allowed to create a
+            // Reverser
+            friend Reverser reversed<T, N>(T (&)[N]);
+            
+            // Value constructor for use only in the reversed function
+            Reverser(T *array)
+                : array{array}
+            { }
+            Reverser() = delete;
+            Reverser& operator=(const Reverser&) = delete;
+
+        public:
+            Reverser(const Reverser&) = default;
+            class Iterator {
+                private:
+                    T *sub_iter;
+                    T *stop;
+                    T *dummy_end;
+                public:
+                    // iter should be the last element in the array
+                    // stop should be the first element
+                    // dummy should be what iter is set to when complete
+                    //    the implementation below sets the dummy to one-past-
+                    //    the end, since that's the only non-nullptr value that
+                    //    the pointer can be set to that is also not a part
+                    //    of the actual array
+                    Iterator (T *iter, T *stop, T *dummy)
+                        : sub_iter{iter},
+                        stop{stop},
+                        dummy_end{dummy}
+                    { } 
+
+                    auto operator*() -> decltype(*array) {
+                        return *this->sub_iter;
+                    }
+
+                    Iterator& operator++() { 
+                        if (this->sub_iter == this->stop) {
+                            this->sub_iter = this->dummy_end;
+                        } else {
+                            // decrementing the pointer is going forwards
+                            // in the reversed direction
+                            --this->sub_iter;
+                        }
+                        return *this;
+                    }
+
+                    bool operator!=(const Iterator& other) const {
+                        return this->sub_iter != other.sub_iter;
+                    }
+            };
+
+            T *dummy_end() const {
+                return this->array + N;
+            }
+
+            Iterator begin() {
+                return {this->array + N - 1,
+                        this->array,
+                        this->dummy_end()};
+            }
+
+            Iterator end() {
+            return {this->dummy_end(), this->dummy_end(), this->dummy_end()};
+            }
+
+    };
+
+    template <typename T, std::size_t N>
+    Reverser<T[N]> reversed(T (&array)[N]) {
+        return {array};
+    }
+
 }
 
 #endif //REVERSE_HPP__

From 41b1e8270ff9441028505991b89da7eda414971e Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 2 Jun 2014 23:26:18 -0700
Subject: [PATCH 0389/1866] Adds deduction for reverse_iterator type

---
 iterbase.hpp | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/iterbase.hpp b/iterbase.hpp
index 84fa8c32..85595b3a 100644
--- a/iterbase.hpp
+++ b/iterbase.hpp
@@ -22,6 +22,17 @@ namespace iter {
     template <typename Container>
     using iterator_deref = 
         decltype(*std::declval<iterator_type<Container>&>());
+
+    // iterator_type<C> is the type of C's iterator
+    template <typename Container>
+    using reverse_iterator_type =
+        decltype(std::declval<Container&>().rbegin());
+
+    // iterator_deref<C> is the type obtained by dereferencing an iterator
+    // to an object of type C
+    template <typename Container>
+    using reverse_iterator_deref = 
+        decltype(*std::declval<reverse_iterator_type<Container>&>());
 }
 
 #endif // #ifndef ITERBASE__HPP__

From a6be8b21fb206f8d2fbd3d46fa444540baafe3f9 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 2 Jun 2014 23:27:16 -0700
Subject: [PATCH 0390/1866] changeds reverse to reversed in gitignore

---
 tests/.gitignore | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/.gitignore b/tests/.gitignore
index de362625..87ae4e97 100644
--- a/tests/.gitignore
+++ b/tests/.gitignore
@@ -7,7 +7,7 @@ testenumerate
 testrange
 testslice
 testzip
-testreverse
+testreversed
 testrepeat
 testfilter
 testzip_longest

From f3636aefe7c71126c3b774ad697f3fbbd5e0f0c9 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 2 Jun 2014 23:27:54 -0700
Subject: [PATCH 0391/1866] adds reversed test with statically allocated array

---
 tests/testreversed.cpp | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/tests/testreversed.cpp b/tests/testreversed.cpp
index 433e0c80..c6d0ab46 100644
--- a/tests/testreversed.cpp
+++ b/tests/testreversed.cpp
@@ -30,7 +30,13 @@ int main () {
 
     std::cout << "with temporary\n";
     for (auto i : iter::reversed(std::vector<int>{1, 2, 3, 4, 5, 6, 7})) {
-        std::cout << i << std::endl;
+        std::cout << i << '\n';
+    }
+
+    std::cout << "statically sized array\n";
+    int arr[] = {1, 2, 3, 4, 5, 6, 7};
+    for (auto i : iter::reversed(arr)) {
+        std::cout << i << '\n';
     }
 
 

From c42864d1b59e679dbafaa76c6607d4bea202fc11 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 3 Jun 2014 22:16:17 -0700
Subject: [PATCH 0392/1866] replaces reverse with reversed in readme

---
 README.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index d8a4bd0b..a5964bef 100644
--- a/README.md
+++ b/README.md
@@ -23,7 +23,7 @@ evaluation wherever possible.
 [accumulate](#accumulate)<br />
 [compress](#compress)<br />
 [chain](#chain)<br />
-[reverse](#reverse)<br />
+[reversed](#reversed)<br />
 [slice](#slice)<br />
 [sliding_window](#sliding_window)<br />
 [grouper](#grouper)<br />
@@ -352,13 +352,13 @@ for (auto i : chain(empty,vec1,arr1)) {
 }
 ```
 
-reverse
+reversed
 -------
 
 Iterates over elements of a sequence in reverse order.
 
 ```c++
-for (auto i : reverse(a)) {                                          
+for (auto i : reversed(a)) {                                          
     cout << i << '\n';                                           
 }
 ```

From 9d90f0883a5e3ec97b1d47cf114e18fb1f03fb4b Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 3 Jun 2014 22:17:41 -0700
Subject: [PATCH 0393/1866] Renames reverse to reversed in itertools.hpp

---
 itertools.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/itertools.hpp b/itertools.hpp
index 5b038ef8..67a59e37 100644
--- a/itertools.hpp
+++ b/itertools.hpp
@@ -21,7 +21,7 @@
 #include "product.hpp"
 #include "range.hpp"
 #include "repeat.hpp"
-#include "reverse.hpp"
+#include "reversed.hpp"
 #include "slice.hpp"
 #include "sorted.hpp"
 #include "takewhile.hpp"

From 773d434b116a07daa18b7b1c0ec0a7ad11a2f220 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 7 Jun 2014 23:29:05 -0700
Subject: [PATCH 0394/1866] adds tests for movable temporaries

---
 tests/testrepeat.cpp | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/tests/testrepeat.cpp b/tests/testrepeat.cpp
index eb414685..b91fba03 100644
--- a/tests/testrepeat.cpp
+++ b/tests/testrepeat.cpp
@@ -3,6 +3,7 @@
 #include <vector>
 #include <array>
 #include <string>
+#include <memory>
 
 int main () {
     int a = 10;
@@ -16,4 +17,15 @@ int main () {
     for (auto num : iter::repeat(a,10)) {//goes ten times
         std::cout << num << std::endl;
     }
+    
+    std::cout << "with temporary\n";
+    for (auto s : iter::repeat(std::string{"hey"}, 2)) {
+        std::cout <<  s << '\n';
+    }
+
+    std::cout << "with uptr temporary\n";
+    for (auto& p : iter::repeat(std::unique_ptr<int>{new int{2}}, 2)) {
+        std::cout << *p << '\n';
+    }
+
 }

From 739dfc5aebceeef121964e1cf5a1d3a362664353 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 7 Jun 2014 23:35:13 -0700
Subject: [PATCH 0395/1866] Rewrites repeat to support temps and bind to lvals

More similar to python's repeat, the new version will bind to any lvalue
passed in, which I believe to be the expected behavior.  This
modification changes the semantics of repeat() from it's previous
implementation in that the item worked on is no longer a copy of an
lvalue that was passed, but a reference to it.
---
 repeat.hpp | 94 +++++++++++++++++++++++++++++++++++-------------------
 1 file changed, 62 insertions(+), 32 deletions(-)

diff --git a/repeat.hpp b/repeat.hpp
index f7438f07..29991c9c 100644
--- a/repeat.hpp
+++ b/repeat.hpp
@@ -1,49 +1,79 @@
-#ifndef REPEAT_HPP
-#define REPEAT_HPP
-
-#include "iterator_range.hpp"
+#ifndef REPEAT_HPP__
+#define REPEAT_HPP__
 
 #include <iterator>
+#include <utility>
 
 namespace iter {
-    template <typename Elem>
-    class repeat_iter {
+
+    // must me negative
+    constexpr int INFINITE_REPEAT = -1;
+
+    template <typename T>
+    class Repeater;
+
+    template <typename T>
+    Repeater<T> repeat(T&&, int count =INFINITE_REPEAT);
+
+    template <typename T>
+    class Repeater {
+        friend Repeater repeat<T>(T&&, int);
         private:
-            const Elem elem;
-            const size_t until;
-            size_t start=0;
-        public:
-            repeat_iter(const Elem & elem, size_t until) : 
-                elem(elem),
-                until(until)
+            T elem;
+            int count;
+
+            Repeater(T e, int c)
+                : elem(std::forward<T>(e)),
+                count{c}
             { }
+        public:
 
-            repeat_iter & operator++() {
-                if (this->until != 0) ++start; //no point in repeating 0 times
-                //so use that to repeat infinitely
-                return *this;
-            }
+            class Iterator {
+                private:
+                    T& elem;
+                    int count;
+                public:
+                    Iterator(T& e, int c)
+                        : elem{e},
+                        count{c}
+                    { }
+
+                    // count down to 0
+                    // INFINITE_REPEAT will be negative, and in that case
+                    // the value is never decremented, it will always compare
+                    // != to an end iterator
+                    Iterator& operator++() {
+                        if (this->count > 0) {
+                            --this->count;
+                        }
+                        return *this;
+                    }
 
-            bool operator!=(const repeat_iter &) const {
-                return this->until == 0 || this->start != this->until;
+                    bool operator!=(const Iterator& other) const {
+                        return this->count != other.count ||
+                            &this->elem != &other.elem;
+                    }
+
+                    T& operator*() {
+                        return this->elem;
+                    }
+            };
+
+            Iterator begin() {
+                return {this->elem, this->count};
             }
 
-            Elem operator*() const {
-                return this->elem;
+            Iterator end() {
+                return {this->elem, 0};
             }
+
     };
 
-    //-1 causes it to repeat infintely 
-    template <typename Elem>
-    iterator_range<repeat_iter<Elem>> repeat(
-            const Elem & elem,
-            size_t until=0)
-    {
-        return iterator_range<repeat_iter<Elem>>(
-                repeat_iter<Elem>(elem, until),
-                repeat_iter<Elem>(elem, until));//just a dummy iter
+    template <typename T>
+    Repeater<T> repeat(T&& e, int count) {
+        return {std::forward<T>(e), count};
     }
         
 }
 
-#endif //REPEAT_HPP
+#endif //REPEAT_HPP__

From bbc69ea877b85b8b0d123f8112413f603242809b Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 8 Jun 2014 11:52:39 -0700
Subject: [PATCH 0396/1866] Replaces chain function with callable object

This is in preparation for chain.from_iterable
---
 chain.hpp | 28 +++++++++++++++++-----------
 1 file changed, 17 insertions(+), 11 deletions(-)

diff --git a/chain.hpp b/chain.hpp
index 0e57ce09..84dc47e9 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -6,16 +6,13 @@
 #include <type_traits>
 
 namespace iter {
-    template <typename Container, typename...RestContainers>
-    class Chained;
-
-    template <typename... Containers>
-    Chained<Containers...> chain(Containers&&...);
+    // rather than a chain function, use a callable object to support
+    // from_iterable
+    class ChainMaker;
 
     template <typename Container, typename... RestContainers>
     class Chained {
-        friend Chained chain<Container, RestContainers...>(
-                Container&&, RestContainers&&...);
+        friend class ChainMaker;
         template <typename C, typename... RC>
         friend class Chained;
 
@@ -84,7 +81,7 @@ namespace iter {
     };
     template <typename Container>
     class Chained<Container> {
-        friend Chained chain<Container>(Container&&);
+        friend class ChainMaker;
         template <typename C, typename... RC>
         friend class Chained;
 
@@ -132,8 +129,17 @@ namespace iter {
             }
     };
 
-    template <typename... Containers>
-    Chained<Containers...> chain(Containers&&... containers) {
-        return {std::forward<Containers>(containers)...};
+    class ChainMaker {
+        public:
+            // expose regular call operator to provide usual chain()
+            template <typename... Containers>
+            Chained<Containers...> operator()(Containers&&... cs) const {
+                return {std::forward<Containers>(cs)...};
+            }
+    };
+
+    namespace {
+        constexpr auto chain = ChainMaker{};
     }
+
 }

From c898657540dee41ddd26cbb0f8366c2f05cb7737 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 8 Jun 2014 14:46:21 -0700
Subject: [PATCH 0397/1866] Adds test for chain.fromiterable

---
 tests/.gitignore                |  1 +
 tests/SConstruct                |  1 +
 tests/testchainfromiterable.cpp | 28 ++++++++++++++++++++++++++++
 3 files changed, 30 insertions(+)
 create mode 100644 tests/testchainfromiterable.cpp

diff --git a/tests/.gitignore b/tests/.gitignore
index 87ae4e97..7daa7f9d 100644
--- a/tests/.gitignore
+++ b/tests/.gitignore
@@ -2,6 +2,7 @@
 *.swp
 testaccumulate
 testchain
+testchainfromiterable
 testcycle
 testenumerate
 testrange
diff --git a/tests/SConstruct b/tests/SConstruct
index 7c0b7cb9..9ca7f7fd 100644
--- a/tests/SConstruct
+++ b/tests/SConstruct
@@ -38,6 +38,7 @@ progs = Split('''
               filterfalse
               grouper
               chain
+              chainfromiterable
               groupby
               sorted
               unique_justseen
diff --git a/tests/testchainfromiterable.cpp b/tests/testchainfromiterable.cpp
new file mode 100644
index 00000000..f4b6d599
--- /dev/null
+++ b/tests/testchainfromiterable.cpp
@@ -0,0 +1,28 @@
+#include <chain.hpp>
+
+#include <iostream>
+#include <vector>
+
+using iter::chain;
+
+int main() {
+    std::vector<std::vector<int>> matrix = {
+        {1, 2, 3},
+        {4, 5},
+        {6, 8, 9, 10, 11, 12}
+    };
+    for (auto i : chain.from_iterable(matrix)) {
+        std::cout << i << '\n';
+    }
+
+    std::cout << "with temporary\n";
+    for (auto i : chain.from_iterable(std::vector<std::vector<int>>{
+                    {1, 2, 3},
+                    {4, 5},
+                    {6, 8, 9, 10, 11, 12}
+                })) {
+        std::cout << i << '\n';
+    }
+
+    return 0;
+}

From 72ce2ceeb46e94032773eb8ad4115f2d3240e7bf Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 8 Jun 2014 15:00:33 -0700
Subject: [PATCH 0398/1866] Adds chain.from_iterable

Works with an iterable of iterables, rather than a variadic number of
iterables
---
 chain.hpp | 82 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 82 insertions(+)

diff --git a/chain.hpp b/chain.hpp
index 84dc47e9..e5df892d 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -1,7 +1,11 @@
+#ifndef CHAIN__HPP__
+#define CHAIN__HPP__
+
 #include "iterbase.hpp"
 
 #include <utility>
 #include <iterator>
+#include <memory>
 #include <initializer_list>
 #include <type_traits>
 
@@ -129,6 +133,75 @@ namespace iter {
             }
     };
 
+    template <typename Container>
+    class ChainedFromIterable {
+        private:
+            Container container;
+            friend class ChainMaker;
+            ChainedFromIterable(Container container)
+                : container(std::forward<Container>(container))
+            { }
+
+        public:
+            class Iterator {
+                private:
+                    using SubContainer = iterator_deref<Container>;
+                    using SubIter = iterator_type<SubContainer>;
+
+                   iterator_type<Container> top_level_iter;
+                   const iterator_type<Container> top_level_end;
+                   std::unique_ptr<SubIter> sub_iter_p;
+                   std::unique_ptr<SubIter> sub_end_p;
+                public:
+                   Iterator(iterator_type<Container> top_iter,
+                           iterator_type<Container> top_end)
+                       : top_level_iter{top_iter},
+                       top_level_end{top_end},
+                       sub_iter_p{!(top_iter != top_end) ?  // iter == end ?
+                           nullptr : new SubIter{std::begin(*top_iter)}},
+                       sub_end_p{!(top_iter != top_end) ?  // iter == end ?
+                           nullptr : new SubIter{std::end(*top_iter)}}
+                   { }
+
+                   Iterator& operator++() {
+                       ++*this->sub_iter_p;
+                       if (!(*this->sub_iter_p != *this->sub_end_p)) {
+                           ++this->top_level_iter;
+                           if (this->top_level_iter != this->top_level_end) {
+                               sub_iter_p.reset(
+                                       new SubIter{std::begin(*this->top_level_iter)});
+                               sub_end_p.reset(
+                                       new SubIter{std::end(*this->top_level_iter)});
+                           } else {
+                               sub_iter_p.reset(nullptr);
+                               sub_end_p.reset(nullptr);
+                           }
+                       }
+                       return *this;
+                   }
+                       
+
+                   bool operator!=(const Iterator& other) const {
+                       return this->top_level_iter != other.top_level_iter &&
+                           (this->sub_iter_p != other.sub_iter_p ||
+                            *this->sub_iter_p != *other.sub_iter_p);
+                   }
+
+                   iterator_deref<iterator_deref<Container>> operator*() {
+                       return **this->sub_iter_p;
+                   }
+           };
+
+           Iterator begin() {
+               return {std::begin(this->container), std::end(this->container)};
+           }
+
+           Iterator end() {
+               return {std::end(this->container), std::end(this->container)};
+           }
+    };
+
+
     class ChainMaker {
         public:
             // expose regular call operator to provide usual chain()
@@ -136,6 +209,13 @@ namespace iter {
             Chained<Containers...> operator()(Containers&&... cs) const {
                 return {std::forward<Containers>(cs)...};
             }
+
+            // chain.from_iterable
+            template <typename Container>
+            ChainedFromIterable<Container> from_iterable(
+                    Container&& container) const {
+                return {std::forward<Container>(container)};
+            }
     };
 
     namespace {
@@ -143,3 +223,5 @@ namespace iter {
     }
 
 }
+
+#endif //#define CHAIN__HPP__

From 2fa51679d3e10894ebd88e48243c442630743a83 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 8 Jun 2014 18:10:40 -0700
Subject: [PATCH 0399/1866] Adds chain.from_iterable to README

---
 README.md | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/README.md b/README.md
index a5964bef..e62a8cce 100644
--- a/README.md
+++ b/README.md
@@ -23,6 +23,7 @@ evaluation wherever possible.
 [accumulate](#accumulate)<br />
 [compress](#compress)<br />
 [chain](#chain)<br />
+[chain.from\_iterable](#chain.from_iterable)<br />
 [reversed](#reversed)<br />
 [slice](#slice)<br />
 [sliding_window](#sliding_window)<br />
@@ -352,6 +353,25 @@ for (auto i : chain(empty,vec1,arr1)) {
 }
 ```
 
+chain.from_iterable
+-------------------
+
+Similar to chain, but rather than taking a variadic number of iterables,
+it takes an iterable of iterables and chains the contained iterables together.
+A simple example is shown below using a vector of vectors to represent
+a 2d ragged array, and prints it in row-major order.
+```c++
+vector<vector<int>> matrix = {
+    {1, 2, 3},
+    {4, 5},
+    {6, 8, 9, 10, 11, 12}
+};
+
+for (auto i : chain.from_iterable(matrix)) {
+    cout << i << '\n';
+}
+```
+
 reversed
 -------
 

From 5c58485108c2128a56e81419cf25ed1cecddcb98 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 6 Jul 2014 22:40:07 -0700
Subject: [PATCH 0400/1866] replaces SO explosion implementation

---
 imap.hpp | 101 ++++++++++++++++++++++++++++---------------------------
 1 file changed, 51 insertions(+), 50 deletions(-)

diff --git a/imap.hpp b/imap.hpp
index 3cc01371..b3e934aa 100644
--- a/imap.hpp
+++ b/imap.hpp
@@ -8,60 +8,59 @@
 
 namespace iter {
 
-    // Everything in detail namespace 
-    // modified from http://stackoverflow.com/questions/10766112/
-    // Question by Thomas http://stackoverflow.com/users/115355/thomas
-    // Answer by Kerrek SB http://stackoverflow.com/users/596781/kerrek-sb
-    namespace detail
-    {
-        // implementation details, users never invoke these directly
-        template <typename F, typename Tuple, bool Done, int Total, int... N>
-        struct call_impl
+    namespace detail {
+
+    template <std::size_t Index, typename Functor, typename Tup>
+    struct Expander {
+        template <typename... Ts>
+        static auto call(Functor&& f, Tup&& tup, Ts&&... args)
+            -> decltype(Expander<Index-1, Functor, Tup>::call(
+                    std::forward<Functor>(f),
+                    std::forward<Tup>(tup),
+                    std::get<Index-1>(tup),
+                    std::forward<Ts>(args)...))
         {
-            static auto call(F f, Tuple&& t) -> 
-                decltype(call_impl<F,
-                    Tuple,
-                    Total == 1 + sizeof...(N),
-                    Total,
-                    N...,
-                    sizeof...(N)>::call(f, std::forward<Tuple>(t)))
-            {
-                return call_impl<F,
-                    Tuple,
-                    Total == 1 + sizeof...(N),
-                    Total,
-                    N...,
-                    sizeof...(N)>::call(f, std::forward<Tuple>(t));
-            }
-        };
+            // recurse
+            return Expander<Index-1, Functor, Tup>::call(
+                    std::forward<Functor>(f),
+                    std::forward<Tup>(tup),
+                    std::get<Index-1>(tup), // pull out one element
+                    std::forward<Ts>(args)...); // everything already expanded
+        }
+    };
 
-        template <typename F, typename Tuple, int Total, int... N>
-        struct call_impl<F, Tuple, true, Total, N...>
-        {
-            static auto call(F f, Tuple&& t) -> 
-                decltype(f(std::get<N>(std::forward<Tuple>(t))...))
-            {
-                return f(std::get<N>(std::forward<Tuple>(t))...);
-            }
-        };
-
-        // user invokes this
-        template <typename F, typename Tuple>
-        auto call(F f, Tuple&& t) -> 
-            decltype(call_impl<F,
-                Tuple,
-                0 == std::tuple_size<typename std::decay<Tuple>::type>::value,
-                std::tuple_size<typename std::decay<Tuple>::type>::value>
-                ::call(f,std::forward<Tuple>(t)))
+    template <typename Functor, typename Tup>
+    struct Expander<0, Functor, Tup> {
+        template <typename... Ts>
+        static auto call(Functor&& f, Tup&&, Ts&&... args)
+            -> decltype(f(std::forward<Ts>(args)...))
         {
-            typedef typename std::decay<Tuple>::type ttype;
-            return call_impl<F,
-                Tuple,
-                0 == std::tuple_size<ttype>::value,
-                std::tuple_size<ttype>::value>::call(f,std::forward<Tuple>(t));
+            static_assert(
+                std::tuple_size<
+                    typename std::remove_reference<Tup>::type>::value
+                    == sizeof...(Ts),
+                "tuple has not been fully expanded");
+            return f(std::forward<Ts>(args)...); // the actual call
         }
+    };
+
+    template <typename Functor, typename Tup>
+    auto call_with_tuple(Functor&& f, Tup&& tup)
+        -> decltype(Expander<std::tuple_size<
+                    typename std::remove_reference<Tup>::type>::value,
+                    Functor, Tup>::call(
+                        std::forward<Functor>(f),
+                        std::forward<Tup>(tup)))
+    {
+        return Expander<std::tuple_size<
+            typename std::remove_reference<Tup>::type>::value,
+            Functor, Tup>::call(
+                std::forward<Functor>(f),
+                std::forward<Tup>(tup));
     }
 
+    } // end detail
+
     //Forward declarations of IMap and imap
     template <typename MapFunc, typename... Containers>
     class IMap;
@@ -102,9 +101,11 @@ namespace iter {
                     { } 
 
                     auto operator*() const -> 
-                        decltype(detail::call(this->map_func, *(this->zipiter)))
+                        decltype(detail::call_with_tuple(
+                                    this->map_func, *(this->zipiter)))
                     {
-                        return detail::call(this->map_func, *(this->zipiter));
+                        return detail::call_with_tuple(
+                                this->map_func, *(this->zipiter));
                     }
 
                     Iterator& operator++() { 

From 7d9cae1a94e40571cc4773e9c994e0dc82659006 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 27 Jul 2014 23:32:21 -0700
Subject: [PATCH 0401/1866] tests combinations with temporary and static array

---
 tests/testcombinations.cpp | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/tests/testcombinations.cpp b/tests/testcombinations.cpp
index 2576dc94..1153ed21 100644
--- a/tests/testcombinations.cpp
+++ b/tests/testcombinations.cpp
@@ -25,9 +25,24 @@ int main() {
         for (auto j : i ) std::cout << j << " ";
         std::cout<<std::endl;
     }
+    std::cout << "initializer list\n";
     for (auto i : combinations({1,2,3,4},3)) {
         for (auto j : i ) std::cout << j << " ";
         std::cout<<std::endl;
     }
+
+    std::cout << "temporary\n";
+    for (auto i : combinations(std::vector<int>{1,2,3,4,5}, 3)) {
+        for (auto j : i ) std::cout << j << " ";
+        std::cout<<std::endl;
+    }
+
+    std::cout << "static array\n";
+    int array[] = {1,2,3,4,5};
+    for (auto i : combinations(array, 3)) {
+        for (auto j : i) std::cout << j << " ";
+        std::cout << '\n';
+    }
+
     return 0;
 }

From 94dc3afee90f687b2df1de1c7b433edc928d7b30 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 27 Jul 2014 23:43:07 -0700
Subject: [PATCH 0402/1866] adds support for temporaries to combinations

(breaks powerset)
---
 combinations.hpp | 201 ++++++++++++++++++++++++-----------------------
 1 file changed, 101 insertions(+), 100 deletions(-)

diff --git a/combinations.hpp b/combinations.hpp
index 1ff9a991..6ef85f4d 100644
--- a/combinations.hpp
+++ b/combinations.hpp
@@ -1,125 +1,126 @@
-#ifndef COMBINATIONS_HPP
-#define COMBINATIONS_HPP
+#ifndef COMBINATIONS_HPP_
+#define COMBINATIONS_HPP_
 
-#include "iterator_range.hpp"
+#include "iterbase.hpp"
 
-#include <array>
 #include <vector>
 #include <type_traits>
 #include <iterator>
-#include <iostream>
 #include <initializer_list>
 
 namespace iter {
-    //Could try having antoher template for container to return (right now it's
-    //just an std::vector)
     template <typename Container>
-        struct combinations_iter;
-
-    template <typename Container>
-        iterator_range<combinations_iter<Container>>
-        combinations(const Container & container, size_t N) {
-            auto begin = combinations_iter<Container>(container,N);
-            auto end = combinations_iter<Container>(container,N);
-            return 
-                iterator_range<combinations_iter<Container>>(begin,end);
-        }
-    template <typename T>
-        iterator_range<combinations_iter<std::initializer_list<T>>>
-        combinations(std::initializer_list<T> && container, size_t N) {
-            auto begin = combinations_iter<std::initializer_list<T>>(container,N);
-            auto end = combinations_iter<std::initializer_list<T>>(container,N);
-            return {begin,end};
-        }
-    template <typename Container>
-        struct combinations_iter
-        {
+    class Combinator {
         private:
-            const Container & items;
-            std::vector<decltype(std::begin(items))> indicies;
-            bool not_done = true;
-
+            Container container;
+            std::size_t length;
         public:
-            //Holy shit look at this typedef
-            using item_t = typename 
-                std::remove_const<
-                typename std::remove_reference<decltype(*(std::begin(items)))>::type>::type;
-            combinations_iter(const Container & i, size_t N) : 
-                items(i),indicies(N)
-            {
-                if (N == 0) {
-                    not_done = false;
-                    return;
-                }
-                size_t inc = 0;
-                for (auto & iter : indicies) {
-                    if (std::begin(items) + inc != std::end(items)) {
-                        iter = std::begin(items)+inc;
-                        ++inc;
-                    }
-                    else {
+            Combinator(Container in_container, std::size_t in_length)
+                : container(std::forward<Container>(in_container)),
+                length{in_length}
+            { }
+
+
+        class Iterator {
+            private:
+                Container& items;
+                std::vector<iterator_type<Container>> indicies;
+                bool not_done = true;
+
+                using item_t = typename 
+                    std::remove_const<
+                    typename std::remove_reference<iterator_deref<Container>>::type>::type;
+
+            public:
+                Iterator(Container& i, size_t N)
+                    : items(i),
+                    indicies(N)
+                {
+                    if (N == 0) {
                         not_done = false;
-                        break;
+                        return;
+                    }
+                    size_t inc = 0;
+                    for (auto& iter : indicies) {
+                        if (std::begin(items) + inc != std::end(items)) {
+                            iter = std::begin(items)+inc;
+                            ++inc;
+                        }
+                        else {
+                            not_done = false;
+                            break;
+                        }
                     }
                 }
-            }
-            std::vector<item_t> operator*() const
-            {
-                std::vector<item_t> values;
-                for (auto i : indicies) {
-                    values.push_back(*i);
+
+                std::vector<item_t> operator*() {
+                    std::vector<item_t> values;
+                    for (auto i : indicies) {
+                        values.push_back(*i);
+                    }
+                    return values;
                 }
-                return values;
-            }
 
 
-            combinations_iter &
-            operator++() 
-            {
-                for (auto iter = indicies.rbegin(); iter != indicies.rend(); ++iter) {
-                    ++(*iter);
-                    //what we have to check here is if the distance between the
-                    //index and the end of indicies is >= the distance between
-                    //the item and end of item
-                    if ((*iter + std::distance(indicies.rbegin(),iter)) ==
-                            std::end(items)) {
-                        if ( (iter + 1) != indicies.rend()) {
-                            size_t inc = 1;
-                            for (auto down = iter; down != indicies.rbegin()-1;--down) {
-                                (*down) = (*(iter + 1)) + 1 + inc;
-                                /*if (*down == items.cend()) {
-                                    iter = iter + 1;
-                                }*/
-                                ++inc;
+                Iterator& operator++() {
+                    for (auto iter = indicies.rbegin(); iter != indicies.rend(); ++iter) {
+                        ++(*iter);
+                        //what we have to check here is if the distance between the
+                        //index and the end of indicies is >= the distance between
+                        //the item and end of item
+                        if ((*iter + std::distance(indicies.rbegin(),iter)) ==
+                                std::end(items)) {
+                            if ( (iter + 1) != indicies.rend()) {
+                                size_t inc = 1;
+                                for (auto down = iter; down != indicies.rbegin()-1;--down) {
+                                    (*down) = (*(iter + 1)) + 1 + inc;
+                                    /*if (*down == items.cend()) {
+                                        iter = iter + 1;
+                                    }*/
+                                    ++inc;
+                                }
+                            }
+                            else {
+                                not_done = false;
+                                break;
                             }
                         }
-                        else {
-                            not_done = false;
-                            break;
-                        }
+                        else break; 
+                        //we break because none of the rest of the items need to 
+                        //be incremented
                     }
-                    else break; 
-                    //we break because none of the rest of the items need to 
-                    //be incremented
+                    return *this;
                 }
-                return *this;
-            }
 
-            bool operator !=(const combinations_iter &)
-            {
-                //because of the way this is done you have to start from the 
-                //begining of the range and end at the end, you could break in 
-                //the middle of the loop though, it's not different from the way
-                //that python's works
-                return not_done;
-            }
+                bool operator !=(const Iterator&)
+                {
+                    //because of the way this is done you have to start from the 
+                    //begining of the range and end at the end, you could break in 
+                    //the middle of the loop though, it's not different from the way
+                    //that python's works
+                    return not_done;
+                }
         };
-}
-namespace std {
+
+        Iterator begin() {
+            return {this->container, this->length};
+        }
+        
+        Iterator end() {
+            return {this->container, this->length};
+        }
+    };
+
     template <typename Container>
-        struct iterator_traits<iter::combinations_iter<Container>> {
-            using difference_type = ptrdiff_t;
-            using iterator_category = input_iterator_tag;
-        };
+    Combinator<Container> combinations(
+            Container&& container, std::size_t length) {
+        return {std::forward<Container>(container), length};
+    }
+
+    template <typename T>
+    Combinator<std::initializer_list<T>> combinations(
+            std::initializer_list<T> il, std::size_t length) {
+        return {il, length};
+    }
 }
-#endif //COMBINATIONS_HPP
+#endif //#ifndef COMBINATIONS_HPP_

From 9e77e47f4ef90f4ab9f09ecc964ef5f11586d090 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 28 Jul 2014 20:58:53 -0700
Subject: [PATCH 0403/1866] only combinations() can make a Combinator

---
 combinations.hpp | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/combinations.hpp b/combinations.hpp
index 6ef85f4d..704363c9 100644
--- a/combinations.hpp
+++ b/combinations.hpp
@@ -9,11 +9,26 @@
 #include <initializer_list>
 
 namespace iter {
+    template <typename Container>
+    class Combinator;
+
+    template <typename Container>
+    Combinator<Container> combinations(Container&&, std::size_t);
+
+    template <typename T>
+    Combinator<std::initializer_list<T>> combinations(
+            std::initializer_list<T>, std::size_t);
+
     template <typename Container>
     class Combinator {
         private:
             Container container;
             std::size_t length;
+
+            friend Combinator combinations<Container>(Container&&,std::size_t);
+            template <typename T>
+            friend Combinator<std::initializer_list<T>> combinations(
+                    std::initializer_list<T>, std::size_t);
         public:
             Combinator(Container in_container, std::size_t in_length)
                 : container(std::forward<Container>(in_container)),

From 00d981d6960c0faa21cfc40cddb1dff9e63b29ce Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 28 Jul 2014 21:09:54 -0700
Subject: [PATCH 0404/1866] formatting

---
 combinations.hpp | 38 +++++++++++++++++++++-----------------
 1 file changed, 21 insertions(+), 17 deletions(-)

diff --git a/combinations.hpp b/combinations.hpp
index 704363c9..31c43ef0 100644
--- a/combinations.hpp
+++ b/combinations.hpp
@@ -44,7 +44,8 @@ namespace iter {
 
                 using item_t = typename 
                     std::remove_const<
-                    typename std::remove_reference<iterator_deref<Container>>::type>::type;
+                        typename std::remove_reference<
+                            iterator_deref<Container>>::type>::type;
 
             public:
                 Iterator(Container& i, size_t N)
@@ -60,8 +61,7 @@ namespace iter {
                         if (std::begin(items) + inc != std::end(items)) {
                             iter = std::begin(items)+inc;
                             ++inc;
-                        }
-                        else {
+                        } else {
                             not_done = false;
                             break;
                         }
@@ -78,41 +78,45 @@ namespace iter {
 
 
                 Iterator& operator++() {
-                    for (auto iter = indicies.rbegin(); iter != indicies.rend(); ++iter) {
+                    for (auto iter = indicies.rbegin();
+                            iter != indicies.rend();
+                            ++iter) {
                         ++(*iter);
-                        //what we have to check here is if the distance between the
-                        //index and the end of indicies is >= the distance between
-                        //the item and end of item
+                        //what we have to check here is if the distance between
+                        //the index and the end of indicies is >= the distance
+                        //between the item and end of item
                         if ((*iter + std::distance(indicies.rbegin(),iter)) ==
                                 std::end(items)) {
                             if ( (iter + 1) != indicies.rend()) {
                                 size_t inc = 1;
-                                for (auto down = iter; down != indicies.rbegin()-1;--down) {
+                                for (auto down = iter;
+                                        down != indicies.rbegin()-1;
+                                        --down) {
                                     (*down) = (*(iter + 1)) + 1 + inc;
                                     /*if (*down == items.cend()) {
                                         iter = iter + 1;
                                     }*/
                                     ++inc;
                                 }
-                            }
-                            else {
+                            } else {
                                 not_done = false;
                                 break;
                             }
+                        } else {
+                            break; 
                         }
-                        else break; 
-                        //we break because none of the rest of the items need to 
-                        //be incremented
+                        //we break because none of the rest of the items need
+                        //to be incremented
                     }
                     return *this;
                 }
 
                 bool operator !=(const Iterator&)
                 {
-                    //because of the way this is done you have to start from the 
-                    //begining of the range and end at the end, you could break in 
-                    //the middle of the loop though, it's not different from the way
-                    //that python's works
+                    //because of the way this is done you have to start from
+                    //the begining of the range and end at the end, you could
+                    //break in the middle of the loop though, it's not
+                    //different from the way that python's works
                     return not_done;
                 }
         };

From e9bbe4987599175da65d0994d1c45a2b31fed593 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 28 Jul 2014 21:59:47 -0700
Subject: [PATCH 0405/1866] fixes combinations to work despite clang bug

---
 combinations.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/combinations.hpp b/combinations.hpp
index 31c43ef0..a6b4c984 100644
--- a/combinations.hpp
+++ b/combinations.hpp
@@ -57,7 +57,7 @@ namespace iter {
                         return;
                     }
                     size_t inc = 0;
-                    for (auto& iter : indicies) {
+                    for (auto& iter : this->indicies) {
                         if (std::begin(items) + inc != std::end(items)) {
                             iter = std::begin(items)+inc;
                             ++inc;

From 3d95314f1b4c9af670038eafb6ecb424b2af7e7f Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 30 Jul 2014 22:11:05 -0700
Subject: [PATCH 0406/1866] restores privacy, really

---
 combinations.hpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/combinations.hpp b/combinations.hpp
index a6b4c984..4853bd73 100644
--- a/combinations.hpp
+++ b/combinations.hpp
@@ -29,12 +29,13 @@ namespace iter {
             template <typename T>
             friend Combinator<std::initializer_list<T>> combinations(
                     std::initializer_list<T>, std::size_t);
-        public:
+
             Combinator(Container in_container, std::size_t in_length)
                 : container(std::forward<Container>(in_container)),
                 length{in_length}
             { }
 
+        public:
 
         class Iterator {
             private:

From 2214b2ccd745a06145ea1fd9fdc860b01f3d1b31 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 1 Aug 2014 13:38:06 -0700
Subject: [PATCH 0407/1866] test with init list and combination size of 1

---
 tests/testcombinations.cpp | 5 +++++
 tests/testpowerset.cpp     | 6 ++++++
 2 files changed, 11 insertions(+)

diff --git a/tests/testcombinations.cpp b/tests/testcombinations.cpp
index 1153ed21..f8c67582 100644
--- a/tests/testcombinations.cpp
+++ b/tests/testcombinations.cpp
@@ -30,6 +30,11 @@ int main() {
         for (auto j : i ) std::cout << j << " ";
         std::cout<<std::endl;
     }
+    std::cout << "initializer list\n";
+    for (auto i : combinations({1,2,3,4},1)) {
+        for (auto j : i ) std::cout << j << " ";
+        std::cout<<std::endl;
+    }
 
     std::cout << "temporary\n";
     for (auto i : combinations(std::vector<int>{1,2,3,4,5}, 3)) {
diff --git a/tests/testpowerset.cpp b/tests/testpowerset.cpp
index 10f92c52..d4acbbd9 100644
--- a/tests/testpowerset.cpp
+++ b/tests/testpowerset.cpp
@@ -10,10 +10,16 @@ int main() {
         for (auto i : v) std::cout << i << " ";
         std::cout << std::endl;
     }
+    for (auto v : powerset(std::vector<int>{1,2})) {
+        for (auto i : v) std::cout << i << " ";
+        std::cout << std::endl;
+    }
     for (auto v : powerset({1,2,3,4})) {
         for (auto i : v) std::cout << i << " ";
         std::cout << std::endl;
     }
+#if 0
+#endif
 
     return 0;
 }

From 651f17216d9d66425d07746df6f700796cf16ea1 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 1 Aug 2014 13:47:01 -0700
Subject: [PATCH 0408/1866] powerset supports temps, error with init lists

a valgrind error occurs betwee the first two combinations of
initializer lists
---
 powerset.hpp | 128 +++++++++++++++++++++++++++------------------------
 1 file changed, 68 insertions(+), 60 deletions(-)

diff --git a/powerset.hpp b/powerset.hpp
index 178bd756..d92d419f 100644
--- a/powerset.hpp
+++ b/powerset.hpp
@@ -1,76 +1,84 @@
-#ifndef POWERSET_HPP
-#define POWERSET_HPP
+#ifndef POWERSET_HPP_
+#define POWERSET_HPP_
 
-#include "iterator_range.hpp"
+#include "iterbase.hpp"
 #include "combinations.hpp"
 
+#include <vector>
 #include <initializer_list>
+#include <utility>
+#include <iterator>
 
 namespace iter {
     template <typename Container>
-        struct powerset_iter;
+    class Powersetter {
+        private:
+            Container container;
 
-    template <typename Container>
-        iterator_range<powerset_iter<Container>>
-        powerset(const Container & container)
-        {
-            auto begin = powerset_iter<Container>(container);
-            auto end = powerset_iter<Container>(container);
-            return iterator_range<powerset_iter<Container>>(begin,end);
-        }
+        public:
+            Powersetter(Container container)
+                : container(std::forward<Container>(container))
+            { }
 
-    template <typename T>
-        iterator_range<powerset_iter<std::initializer_list<T>>>
-        powerset(std::initializer_list<T> && container)
-        {
-            auto begin = powerset_iter<std::initializer_list<T>>(container);
-            auto end = powerset_iter<std::initializer_list<T>>(container);
-            return {begin,end};
-        }
+            class Iterator {
+                private:
+                    std::size_t container_size;
+                    std::size_t list_size = 0;
+                    bool not_done = true;
+
+                    using CombinatorType =
+                        decltype(combinations(std::declval<Container&>(), 0));
+                    std::vector<CombinatorType> combinators;
+                    std::vector<iterator_type<CombinatorType>> inner_iters;
+                public:
+                    Iterator(Container& container)
+                        : container_size{container.size()}
+                    {
+                        for (std::size_t i = 0; i <= container_size; ++i) {
+                            combinators.push_back(combinations(container, i));
+                            inner_iters.push_back(std::begin(combinators.back()));
+                        }
+                    }
 
+                    Iterator& operator++() {
+                        ++inner_iters[list_size];
+                        if (!(inner_iters[list_size] != inner_iters[list_size])) {
+                            ++list_size;
+                        }
+                        if (container_size < list_size) {
+                            not_done = false;
+                        }
 
-    template <typename Container>
-        struct powerset_iter {
-        private:
-            const Container & container;
-            size_t list_size = 0;
-            std::vector<combinations_iter<Container>> inner_iters;
-            bool not_done = true;
-        public:
-            powerset_iter(const Container & c) : 
-                container(c),
-                inner_iters()
-                {
-                    for (size_t i = 0; i <= container.size();++i) {
-                        inner_iters.push_back(combinations_iter<Container>(container,i));
+                        return *this;
                     }
-                }
-            //default constructor
-            powerset_iter & operator++()
-            {
-                ++(inner_iters[list_size]);
-                
-                if (!(inner_iters[list_size] != inner_iters[list_size])) {
-                    ++list_size;
-                    //inner_iter = combinations_iter<Container>(container,list_size);
-                }
-                if (container.size() < list_size) not_done = false;
-                return *this;
-            }
-            auto operator*() const -> decltype(*inner_iters[list_size]) 
-            {
-                return *(inner_iters[list_size]);
+
+                    auto operator*() -> decltype(*inner_iters[0]) {
+                        return *(inner_iters[list_size]);
+                    }
+
+                    bool operator != (const Iterator&) {
+                        return not_done;
+                    }
+            }; 
+
+            Iterator begin() {
+                return {this->container};
             }
-            bool operator != (const powerset_iter &) {
-               return not_done;
+
+            Iterator end() {
+                return {this->container};
             }
-        }; 
-}
-namespace std {
+    };
+
     template <typename Container>
-        struct iterator_traits<iter::powerset_iter<Container>> {
-            using difference_type = ptrdiff_t;
-            using iterator_category = input_iterator_tag;
-        };
+    Powersetter<Container> powerset(Container&& container) {
+        return {std::forward<Container>(container)};
+    }
+
+    template <typename T>
+    Powersetter<std::initializer_list<T>> powerset(
+            std::initializer_list<T> il) {
+        return {il};
+    }
 }
-#endif //POWERSET_HPP
+#endif // #ifndef POWERSET_HPP_

From fd3ce25749a9da59aec71aa2b5d822e54f964456 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 1 Aug 2014 13:57:22 -0700
Subject: [PATCH 0409/1866] Fixes init list bug, makes iterators faster

The creation of the combinators happens at the Powersetter level rather
than within the Iterator's constructor.  This fixes the error with the
initializer_lists.
---
 powerset.hpp | 32 +++++++++++++++++++-------------
 1 file changed, 19 insertions(+), 13 deletions(-)

diff --git a/powerset.hpp b/powerset.hpp
index d92d419f..e0e7b566 100644
--- a/powerset.hpp
+++ b/powerset.hpp
@@ -10,15 +10,22 @@
 #include <iterator>
 
 namespace iter {
-    template <typename Container>
+    template <typename Container,
+              typename CombinatorType=
+                  decltype(combinations(std::declval<Container&>(), 0))>
     class Powersetter {
         private:
             Container container;
-
+            
+            std::vector<CombinatorType> combinators;
         public:
             Powersetter(Container container)
                 : container(std::forward<Container>(container))
-            { }
+            {
+                for (std::size_t i = 0; i <= this->container.size(); ++i) {
+                    combinators.push_back(combinations(this->container, i));
+                }
+            }
 
             class Iterator {
                 private:
@@ -26,17 +33,16 @@ namespace iter {
                     std::size_t list_size = 0;
                     bool not_done = true;
 
-                    using CombinatorType =
-                        decltype(combinations(std::declval<Container&>(), 0));
-                    std::vector<CombinatorType> combinators;
+                    std::vector<CombinatorType>& combinators;
                     std::vector<iterator_type<CombinatorType>> inner_iters;
                 public:
-                    Iterator(Container& container)
-                        : container_size{container.size()}
+                    Iterator(Container& container,
+                            std::vector<CombinatorType>& combs)
+                        : container_size{container.size()},
+                        combinators(combs)
                     {
-                        for (std::size_t i = 0; i <= container_size; ++i) {
-                            combinators.push_back(combinations(container, i));
-                            inner_iters.push_back(std::begin(combinators.back()));
+                        for (auto& comb : combinators) {
+                            inner_iters.push_back(std::begin(comb));
                         }
                     }
 
@@ -62,11 +68,11 @@ namespace iter {
             }; 
 
             Iterator begin() {
-                return {this->container};
+                return {this->container, this->combinators};
             }
 
             Iterator end() {
-                return {this->container};
+                return {this->container, this->combinators};
             }
     };
 

From 7ca955897d09b2e318158ca437e3c1369f842e82 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 1 Aug 2014 15:10:54 -0700
Subject: [PATCH 0410/1866] Removes .size() requirement from powerset argument

By just counting the elements when building combinators, there is no
need to call .size() on an unknown type Container
---
 powerset.hpp | 22 ++++++++++++++--------
 1 file changed, 14 insertions(+), 8 deletions(-)

diff --git a/powerset.hpp b/powerset.hpp
index e0e7b566..815686b9 100644
--- a/powerset.hpp
+++ b/powerset.hpp
@@ -3,7 +3,9 @@
 
 #include "iterbase.hpp"
 #include "combinations.hpp"
+#include "enumerate.hpp"
 
+#include <cassert>
 #include <vector>
 #include <initializer_list>
 #include <utility>
@@ -19,12 +21,17 @@ namespace iter {
             
             std::vector<CombinatorType> combinators;
         public:
-            Powersetter(Container container)
-                : container(std::forward<Container>(container))
+            Powersetter(Container in_container)
+                : container(std::forward<Container>(in_container))
             {
-                for (std::size_t i = 0; i <= this->container.size(); ++i) {
+                std::size_t i = 0;
+                for (auto iter = std::begin(this->container),
+                            end = std::end(this->container);
+                        iter != end;
+                        ++iter, ++i) {
                     combinators.push_back(combinations(this->container, i));
                 }
+                combinators.push_back(combinations(this->container, i));
             }
 
             class Iterator {
@@ -36,9 +43,8 @@ namespace iter {
                     std::vector<CombinatorType>& combinators;
                     std::vector<iterator_type<CombinatorType>> inner_iters;
                 public:
-                    Iterator(Container& container,
-                            std::vector<CombinatorType>& combs)
-                        : container_size{container.size()},
+                    Iterator(std::vector<CombinatorType>& combs)
+                        : container_size{combs.size() - 1},
                         combinators(combs)
                     {
                         for (auto& comb : combinators) {
@@ -68,11 +74,11 @@ namespace iter {
             }; 
 
             Iterator begin() {
-                return {this->container, this->combinators};
+                return {this->combinators};
             }
 
             Iterator end() {
-                return {this->container, this->combinators};
+                return {this->combinators};
             }
     };
 

From 597825f2850d08446ffc707de003db762b10a064 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 1 Aug 2014 16:10:59 -0700
Subject: [PATCH 0411/1866] A slight (imo) readbility improvement

---
 powerset.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/powerset.hpp b/powerset.hpp
index 815686b9..ef532917 100644
--- a/powerset.hpp
+++ b/powerset.hpp
@@ -24,14 +24,14 @@ namespace iter {
             Powersetter(Container in_container)
                 : container(std::forward<Container>(in_container))
             {
-                std::size_t i = 0;
+                combinators.push_back(combinations(this->container, 0));
+                std::size_t i = 1;
                 for (auto iter = std::begin(this->container),
                             end = std::end(this->container);
                         iter != end;
                         ++iter, ++i) {
                     combinators.push_back(combinations(this->container, i));
                 }
-                combinators.push_back(combinations(this->container, i));
             }
 
             class Iterator {

From cf0ff5a4f836b08eb0a54f9022e0abd15b0c0585 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 1 Aug 2014 17:18:39 -0700
Subject: [PATCH 0412/1866] labels test cases

---
 tests/testpowerset.cpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/tests/testpowerset.cpp b/tests/testpowerset.cpp
index d4acbbd9..712cae14 100644
--- a/tests/testpowerset.cpp
+++ b/tests/testpowerset.cpp
@@ -10,11 +10,13 @@ int main() {
         for (auto i : v) std::cout << i << " ";
         std::cout << std::endl;
     }
-    for (auto v : powerset(std::vector<int>{1,2})) {
+    std::cout << "with temporary\n";
+    for (auto v : powerset(std::vector<int>{1,2,3})) {
         for (auto i : v) std::cout << i << " ";
         std::cout << std::endl;
     }
-    for (auto v : powerset({1,2,3,4})) {
+    std::cout << "with initializer_list\n";
+    for (auto v : powerset({1,2,3})) {
         for (auto i : v) std::cout << i << " ";
         std::cout << std::endl;
     }

From f5ad22a31f9809ec32c8c8958897f304aa7a2bbd Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 2 Aug 2014 10:50:07 -0700
Subject: [PATCH 0413/1866] breaks line

---
 combinations.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/combinations.hpp b/combinations.hpp
index 4853bd73..65e92425 100644
--- a/combinations.hpp
+++ b/combinations.hpp
@@ -43,8 +43,8 @@ namespace iter {
                 std::vector<iterator_type<Container>> indicies;
                 bool not_done = true;
 
-                using item_t = typename 
-                    std::remove_const<
+                using item_t =
+                    typename std::remove_const<
                         typename std::remove_reference<
                             iterator_deref<Container>>::type>::type;
 

From d6cd3e6b85865a6298894666620523b03344b65b Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 2 Aug 2014 14:54:01 -0700
Subject: [PATCH 0414/1866] adds test with temporary

---
 tests/testcombinations_with_replacement.cpp | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/tests/testcombinations_with_replacement.cpp b/tests/testcombinations_with_replacement.cpp
index 40fbad82..213cfd14 100644
--- a/tests/testcombinations_with_replacement.cpp
+++ b/tests/testcombinations_with_replacement.cpp
@@ -8,17 +8,18 @@
 using iter::combinations_with_replacement;
 
 int main() {
-    std::vector<int> v = {1,2,3,4,5};
-    for (auto i : combinations_with_replacement(v,40)) {
-        //std::cout << i << std::endl;
+    std::vector<int> v = {1,2,3,};
+    for (auto i : combinations_with_replacement(v,4)) {
         for (auto j : i ) std::cout << j << " ";
         std::cout<<std::endl;
     }
-    for (auto i : combinations_with_replacement(v,4)) {
-        //std::cout << i << std::endl;
+
+    for (auto i : combinations_with_replacement(std::vector<int>{1,2,3},4)) {
         for (auto j : i ) std::cout << j << " ";
         std::cout<<std::endl;
     }
+
+#if 0
     for (auto i : combinations_with_replacement(v,1)) {
         //std::cout << i << std::endl;
         for (auto j : i ) std::cout << j << " ";
@@ -29,5 +30,6 @@ int main() {
         for (auto j : i ) std::cout << j << " ";
         std::cout<<std::endl;
     }
+#endif
     return 0;
 }

From c2635caf6ae399e51ffe9b993d341c1aa8f51088 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 2 Aug 2014 14:54:42 -0700
Subject: [PATCH 0415/1866] restores test with init list

---
 tests/testcombinations_with_replacement.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/tests/testcombinations_with_replacement.cpp b/tests/testcombinations_with_replacement.cpp
index 213cfd14..df264335 100644
--- a/tests/testcombinations_with_replacement.cpp
+++ b/tests/testcombinations_with_replacement.cpp
@@ -19,13 +19,13 @@ int main() {
         std::cout<<std::endl;
     }
 
-#if 0
-    for (auto i : combinations_with_replacement(v,1)) {
-        //std::cout << i << std::endl;
+    for (auto i : combinations_with_replacement({1,2,3,4},4)) {
         for (auto j : i ) std::cout << j << " ";
         std::cout<<std::endl;
     }
-    for (auto i : combinations_with_replacement({1,2,3,4},4)) {
+
+#if 0
+    for (auto i : combinations_with_replacement(v,1)) {
         //std::cout << i << std::endl;
         for (auto j : i ) std::cout << j << " ";
         std::cout<<std::endl;

From f83d42846a84a9839e66ce5bb2cf97ac20e030db Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 2 Aug 2014 14:56:58 -0700
Subject: [PATCH 0416/1866] adds support for temporaries

---
 combinations_with_replacement.hpp | 160 +++++++++++++++++-------------
 1 file changed, 89 insertions(+), 71 deletions(-)

diff --git a/combinations_with_replacement.hpp b/combinations_with_replacement.hpp
index 07aacf85..fbd6302a 100644
--- a/combinations_with_replacement.hpp
+++ b/combinations_with_replacement.hpp
@@ -2,8 +2,8 @@
 #define COMBINATIONS_WITH_REPLACEMENT_HPP
 
 #include "iterator_range.hpp"
+#include "iterbase.hpp"
 
-#include <array>
 #include <vector>
 #include <type_traits>
 
@@ -13,12 +13,13 @@ namespace iter {
     //of items in your combination at runtime, but rather it is a way to view 
     //a list based on the problem your solving, that being said it would be easy
     //to make it decided at runtime
+#if 0
     template <typename Container>
         struct combinations_with_replacement_iter;
 
     template <typename Container>
         iterator_range<combinations_with_replacement_iter<Container>>
-        combinations_with_replacement(const Container & container, size_t N) {
+        combinations_with_replacement(Container & container, std::size_t N) {
             auto begin = combinations_with_replacement_iter<Container>(container, N);
             auto end = combinations_with_replacement_iter<Container>(container, N);
             return 
@@ -26,82 +27,99 @@ namespace iter {
         }
      template <typename T>
         iterator_range<combinations_with_replacement_iter<std::initializer_list<T>>>
-        combinations_with_replacement(std::initializer_list<T> && container, size_t N) {
+        combinations_with_replacement(std::initializer_list<T> && container, std::size_t N) {
             auto begin = combinations_with_replacement_iter<std::initializer_list<T>>(container, N);
             auto end = combinations_with_replacement_iter<std::initializer_list<T>>(container, N);
             return {begin,end};
         }
-   template <typename Container>
-        struct combinations_with_replacement_iter
-        {
+#endif
+    template <typename Container>
+    class CombinatorWithReplacement {
         private:
-            const Container & items;
-            std::vector<decltype(std::begin(items))> indicies;
-            bool not_done = true;
+            Container container;
+            std::size_t length;
 
         public:
-            //Holy shit look at this typedef
-            using item_t = typename 
-                std::remove_const<
-                typename std::remove_reference<decltype(*(std::begin(items)))>::type>::type;
-            combinations_with_replacement_iter(const Container & i, size_t N) : 
-                items(i), indicies(N)
-            {
-                if (N == 0) {
-                    not_done = false;
-                    return;
-                }
-                for (auto & iter : indicies) iter = std::begin(items);
-            }
-            //technically should be a dynarray
-            std::vector<item_t> operator*()const
-            {
-                std::vector<item_t> values;
-                for (auto i : indicies) {
-                    values.push_back(*i);
-                }
-                return values;
-            }
-
-
-            combinations_with_replacement_iter &
-            operator++() 
-            {
-                for (auto iter = indicies.rbegin(); iter != indicies.rend(); ++iter) {
-                    ++(*iter);
-                    if (*iter == std::end(items)) {
-                        if ( (iter + 1) != indicies.rend()) {
-                            for (auto down = iter; down != indicies.rbegin()-1;--down) {
-                                (*down) = (*(iter + 1)) + 1; 
-                            }
-                        }
-                        else {
-                            not_done = false;
-                            break;
-                        }
-                    }
-                    else break; 
-                    //we break because none of the rest of the items need to 
-                    //be incremented
-                }
-                return *this;
-            }
-
-            bool operator !=(const combinations_with_replacement_iter &)
-            {
-                //because of the way this is done you have to start from the 
-                //begining of the range and end at the end, you could break in 
-                //the middle of the loop though, it's not different from the way
-                //that python's works
-                return not_done;
-            }
-        };
-}
-namespace std {
+           CombinatorWithReplacement(Container container, std::size_t n)
+               : container(std::forward<Container>(container)),
+               length{n}
+           { }
+
+           class Iterator {
+               private:
+                   Container& items;
+                   std::vector<iterator_type<Container>> indicies;
+                   bool not_done;
+
+               public:
+                   using item_t =
+                       typename std::remove_const<
+                           typename std::remove_reference<
+                               iterator_deref<Container>>::type>::type;
+
+                   Iterator(
+                           Container& container, std::size_t n)
+                       : items(container),
+                       indicies(n, std::begin(items)),
+                       not_done{n != 0}
+                   { }
+
+                   std::vector<item_t> operator*()
+                   {
+                       std::vector<item_t> values;
+                       for (auto i : indicies) {
+                           values.push_back(*i);
+                       }
+                       return values;
+                   }
+
+
+                   Iterator& operator++() {
+                       for (auto iter = indicies.rbegin(); iter != indicies.rend(); ++iter) {
+                           ++(*iter);
+                           if (*iter == std::end(items)) {
+                               if ( (iter + 1) != indicies.rend()) {
+                                   for (auto down = iter; down != indicies.rbegin()-1;--down) {
+                                       (*down) = (*(iter + 1)) + 1; 
+                                   }
+                               }
+                               else {
+                                   not_done = false;
+                                   break;
+                               }
+                           }
+                           else break; 
+                           //we break because none of the rest of the items need to 
+                           //be incremented
+                       }
+                       return *this;
+                   }
+
+                   bool operator !=(const Iterator&) const
+                   {
+                       //because of the way this is done you have to start from the 
+                       //begining of the range and end at the end, you could break in 
+                       //the middle of the loop though, it's not different from the way
+                       //that python's works
+                       return not_done;
+                   }
+           };
+
+           Iterator begin() {
+               return {this->container, this->length};
+           }
+
+           Iterator end() {
+               return {this->container, 0};
+           }
+    };
+
     template <typename Container>
-        struct iterator_traits<iter::combinations_with_replacement_iter<Container>> {
-            using difference_type = ptrdiff_t;
-            using iterator_category = input_iterator_tag;
-        };
+    CombinatorWithReplacement<Container> combinations_with_replacement(
+            Container&& container, std::size_t length) {
+        return {std::forward<Container>(container), length};
+    }
+
 }
+
 #endif //COMBINATIONS_WITH_REPLACEMENT_HPP

From 59c2f69878688751d872c5e34bc8c80c2a608734 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 2 Aug 2014 14:57:20 -0700
Subject: [PATCH 0417/1866] adds support for init lists

---
 combinations_with_replacement.hpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/combinations_with_replacement.hpp b/combinations_with_replacement.hpp
index fbd6302a..f07846b8 100644
--- a/combinations_with_replacement.hpp
+++ b/combinations_with_replacement.hpp
@@ -120,6 +120,12 @@ namespace iter {
         return {std::forward<Container>(container), length};
     }
 
+    template <typename T>
+    CombinatorWithReplacement<std::initializer_list<T>> 
+    combinations_with_replacement(
+            std::initializer_list<T> il, std::size_t length) {
+        return {il, length};
+    }
 }
 
 #endif //COMBINATIONS_WITH_REPLACEMENT_HPP

From 74d72af4b24dd63f81b70defcc25674ae78b2a1f Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 2 Aug 2014 15:01:33 -0700
Subject: [PATCH 0418/1866] private value constructor

---
 combinations_with_replacement.hpp | 42 ++++++++++++++-----------------
 1 file changed, 19 insertions(+), 23 deletions(-)

diff --git a/combinations_with_replacement.hpp b/combinations_with_replacement.hpp
index f07846b8..5738feda 100644
--- a/combinations_with_replacement.hpp
+++ b/combinations_with_replacement.hpp
@@ -8,43 +8,39 @@
 #include <type_traits>
 
 namespace iter {
-    //if size isn't passed as template argument would have to switch to vectors
-    //for everything, generally I would say you don't need to decide the amount
-    //of items in your combination at runtime, but rather it is a way to view 
-    //a list based on the problem your solving, that being said it would be easy
-    //to make it decided at runtime
-#if 0
+
     template <typename Container>
-        struct combinations_with_replacement_iter;
+    class CombinatorWithReplacement;
 
     template <typename Container>
-        iterator_range<combinations_with_replacement_iter<Container>>
-        combinations_with_replacement(Container & container, std::size_t N) {
-            auto begin = combinations_with_replacement_iter<Container>(container, N);
-            auto end = combinations_with_replacement_iter<Container>(container, N);
-            return 
-                iterator_range<combinations_with_replacement_iter<Container>>(begin,end);
-        }
-     template <typename T>
-        iterator_range<combinations_with_replacement_iter<std::initializer_list<T>>>
-        combinations_with_replacement(std::initializer_list<T> && container, std::size_t N) {
-            auto begin = combinations_with_replacement_iter<std::initializer_list<T>>(container, N);
-            auto end = combinations_with_replacement_iter<std::initializer_list<T>>(container, N);
-            return {begin,end};
-        }
-#endif
+    CombinatorWithReplacement<Container> combinations_with_replacement(
+            Container&&, std::size_t);
+
+    template <typename T>
+    CombinatorWithReplacement<std::initializer_list<T>>
+    combinations_with_replacement(
+            std::initializer_list<T>, std::size_t);
+
     template <typename Container>
     class CombinatorWithReplacement {
         private:
             Container container;
             std::size_t length;
 
-        public:
+            friend CombinatorWithReplacement
+                combinations_with_replacement<Container>(
+                        Container&& ,std::size_t);
+            template <typename T>
+            friend CombinatorWithReplacement<std::initializer_list<T>>
+            combinations_with_replacement(
+                    std::initializer_list<T>, std::size_t);
+
            CombinatorWithReplacement(Container container, std::size_t n)
                : container(std::forward<Container>(container)),
                length{n}
            { }
 
+        public:
            class Iterator {
                private:
                    Container& items;

From 7d8ee6de5b41cda60aa1e4ecc8e89b3015fba612 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 2 Aug 2014 15:06:28 -0700
Subject: [PATCH 0419/1866] adds test with static array

---
 tests/testcombinations_with_replacement.cpp | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/tests/testcombinations_with_replacement.cpp b/tests/testcombinations_with_replacement.cpp
index df264335..0f0a194c 100644
--- a/tests/testcombinations_with_replacement.cpp
+++ b/tests/testcombinations_with_replacement.cpp
@@ -14,22 +14,24 @@ int main() {
         std::cout<<std::endl;
     }
 
+    std::cout << "with temporary\n";
     for (auto i : combinations_with_replacement(std::vector<int>{1,2,3},4)) {
         for (auto j : i ) std::cout << j << " ";
         std::cout<<std::endl;
     }
 
-    for (auto i : combinations_with_replacement({1,2,3,4},4)) {
+    std::cout << "with init list\n";
+    for (auto i : combinations_with_replacement({1,2,3},4)) {
         for (auto j : i ) std::cout << j << " ";
         std::cout<<std::endl;
     }
 
-#if 0
-    for (auto i : combinations_with_replacement(v,1)) {
-        //std::cout << i << std::endl;
+    std::cout << "with static array\n";
+    int arr[] = {1, 2, 3};
+    for (auto i : combinations_with_replacement(arr,4)) {
         for (auto j : i ) std::cout << j << " ";
         std::cout<<std::endl;
     }
-#endif
+
     return 0;
 }

From efc47698d473ddd28f6b16e3fec3e3597c8838f1 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 2 Aug 2014 15:09:44 -0700
Subject: [PATCH 0420/1866] adds some missing includes and formats the source

---
 combinations_with_replacement.hpp | 35 ++++++++++++++++++-------------
 1 file changed, 20 insertions(+), 15 deletions(-)

diff --git a/combinations_with_replacement.hpp b/combinations_with_replacement.hpp
index 5738feda..f56d7d2b 100644
--- a/combinations_with_replacement.hpp
+++ b/combinations_with_replacement.hpp
@@ -1,11 +1,12 @@
-#ifndef COMBINATIONS_WITH_REPLACEMENT_HPP
-#define COMBINATIONS_WITH_REPLACEMENT_HPP
+#ifndef COMBINATIONS_WITH_REPLACEMENT_HPP_
+#define COMBINATIONS_WITH_REPLACEMENT_HPP_
 
-#include "iterator_range.hpp"
 #include "iterbase.hpp"
 
+#include <iterator>
 #include <vector>
 #include <type_traits>
+#include <initializer_list>
 
 namespace iter {
 
@@ -71,32 +72,36 @@ namespace iter {
 
 
                    Iterator& operator++() {
-                       for (auto iter = indicies.rbegin(); iter != indicies.rend(); ++iter) {
+                       for (auto iter = indicies.rbegin();
+                               iter != indicies.rend();
+                               ++iter) {
                            ++(*iter);
                            if (*iter == std::end(items)) {
                                if ( (iter + 1) != indicies.rend()) {
-                                   for (auto down = iter; down != indicies.rbegin()-1;--down) {
+                                   for (auto down = iter;
+                                           down != indicies.rbegin()-1;
+                                           --down) {
                                        (*down) = (*(iter + 1)) + 1; 
                                    }
-                               }
-                               else {
+                               } else {
                                    not_done = false;
                                    break;
                                }
+                           } else {
+                               //we break because none of the rest of the items
+                               //need to be incremented
+                               break; 
                            }
-                           else break; 
-                           //we break because none of the rest of the items need to 
-                           //be incremented
                        }
                        return *this;
                    }
 
                    bool operator !=(const Iterator&) const
                    {
-                       //because of the way this is done you have to start from the 
-                       //begining of the range and end at the end, you could break in 
-                       //the middle of the loop though, it's not different from the way
-                       //that python's works
+                       //because of the way this is done you have to start from
+                       //the begining of the range and end at the end, you
+                       //could break in the middle of the loop though, it's not
+                       //different from the waythat python's works
                        return not_done;
                    }
            };
@@ -124,4 +129,4 @@ namespace iter {
     }
 }
 
-#endif //COMBINATIONS_WITH_REPLACEMENT_HPP
+#endif // #ifndef COMBINATIONS_WITH_REPLACEMENT_HPP_

From 203ce5d97626beef09e3b0b58cbfcf3ae262ad73 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 2 Aug 2014 22:00:20 -0700
Subject: [PATCH 0421/1866] adds test with temporary

---
 tests/testsliding_window.cpp | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/tests/testsliding_window.cpp b/tests/testsliding_window.cpp
index 33f0e88d..4b63a9d5 100644
--- a/tests/testsliding_window.cpp
+++ b/tests/testsliding_window.cpp
@@ -11,5 +11,14 @@ int main() {
         }
         std::cout << std::endl;
     }
+
+    for (auto sec : sliding_window(std::vector<int>{1,2,3,4,5,6,7,8,9} ,4)) {
+        for (auto i : sec) {
+            std::cout << i << " ";
+            i.get() = 90;
+        }
+        std::cout << std::endl;
+    }
+
     return 0;
 }

From 8d8bdb438bb20102addeb4a0b9e1f93e2a4a050d Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 2 Aug 2014 22:00:48 -0700
Subject: [PATCH 0422/1866] fixes temporary support

---
 sliding_window.hpp | 143 +++++++++++++++++++++++++++------------------
 1 file changed, 86 insertions(+), 57 deletions(-)

diff --git a/sliding_window.hpp b/sliding_window.hpp
index a7bea87e..8e81b639 100644
--- a/sliding_window.hpp
+++ b/sliding_window.hpp
@@ -1,7 +1,8 @@
-#ifndef SLIDING_WINDOW_HPP
-#define SLIDING_WINDOW_HPP
+#ifndef SLIDING_WINDOW_HPP_
+#define SLIDING_WINDOW_HPP_
 
 #include "iterator_range.hpp"
+#include "iterbase.hpp"
 
 #include <vector>
 #include <algorithm>
@@ -11,68 +12,96 @@
 #include <iterator>
 
 namespace iter {
+#if 0
     template <typename Container>
-        struct sliding_window_iter;
+    struct sliding_window_iter;
+
     template <typename Container>
-        iterator_range<sliding_window_iter<Container>>
-        sliding_window(Container && container, size_t s) {
-            auto begin = sliding_window_iter<Container>(std::forward<Container>(container),s);
-            auto end = sliding_window_iter<Container>(std::forward<Container>(container));
-            return iterator_range<sliding_window_iter<Container>>(begin,end);
-        }
+    iterator_range<sliding_window_iter<Container>>
+    sliding_window(Container&& container, std::size_t s) {
+        auto begin = sliding_window_iter<Container>(std::forward<Container>(container),s);
+        auto end = sliding_window_iter<Container>(std::forward<Container>(container));
+        return iterator_range<sliding_window_iter<Container>>(begin,end);
+    }
+#endif
 
     template <typename Container>
-        struct sliding_window_iter {
-            typename 
-                std::conditional<std::is_lvalue_reference<Container>::value,
-                Container&,
-                const Container &>::type container;
-            //Container && container;
-            //using Iterator = decltype(container.begin());
-            using Iterator = decltype(std::begin(container));
-            std::vector<Iterator> section;
-            size_t section_size = 0;
-            sliding_window_iter(Container && c, size_t s) :
-                container(std::forward<Container>(c)),section_size(s) {
-                    size_t i = 0;
-                    for (auto iter = std::begin(container); i < section_size;++iter,++i) {
-                        section.push_back(iter);
+    class SlidingWindow {
+        private:
+            Container container;
+            std::size_t window_size;
+
+        public:
+            SlidingWindow(Container container, std::size_t win_sz)
+                : container(std::forward<Container>(container)),
+                window_size{win_sz}
+            { }
+
+            class Iterator {
+                private:
+                    // confusing, but, just makes the type of the vector returned by
+                    // operator*()
+                    using OpDerefElemType =
+                        std::reference_wrapper<
+                            typename std::remove_reference<
+                                iterator_deref<Container>>::type>;
+                    using DerefVec = std::vector<OpDerefElemType>;
+
+                    std::vector<iterator_type<Container>> section;
+                    std::size_t section_size = 0;
+
+                public:
+                    Iterator(Container& container, std::size_t s)
+                        : section_size{s}
+                    {
+                        auto iter = std::begin(container);
+                        for (std::size_t i = 0;
+                                i < section_size;
+                                ++iter, ++i) {
+                            section.push_back(iter);
+                        }
                     }
-                    //for (size_t i = 0; i < section_size; ++i) 
-                      //  section.push_back(container.begin()+i);
-                }
-            sliding_window_iter(Container && c) : container(std::forward<Container>(c))
-            //creates the end iterator
-            {
-                section.push_back(std::end(container));
-            }
 
-            sliding_window_iter & operator++() {
-                for (auto & iter : section) {
-                    ++iter;
-                }
-                return *this;
-                //std::for_each(section.begin(),section.end(),[](Iterator & i){++i;});
-            }
-            bool operator!=(const sliding_window_iter & rhs) {
-               return this->section.back() != rhs.section.back();
+                    // for the end iter
+                    Iterator(Container& container)
+                        : section{std::end(container)},
+                        section_size{0}
+                    { }
+
+                    Iterator& operator++() {
+                        for (auto&& iter : section) {
+                            ++iter;
+                        }
+                        return *this;
+                    }
+
+                    bool operator!=(const Iterator& rhs) const {
+                       return this->section.back() != rhs.section.back();
+                    }
+
+                    DerefVec operator*() {
+                        DerefVec vec;
+                        for (auto&& iter : section) {
+                            vec.push_back(*iter);
+                        }
+                        return vec;
+                    }
+            };
+
+            Iterator begin() {
+                return {container, window_size};
             }
-            using Deref_type = std::vector<std::reference_wrapper<typename std::remove_reference<decltype(*std::declval<Iterator>())>::type>>;
-            Deref_type operator*()
-            {
-                Deref_type vec;
-                for (auto i : section) {
-                    vec.push_back(*i);
-                }
-                return vec;
+
+            Iterator end() {
+                return {container};
             }
-        };
-}
-namespace std {
+    };
+
     template <typename Container>
-        struct iterator_traits<iter::sliding_window_iter<Container>> {
-            using difference_type = ptrdiff_t;
-            using iterator_category = input_iterator_tag;
-        };
+    SlidingWindow<Container> sliding_window(
+            Container&& container, std::size_t window_size) {
+        return {std::forward<Container>(container), window_size};
+    }
 }
-#endif //SLIDING_WINDOW_HPP
+
+#endif //SLIDING_WINDOW_HPP_

From 97c27ecb99245145a87f4fd8eae7252ec4a72953 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 2 Aug 2014 22:04:35 -0700
Subject: [PATCH 0423/1866] adds test with init list

---
 tests/testsliding_window.cpp | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/tests/testsliding_window.cpp b/tests/testsliding_window.cpp
index 4b63a9d5..94b37dab 100644
--- a/tests/testsliding_window.cpp
+++ b/tests/testsliding_window.cpp
@@ -12,7 +12,7 @@ int main() {
         std::cout << std::endl;
     }
 
-    for (auto sec : sliding_window(std::vector<int>{1,2,3,4,5,6,7,8,9} ,4)) {
+    for (auto sec : sliding_window(std::vector<int>{1,2,3,4,5,6,7,8,9}, 4)) {
         for (auto i : sec) {
             std::cout << i << " ";
             i.get() = 90;
@@ -20,5 +20,12 @@ int main() {
         std::cout << std::endl;
     }
 
+    for (auto sec : sliding_window({1,2,3,4,5,6,7,8,9}, 4)) {
+        for (auto i : sec) {
+            std::cout << i << " ";
+        }
+        std::cout << std::endl;
+    }
+
     return 0;
 }

From 6725ab526809e39cb7316d21420502b88aa1bf62 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 2 Aug 2014 22:05:17 -0700
Subject: [PATCH 0424/1866] adds support for init lists

---
 sliding_window.hpp | 19 ++++++-------------
 1 file changed, 6 insertions(+), 13 deletions(-)

diff --git a/sliding_window.hpp b/sliding_window.hpp
index 8e81b639..869c4f90 100644
--- a/sliding_window.hpp
+++ b/sliding_window.hpp
@@ -12,19 +12,6 @@
 #include <iterator>
 
 namespace iter {
-#if 0
-    template <typename Container>
-    struct sliding_window_iter;
-
-    template <typename Container>
-    iterator_range<sliding_window_iter<Container>>
-    sliding_window(Container&& container, std::size_t s) {
-        auto begin = sliding_window_iter<Container>(std::forward<Container>(container),s);
-        auto end = sliding_window_iter<Container>(std::forward<Container>(container));
-        return iterator_range<sliding_window_iter<Container>>(begin,end);
-    }
-#endif
-
     template <typename Container>
     class SlidingWindow {
         private:
@@ -102,6 +89,12 @@ namespace iter {
             Container&& container, std::size_t window_size) {
         return {std::forward<Container>(container), window_size};
     }
+
+    template <typename T>
+    SlidingWindow<std::initializer_list<T>> sliding_window(
+            std::initializer_list<T> il, std::size_t window_size) {
+        return {il, window_size};
+    }
 }
 
 #endif //SLIDING_WINDOW_HPP_

From 84a4ddc0b785482929ba42d73b0d9f57645c5588 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 2 Aug 2014 22:09:20 -0700
Subject: [PATCH 0425/1866] adds test with window size > iterable size

---
 tests/testsliding_window.cpp | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/tests/testsliding_window.cpp b/tests/testsliding_window.cpp
index 94b37dab..98ff33f1 100644
--- a/tests/testsliding_window.cpp
+++ b/tests/testsliding_window.cpp
@@ -1,7 +1,10 @@
 #include "sliding_window.hpp"
+
 #include <iostream>
 #include <vector>
+
 using iter::sliding_window;
+
 int main() {
     std::vector<int> v = {1,2,3,4,5,6,7,8,9}; 
     for (auto sec : sliding_window(v,4)) {
@@ -27,5 +30,12 @@ int main() {
         std::cout << std::endl;
     }
 
+    for (auto sec : sliding_window({1,2,3}, 10)) {
+        for (auto i : sec) {
+            std::cout << i << " ";
+        }
+        std::cout << std::endl;
+    }
+
     return 0;
 }

From 048db19c27de16ac3bafd0aaa66318742a7f600c Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 2 Aug 2014 22:10:48 -0700
Subject: [PATCH 0426/1866] Covers case where window size > iterable size

---
 sliding_window.hpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/sliding_window.hpp b/sliding_window.hpp
index 869c4f90..4c8b19f3 100644
--- a/sliding_window.hpp
+++ b/sliding_window.hpp
@@ -42,8 +42,9 @@ namespace iter {
                         : section_size{s}
                     {
                         auto iter = std::begin(container);
+                        auto end = std::end(container);
                         for (std::size_t i = 0;
-                                i < section_size;
+                                i < section_size && iter != end;
                                 ++iter, ++i) {
                             section.push_back(iter);
                         }

From 2ef2c8a4755bc4b4d0330e93bf93a22fb88c09df Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 2 Aug 2014 22:20:39 -0700
Subject: [PATCH 0427/1866] private value ctor

---
 sliding_window.hpp | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/sliding_window.hpp b/sliding_window.hpp
index 4c8b19f3..cc6f640d 100644
--- a/sliding_window.hpp
+++ b/sliding_window.hpp
@@ -12,22 +12,40 @@
 #include <iterator>
 
 namespace iter {
+    template <typename Container>
+    class SlidingWindow;
+
+    template <typename Container>
+    SlidingWindow<Container> sliding_window(Container&&, std::size_t);
+
+    template <typename T>
+    SlidingWindow<std::initializer_list<T>> sliding_window(
+            std::initializer_list<T>, std::size_t);
+
     template <typename Container>
     class SlidingWindow {
         private:
             Container container;
             std::size_t window_size;
 
-        public:
+            friend SlidingWindow sliding_window<Container>(
+                    Container&&, std::size_t);
+            
+            template <typename T>
+            friend SlidingWindow<std::initializer_list<T>> sliding_window(
+                    std::initializer_list<T>, std::size_t);
+
             SlidingWindow(Container container, std::size_t win_sz)
                 : container(std::forward<Container>(container)),
                 window_size{win_sz}
             { }
 
+        public:
+
             class Iterator {
                 private:
-                    // confusing, but, just makes the type of the vector returned by
-                    // operator*()
+                    // confusing, but, just makes the type of the vector
+                    // returned by operator*()
                     using OpDerefElemType =
                         std::reference_wrapper<
                             typename std::remove_reference<

From 37b502b2ac2e1bd9fbd74d241988fb85967059b6 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 2 Aug 2014 22:24:42 -0700
Subject: [PATCH 0428/1866] adds test with static array

---
 tests/testsliding_window.cpp | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/tests/testsliding_window.cpp b/tests/testsliding_window.cpp
index 98ff33f1..16708db7 100644
--- a/tests/testsliding_window.cpp
+++ b/tests/testsliding_window.cpp
@@ -15,6 +15,7 @@ int main() {
         std::cout << std::endl;
     }
 
+    std::cout << "with temporary\n";
     for (auto sec : sliding_window(std::vector<int>{1,2,3,4,5,6,7,8,9}, 4)) {
         for (auto i : sec) {
             std::cout << i << " ";
@@ -23,6 +24,7 @@ int main() {
         std::cout << std::endl;
     }
 
+    std::cout << "with init list\n";
     for (auto sec : sliding_window({1,2,3,4,5,6,7,8,9}, 4)) {
         for (auto i : sec) {
             std::cout << i << " ";
@@ -30,6 +32,7 @@ int main() {
         std::cout << std::endl;
     }
 
+    std::cout << "with window_size > length\n";
     for (auto sec : sliding_window({1,2,3}, 10)) {
         for (auto i : sec) {
             std::cout << i << " ";
@@ -37,5 +40,14 @@ int main() {
         std::cout << std::endl;
     }
 
+    std::cout << "with static array\n";
+    int arr[] = {1,2,3,4,5,6,7,8,9};
+    for (auto sec : sliding_window(arr, 4)) {
+        for (auto i : sec) {
+            std::cout << i << " ";
+        }
+        std::cout << std::endl;
+    }
+
     return 0;
 }

From 8094f723b245c17e27ed6521c1a2157da5402a1e Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 3 Aug 2014 12:48:08 -0700
Subject: [PATCH 0429/1866] shortens permutations tests for readability

---
 tests/testpermutations.cpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/tests/testpermutations.cpp b/tests/testpermutations.cpp
index adeeca06..6ebc03b4 100644
--- a/tests/testpermutations.cpp
+++ b/tests/testpermutations.cpp
@@ -5,7 +5,7 @@
 
 int main() {
     using iter::permutations;
-    std::vector<int> v = {1,2,3,4,5};
+    std::vector<int> v = {1,2,3};
     for (auto vec : permutations(v)) {
         for (auto i : vec) {
             std::cout << i << " ";
@@ -27,6 +27,8 @@ int main() {
         }
         std::cout << std::endl;
     }
+
+    std::cout << "init list\n";
     //std::next_permutation doesn't work on initializer_lists
     for (auto vec : permutations({1,2,3,4})) {
         for (auto c : vec) {

From b84a623bbb0d05bfdbe91ff10b948dea9f675434 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 3 Aug 2014 12:48:37 -0700
Subject: [PATCH 0430/1866] reworks permutations overall style

---
 permutations.hpp | 107 +++++++++++++++++++++++++++--------------------
 1 file changed, 62 insertions(+), 45 deletions(-)

diff --git a/permutations.hpp b/permutations.hpp
index 1d0e4442..ef6a3dff 100644
--- a/permutations.hpp
+++ b/permutations.hpp
@@ -1,64 +1,81 @@
 #ifndef PERMUTATIONS_HPP
 #define PERMUTATIONS_HPP
 
-#include "iterator_range.hpp"
-
 #include <algorithm>
 #include <initializer_list>
 #include <vector>
 
-namespace iter {
-    template <typename Container>
-        struct permutation_iter;
 
-    template <typename Container>
-        iterator_range<permutation_iter<Container>>
-        permutations (const Container & container) {
-            return iterator_range<permutation_iter<Container>>(
-                    permutation_iter<Container>(container),
-                    permutation_iter<Container>());
-        }
-    //since initializer_list doesn't have bidir iters this is a hack
-    //to get it to work by using a vector in its place
-    template <typename T>
-        iterator_range<permutation_iter<std::vector<T>>>
-        permutations (std::initializer_list<T> && container) {
-            std::vector<T> begin(std::begin(container),std::end(container));
-            return  {permutation_iter<std::vector<T>>(container),
-                    permutation_iter<std::vector<T>>()};
-        }
+namespace iter {
 
     template <typename Container>
-        struct permutation_iter
-        {
+    class Permuter {
+        private:
             Container container;
-            using Iterator = decltype(std::begin(container));
-            bool is_not_last = true;
-            permutation_iter(){}
-            permutation_iter(const Container & c) : container(c) 
-            {
-                //sort first so you can get every permutation
-                std::sort(std::begin(container),std::end(container));
-            }
-            const Container & operator*()
+
+        public:
+            // always copy, never move
+            Permuter(Container in_container)
+                : container(in_container)
             {
-                return container;
+                    std::sort(std::begin(this->container),
+                        std::end(this->container));
             }
-            permutation_iter & operator++() {
-                is_not_last = std::next_permutation(std::begin(container),std::end(container));
-                return *this;
+
+            class Iterator {
+                private:
+                    Container& container;
+                    bool is_not_last = true;
+
+                public:
+                    Iterator(Container& c)
+                        : container(c) 
+                    { }
+
+                    Container& operator*() {
+                        return container;
+                    }
+
+                    Iterator& operator++() {
+                        is_not_last =
+                            std::next_permutation(std::begin(container),
+                                    std::end(container));
+                        return *this;
+                    }
+
+                    bool operator!=(const Iterator&) const {
+                        return is_not_last;
+                    }
+
+            };
+
+            Iterator begin() {
+                return {this->container};
             }
-            bool operator!=(const permutation_iter &) {
-                return is_not_last;
+
+            Iterator end() {
+                return {this->container};
             }
-        };
-}
-namespace std {
+
+
+    };
+
+    // NOTE unlike other itertools, this one copies the input container
+    // rather than taking a universal ref
     template <typename Container>
-        struct iterator_traits<iter::permutation_iter<Container>> {
-            using difference_type = ptrdiff_t;
-            using iterator_category = input_iterator_tag;
-        };
+    Permuter<Container> permutations(const Container& container) {
+        return {container};
+    }
+
+    //since initializer_list doesn't have bidir iters this is a hack
+    //to get it to work by using a vector in its place
+    template <typename T>
+    Permuter<std::vector<T>> permutations(std::initializer_list<T> il) {
+        std::vector<T> vec = il;
+        return {std::move(vec)};
+    }
+
 }
+
 #endif //PERMUTATIONS_HPP
 

From 2d6334050a1aaf0cfa083e2f77723145f63fa29f Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 3 Aug 2014 15:36:13 -0700
Subject: [PATCH 0431/1866] removes const that was causing me problems

---
 enumerate.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index f2e63ff2..0bee1f4a 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -85,7 +85,7 @@ namespace iter {
                         index{0}
                     { } 
 
-                    IterYield operator*() const {
+                    IterYield operator*() {
                         return IterYield(this->index, *this->sub_iter);
                     }
 

From eb0a7ad1c17135ac0ada6b56a5e60bd27a9cadf4 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 3 Aug 2014 15:39:02 -0700
Subject: [PATCH 0432/1866] removes couts that were still hanging around

---
 slice.hpp | 2 --
 1 file changed, 2 deletions(-)

diff --git a/slice.hpp b/slice.hpp
index 7e1e0d26..fa5f8e2a 100644
--- a/slice.hpp
+++ b/slice.hpp
@@ -81,8 +81,6 @@ namespace iter {
                             size(this->container))) {
                     this->stop = static_cast<DifferenceType>(size(
                                 this->container));
-                    std::cout << "stop is too large\n";
-                    std::cout << "stop is now: " << this->stop << '\n';
                 }
                 if (this->start < 0) {
                     this->start = 0; 

From fba04b2b7497b1f7eef7dbe753d008fceddbd2e7 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 3 Aug 2014 16:40:57 -0700
Subject: [PATCH 0433/1866] shortens and supports temporaries

---
 unique_justseen.hpp | 30 ++++++++++++------------------
 1 file changed, 12 insertions(+), 18 deletions(-)

diff --git a/unique_justseen.hpp b/unique_justseen.hpp
index 5729ae23..da759fe9 100644
--- a/unique_justseen.hpp
+++ b/unique_justseen.hpp
@@ -1,7 +1,8 @@
 #ifndef UNIQUE_JUSTSEEN_HPP
 #define UNIQUE_JUSTSEEN_HPP
 
-#include "filter.hpp"
+#include "groupby.hpp"
+#include "imap.hpp"
 
 #include <type_traits>
 #include <functional>
@@ -9,24 +10,17 @@
 
 namespace iter 
 {
-    //this should be self evident but unique_justseen places the requirement 
-    //on the elements in the container have the != operator overloaded
+    // gets first of each group.  since each group is decided based on equality
+    // with the previous item, this results in each item only appearing once
     template <typename Container>
-    auto unique_justseen(Container && container) 
-    -> Filter<std::function<bool(decltype(container.front()))>,Container>
-    {
-        using elem_t = decltype(container.front());
-        auto last = container.begin();
-        std::function<bool(elem_t)> func = [last,container] (elem_t e) mutable 
-                {
-                    if (last == container.begin()) {
-                        return true;
-                    }
-                    else { 
-                        return *(++last) != e;
-                    }
-                };
-        return filter(func,std::forward<Container>(container));
+    auto unique_justseen(Container&& container) {
+        return imap(
+                [] (iterator_deref<
+                        decltype(
+                            groupby(
+                                std::forward<Container>(container)))>&& gb)
+                    {return *std::begin(gb.second);},
+                groupby(std::forward<Container>(container)));
     }
 }
 

From fadb026defc24dcfebece8895c2ab350c0609fa3 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 3 Aug 2014 16:42:50 -0700
Subject: [PATCH 0434/1866] adds test with init list

---
 tests/testunique_justseen.cpp | 16 +++++++++++++++-
 1 file changed, 15 insertions(+), 1 deletion(-)

diff --git a/tests/testunique_justseen.cpp b/tests/testunique_justseen.cpp
index 7c1dc44e..035b8e67 100644
--- a/tests/testunique_justseen.cpp
+++ b/tests/testunique_justseen.cpp
@@ -9,6 +9,20 @@ int main() {
     std::vector<int> v {1,1,1,2,2,4,4,5,6,7,8,8,8,8,9,9};
     for (auto i : unique_justseen(v)) {
         std::cout << i << " ";
-    }std::cout << std::endl;
+    }
+    std::cout << '\n';
+
+    std::cout << "with temporary\n";
+    for (auto i : unique_justseen({1,1,1,2,3,3})) {
+        std::cout << i << " ";
+    }
+    std::cout << '\n';
+
+    std::cout << "with init list\n";
+    for (auto i : unique_justseen({1,1,1,2,3,3})) {
+        std::cout << i << " ";
+    }
+    std::cout << '\n';
+
     return 0;
 }

From f1bd2dc529ff98d337b65a370c646e31e7122a63 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 3 Aug 2014 17:24:09 -0700
Subject: [PATCH 0435/1866] uses custom function object instead of lambda

so I can work with c++11.  otherwise I'd need a lambda inside the
decltype for the trailing return and that's not allowed.  I was testing
with -std=c++1y at first.
---
 unique_justseen.hpp | 27 ++++++++++++++++++---------
 1 file changed, 18 insertions(+), 9 deletions(-)

diff --git a/unique_justseen.hpp b/unique_justseen.hpp
index da759fe9..3a4ad470 100644
--- a/unique_justseen.hpp
+++ b/unique_justseen.hpp
@@ -1,25 +1,34 @@
 #ifndef UNIQUE_JUSTSEEN_HPP
 #define UNIQUE_JUSTSEEN_HPP
 
+#include "iterbase.hpp"
 #include "groupby.hpp"
 #include "imap.hpp"
 
-#include <type_traits>
-#include <functional>
 #include <utility>
+#include <iterator>
+#include <initializer_list>
 
 namespace iter 
 {
+    template <typename GroupByType>
+    struct GroupFrontGetter{
+        auto operator()(iterator_deref<GroupByType>&& gb) ->
+                decltype(*std::begin(gb.second)) {
+            return *std::begin(gb.second);
+        }
+    };
+
+
     // gets first of each group.  since each group is decided based on equality
     // with the previous item, this results in each item only appearing once
     template <typename Container>
-    auto unique_justseen(Container&& container) {
-        return imap(
-                [] (iterator_deref<
-                        decltype(
-                            groupby(
-                                std::forward<Container>(container)))>&& gb)
-                    {return *std::begin(gb.second);},
+    auto unique_justseen(Container&& container) ->
+        decltype(imap(GroupFrontGetter<decltype(
+                        groupby(std::forward<Container>(container)))>{},
+                groupby(std::forward<Container>(container)))) {
+        return imap(GroupFrontGetter<decltype(
+                    groupby(std::forward<Container>(container)))>{},
                 groupby(std::forward<Container>(container)));
     }
 }

From d4819386a819d22bc2e221de25dbb0fb2923e050 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 3 Aug 2014 17:29:23 -0700
Subject: [PATCH 0436/1866] adds support for init lists

---
 unique_justseen.hpp | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/unique_justseen.hpp b/unique_justseen.hpp
index 3a4ad470..878e2e33 100644
--- a/unique_justseen.hpp
+++ b/unique_justseen.hpp
@@ -31,6 +31,16 @@ namespace iter
                     groupby(std::forward<Container>(container)))>{},
                 groupby(std::forward<Container>(container)));
     }
+
+    template <typename T>
+    auto unique_justseen(std::initializer_list<T> il) ->
+        decltype(imap(GroupFrontGetter<decltype(
+                        groupby(std::forward<std::initializer_list<T>>(il)))>{},
+                groupby(std::forward<std::initializer_list<T>>(il)))) {
+        return imap(GroupFrontGetter<decltype(
+                    groupby(std::forward<std::initializer_list<T>>(il)))>{},
+                groupby(std::forward<std::initializer_list<T>>(il)));
+    }
 }
 
 #endif //UNIQUE_JUSTSEEN_HPP

From ce54ef0f6774f16c3ef0231dbf6e67ef9e0b45e4 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 3 Aug 2014 17:32:45 -0700
Subject: [PATCH 0437/1866] fixes temp test

---
 tests/testunique_justseen.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/testunique_justseen.cpp b/tests/testunique_justseen.cpp
index 035b8e67..a128fd76 100644
--- a/tests/testunique_justseen.cpp
+++ b/tests/testunique_justseen.cpp
@@ -13,7 +13,7 @@ int main() {
     std::cout << '\n';
 
     std::cout << "with temporary\n";
-    for (auto i : unique_justseen({1,1,1,2,3,3})) {
+    for (auto i : unique_justseen(std::vector<int>{1,1,1,2,3,3})) {
         std::cout << i << " ";
     }
     std::cout << '\n';

From d4a310baa039d0d2b969e132c50628de71288eb2 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 3 Aug 2014 17:33:27 -0700
Subject: [PATCH 0438/1866] const fix in imap

---
 imap.hpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/imap.hpp b/imap.hpp
index 3cc01371..31225899 100644
--- a/imap.hpp
+++ b/imap.hpp
@@ -89,6 +89,7 @@ namespace iter {
 
         public:
             IMap(const IMap&) = default;
+            IMap(IMap&&) = default;
 
             class Iterator {
                 private:
@@ -101,7 +102,7 @@ namespace iter {
                         zipiter(zipiter)
                     { } 
 
-                    auto operator*() const -> 
+                    auto operator*() -> 
                         decltype(detail::call(this->map_func, *(this->zipiter)))
                     {
                         return detail::call(this->map_func, *(this->zipiter));

From ca7c029641e39b7f4c27739d9383c7e525dc9045 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 3 Aug 2014 17:42:11 -0700
Subject: [PATCH 0439/1866] adds test with static array

---
 tests/testunique_justseen.cpp | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/tests/testunique_justseen.cpp b/tests/testunique_justseen.cpp
index a128fd76..8f454b6d 100644
--- a/tests/testunique_justseen.cpp
+++ b/tests/testunique_justseen.cpp
@@ -24,5 +24,12 @@ int main() {
     }
     std::cout << '\n';
 
+    std::cout << "with static array\n";
+    int arr[] = {1, 1, 2, 3, 3, 3, 4};
+    for (auto i : unique_justseen(arr)) {
+        std::cout << i << " ";
+    }
+    std::cout << '\n';
+
     return 0;
 }

From a50172d61f14ac633828bdfe7ded9354939234e6 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 6 Aug 2014 22:01:26 -0700
Subject: [PATCH 0440/1866] replaces unordered_map with unordered_set

---
 unique_everseen.hpp | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/unique_everseen.hpp b/unique_everseen.hpp
index 1a67f7e8..96c5a2f6 100644
--- a/unique_everseen.hpp
+++ b/unique_everseen.hpp
@@ -6,27 +6,29 @@
 #include <type_traits>
 #include <functional>
 #include <utility>
-#include <unordered_map>
+#include <unordered_set>
+#include <iterator>
 
 namespace iter 
 {
     //the container type must be usable in an unordered_map to achieve constant
     //performance checking if it has ever been seen
     template <typename Container>
-    auto unique_everseen(Container && container) 
-    -> Filter<std::function<bool(decltype(container.front()))>,Container>
+    auto unique_everseen(Container&& container) 
+        -> Filter<std::function<bool(decltype(container.front()))>,Container>
     {
         using elem_t = decltype(container.front());
-        std::unordered_map<typename std::remove_reference<elem_t>::type,bool> elem_seen;
+        std::unordered_set<typename std::remove_reference<elem_t>::type> elem_seen;
         std::function<bool(elem_t)> func = [elem_seen](elem_t e) mutable
         //has to be captured by value because it goes out of scope when the 
         //function returns
                 {
-                    if(!elem_seen[e]) {
-                        elem_seen[e] = true;
+                    if (elem_seen.find(e) == std::end(elem_seen)){
+                        elem_seen.insert(e);
                         return true;
+                    } else {
+                        return false;
                     }
-                    else return false;
                 };
         return filter(func,std::forward<Container>(container));
     }

From e0ef7527ed844853ea7c96ffbf059da75705c724 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 6 Aug 2014 22:01:50 -0700
Subject: [PATCH 0441/1866] adds test with temporary

---
 tests/testunique_everseen.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/tests/testunique_everseen.cpp b/tests/testunique_everseen.cpp
index d57674e7..f6565ae2 100644
--- a/tests/testunique_everseen.cpp
+++ b/tests/testunique_everseen.cpp
@@ -19,5 +19,11 @@ int main() {
             std::cout << i << " ";
         }std::cout << std::endl;
     }
+
+    for (auto i : unique_everseen(
+                std::vector<int>{1,2,1,3,4,3,2,1,5,6,7,7,8,9,8,9,6})) {
+        std::cout << i << " ";
+    }
+    std::cout << std::endl;
     return 0;
 }

From 4277392ad6fa1a1aa5c81702192c6c763e304cba Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 6 Aug 2014 22:08:27 -0700
Subject: [PATCH 0442/1866] adds test with static array

---
 tests/testunique_everseen.cpp | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/tests/testunique_everseen.cpp b/tests/testunique_everseen.cpp
index f6565ae2..78aa41ac 100644
--- a/tests/testunique_everseen.cpp
+++ b/tests/testunique_everseen.cpp
@@ -25,5 +25,12 @@ int main() {
         std::cout << i << " ";
     }
     std::cout << std::endl;
+
+    int arr[] = {1,2,1,3,4,3,2,1,5,6,7,7,8,9,8,9,6};
+    for (auto i : unique_everseen(arr)) {
+        std::cout << i << ' ';
+    }
+    std::cout << '\n';
+
     return 0;
 }

From a7a188dfb5ed938f9903f139c502b738d79b2a12 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 6 Aug 2014 22:10:45 -0700
Subject: [PATCH 0443/1866] removes .front() requirement on Container

---
 unique_everseen.hpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/unique_everseen.hpp b/unique_everseen.hpp
index 96c5a2f6..a281b90c 100644
--- a/unique_everseen.hpp
+++ b/unique_everseen.hpp
@@ -1,6 +1,7 @@
 #ifndef UNIQUE_EVERSEEN_HPP
 #define UNIQUE_EVERSEEN_HPP
 
+#include "iterbase.hpp"
 #include "filter.hpp"
 
 #include <type_traits>
@@ -15,9 +16,9 @@ namespace iter
     //performance checking if it has ever been seen
     template <typename Container>
     auto unique_everseen(Container&& container) 
-        -> Filter<std::function<bool(decltype(container.front()))>,Container>
+        -> Filter<std::function<bool(iterator_deref<Container>)>,Container>
     {
-        using elem_t = decltype(container.front());
+        using elem_t = iterator_deref<Container>;
         std::unordered_set<typename std::remove_reference<elem_t>::type> elem_seen;
         std::function<bool(elem_t)> func = [elem_seen](elem_t e) mutable
         //has to be captured by value because it goes out of scope when the 

From a9f7861ca6a71213dfc19d04c20a1dbcc8c1191f Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 6 Aug 2014 22:21:34 -0700
Subject: [PATCH 0444/1866] adds test with init list

---
 tests/testunique_everseen.cpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/tests/testunique_everseen.cpp b/tests/testunique_everseen.cpp
index 78aa41ac..015adb7d 100644
--- a/tests/testunique_everseen.cpp
+++ b/tests/testunique_everseen.cpp
@@ -32,5 +32,10 @@ int main() {
     }
     std::cout << '\n';
 
+    for (auto i : unique_everseen({1,2,1,3,4,3,2,1,5,6,7,7,8,9,8,9,6})) {
+        std::cout << i << ' ';
+    }
+    std::cout << '\n';
+
     return 0;
 }

From fc556e349930ba0057a318bc552647b3652d452c Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 6 Aug 2014 22:21:44 -0700
Subject: [PATCH 0445/1866] adds support for init lists

---
 unique_everseen.hpp | 39 +++++++++++++++++++++++++++++----------
 1 file changed, 29 insertions(+), 10 deletions(-)

diff --git a/unique_everseen.hpp b/unique_everseen.hpp
index a281b90c..77124c8d 100644
--- a/unique_everseen.hpp
+++ b/unique_everseen.hpp
@@ -20,18 +20,37 @@ namespace iter
     {
         using elem_t = iterator_deref<Container>;
         std::unordered_set<typename std::remove_reference<elem_t>::type> elem_seen;
-        std::function<bool(elem_t)> func = [elem_seen](elem_t e) mutable
+
+        std::function<bool(elem_t)> func =
         //has to be captured by value because it goes out of scope when the 
         //function returns
-                {
-                    if (elem_seen.find(e) == std::end(elem_seen)){
-                        elem_seen.insert(e);
-                        return true;
-                    } else {
-                        return false;
-                    }
-                };
-        return filter(func,std::forward<Container>(container));
+            [elem_seen](elem_t e) mutable
+            {
+                if (elem_seen.find(e) == std::end(elem_seen)){
+                    elem_seen.insert(e);
+                    return true;
+                } else {
+                    return false;
+                }
+            };
+        return filter(func, std::forward<Container>(container));
+    }
+
+    template <typename T>
+    auto unique_everseen(std::initializer_list<T> il) 
+        -> Filter<std::function<bool(T)>, std::initializer_list<T>>
+    {
+        std::unordered_set<T> elem_seen;
+        std::function<bool(T)> func = [elem_seen](const T& e) mutable
+            {
+                if (elem_seen.find(e) == std::end(elem_seen)){
+                    elem_seen.insert(e);
+                    return true;
+                } else {
+                    return false;
+                }
+            };
+        return filter(func, il);
     }
 }
 

From b9b7eae630c5e9a03a5c5c755ffd14bc46aa519e Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 8 Aug 2014 22:50:50 -0700
Subject: [PATCH 0446/1866] adds test with temporary

---
 tests/testzip_longest.cpp | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/tests/testzip_longest.cpp b/tests/testzip_longest.cpp
index c6c0dc59..339db47a 100644
--- a/tests/testzip_longest.cpp
+++ b/tests/testzip_longest.cpp
@@ -27,7 +27,11 @@ int main() {
 
         for (auto e : zip_longest(ivec, svec)) {
             std::cout << std::get<0>(e) << std::endl; 
-            //has to deref iter and the optional object
+            std::cout << std::get<1>(e) << std::endl; 
+        }
+
+        for (auto e : zip_longest("helloworld", ivec)) {
+            std::cout << std::get<0>(e) << std::endl; 
             std::cout << std::get<1>(e) << std::endl; 
         }
     }

From 12b57f983f6e9b94b61526bb00e2a74e6c9d8ac3 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 8 Aug 2014 22:57:11 -0700
Subject: [PATCH 0447/1866] overhauls zip_longest, supports temps

---
 zip_longest.hpp | 244 ++++++++++++++++++++++++++++++------------------
 1 file changed, 153 insertions(+), 91 deletions(-)

diff --git a/zip_longest.hpp b/zip_longest.hpp
index b81b1268..f3fd8014 100644
--- a/zip_longest.hpp
+++ b/zip_longest.hpp
@@ -1,108 +1,170 @@
-#ifndef ZIP_LONGEST_HPP
-#define ZIP_LONGEST_HPP
+#ifndef ZIP_LONGEST_HPP_
+#define ZIP_LONGEST_HPP_
 
-#include "iterator_range.hpp"
+#include "iterbase.hpp"
 
 #include <boost/optional.hpp>
+#include <iterator>
 #include <tuple>
 #include <utility>
-#include <iterator>
+
 
 namespace iter {
-    template <typename ... Containers>
-        struct zip_longest_iter;
-    template <typename ... Containers>
-        iterator_range<zip_longest_iter<Containers...>>
-        zip_longest(Containers && ... containers)
-        {
-            auto begin = 
-                zip_longest_iter<Containers...>(std::forward<Containers>(containers)...);
-            auto end = 
-                zip_longest_iter<Containers...>(std::forward<Containers>(containers)...);
-            return iterator_range<decltype(begin)>(begin,end);
-        }   
-    /*
-    template <int N,typename Tuple>
-    auto zip_get(Tuple & t)->decltype(*std::get<N>(t))&
-    {
-        return *std::get<N>(t);
-    }
-    */
-    template <typename Container>
-        struct zip_longest_iter<Container> {
-        public:
-            using Iterator = decltype(std::begin(std::declval<Container>()));
+    template <typename Container, typename... RestContainers>
+    class ZippedLongest;
+
+    template <typename... Containers>
+    ZippedLongest<Containers...> zip_longest(Containers&&...);
+
+    template <typename Container, typename... RestContainers>
+    class ZippedLongest {
+        static_assert(!std::is_rvalue_reference<Container>::value,
+                "Itertools cannot be templated with rvalue references");
+
+        friend ZippedLongest zip_longest<Container, RestContainers...>(
+                Container&&, RestContainers&&...);
+
+        template <typename C, typename... RC>
+        friend class ZippedLongest;
+
         private:
-            Iterator begin;
-            const Iterator end;
+            Container container;
+            ZippedLongest<RestContainers...> rest_zipped;
+            ZippedLongest(Container container, RestContainers&&... rest)
+                : container(std::forward<Container>(container)),
+                rest_zipped{std::forward<RestContainers>(rest)...}
+            { }
 
         public:
-            zip_longest_iter(Container && c) :
-                begin(std::begin(c)),end(std::end(c)) {}
-
-            std::tuple<boost::optional<decltype(*std::declval<Iterator>())>> 
-            operator*()     
-            {
-                return std::make_tuple(begin != end ? 
-                        boost::optional<decltype(*std::declval<Iterator>())>(*begin)
-                        : boost::optional<decltype(*std::declval<Iterator>())>());
-            }
-            zip_longest_iter & operator++() {
-                if(begin!=end)++begin;
-                return *this;
+            class Iterator {
+                private:
+                    using RestIter =
+                        typename ZippedLongest<RestContainers...>::Iterator;
+                    using OptType = boost::optional<iterator_deref<Container>>;
+
+                    iterator_type<Container> iter;
+                    iterator_type<Container> end;
+                    RestIter rest_iter;
+
+                public:
+                    Iterator(
+                            iterator_type<Container> it,
+                            iterator_type<Container> in_end,
+                            const RestIter& rest)
+                        : iter{it},
+                        end{in_end},
+                        rest_iter{rest}
+                    { }
+
+                    Iterator& operator++() {
+                        if (this->iter != this->end) {
+                            ++this->iter;
+                        }
+                        ++this->rest_iter;
+                        return *this;
+                    }
+
+                    bool operator!=(const Iterator& other) const {
+                        return this->iter != other.iter ||
+                            this->rest_iter != other.rest_iter;
+                    }
+
+                    auto operator*() ->
+                        decltype(std::tuple_cat(
+                                    std::tuple<OptType>{OptType{*this->iter}},
+                                    *this->rest_iter))
+                    {
+                        if (this->iter != this->end) {
+                            return std::tuple_cat(
+                                    std::tuple<OptType>{OptType{*this->iter}},
+                                    *this->rest_iter);
+                        } else {
+                            return std::tuple_cat(
+                                    std::tuple<OptType>{OptType{}},
+                                    *this->rest_iter);
+                        }
+                    }
+            };
+
+            Iterator begin() {
+                return {std::begin(this->container),
+                    std::end(this->container),
+                    std::begin(this->rest_zipped)};
             }
-            bool operator!=(const zip_longest_iter &) const {
-                return begin != end;
+
+            Iterator end() {
+                return {std::end(this->container),
+                    std::end(this->container),
+                    std::end(this->rest_zipped)};
             }
-        };
-    template <typename Container, typename ... Containers>
-        struct zip_longest_iter<Container,Containers...> {
-        public:
-            using Iterator = decltype(std::begin(std::declval<Container>()));
+    };
+
+
+    template <typename Container>
+    class ZippedLongest<Container> {
+        static_assert(!std::is_rvalue_reference<Container>::value,
+                "Itertools cannot be templated with rvalue references");
+
+        friend ZippedLongest zip_longest<Container>(Container&&);
+
+        template <typename C, typename... RC>
+        friend class ZippedLongest;
+
         private:
-            Iterator begin;
-            const Iterator end;
-            zip_longest_iter<Containers...> inner_iter;
-            
+            Container container;
+            ZippedLongest(Container container)
+                : container(std::forward<Container>(container))
+            { }
+
         public:
-            using Elem_t = decltype(*begin);
-            using tuple_t = 
-                decltype(std::tuple_cat(
-                            std::tuple<boost::optional<Elem_t>>(),
-                            *inner_iter));
-
-            zip_longest_iter(Container && c, Containers && ... containers) :
-                begin(std::begin(c)),
-                end(std::end(c)),
-                inner_iter(std::forward<Containers>(containers)...) {}
-
-            //this is for returning a tuple of optional<iterator>
-
-            tuple_t operator*()
-            {
-                return std::tuple_cat(std::make_tuple(begin != end 
-                            ?boost::optional<Elem_t>(*begin)
-                            :boost::optional<Elem_t>()),*inner_iter);
-            }
-            zip_longest_iter & operator++() {
-                if (begin != end) ++begin;
-                ++inner_iter;
-                return *this;
+
+            class Iterator {
+                private:
+                    using OptType = boost::optional<iterator_deref<Container>>;
+                    iterator_type<Container> iter;
+                    iterator_type<Container> end;
+                public:
+                    Iterator(
+                            iterator_type<Container> it,
+                            iterator_type<Container> in_end)
+                        : iter{it},
+                        end{in_end}
+                    { }
+
+                    Iterator& operator++() {
+                        if (this->iter != this->end) {
+                            ++this->iter;
+                        }
+                        return *this;
+                    }
+
+                    bool operator!=(const Iterator& other) const {
+                        return this->iter != other.iter;
+                    }
+
+                    std::tuple<OptType> operator*() {
+                        if (this->iter != this->end) {
+                            return std::tuple<OptType>{OptType{*this->iter}};
+                        }
+                        return std::tuple<OptType>{OptType{}};
+                    }
+            };
+
+            Iterator begin() {
+                return {std::begin(this->container),
+                    std::end(this->container)};
             }
-            bool operator!=(const zip_longest_iter & rhs) const {
-                return begin != end || (this->inner_iter != rhs.inner_iter);
+
+            Iterator end() {
+                return {std::end(this->container),
+                    std::end(this->container)};
             }
-        };
-}
-//should add reset after the end of a range is reached, just in case someone 
-//tries to use it again
-//this means it's only safe to use the range ONCE, which is fine because of
-//the input_iterator_tag
-namespace std {
-    template <typename ... Containers>
-        struct iterator_traits<iter::zip_longest_iter<Containers...>> {
-            using difference_type = ptrdiff_t;
-            using iterator_category = input_iterator_tag;
-        };
+    };
+
+    template <typename... Containers>
+    ZippedLongest<Containers...> zip_longest(Containers&&... containers) {
+        return {std::forward<Containers>(containers)...};
+    }
 }
-#endif //ZIP_LONGEST_HPP
+
+#endif // #ifndef ZIP_LONGEST_HPP_

From 9e2f200575ddbd47ea83e4d5e9b8f5ba6a56044d Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 8 Aug 2014 23:07:25 -0700
Subject: [PATCH 0448/1866] test with two temps

---
 tests/testzip_longest.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tests/testzip_longest.cpp b/tests/testzip_longest.cpp
index 339db47a..8ce7753a 100644
--- a/tests/testzip_longest.cpp
+++ b/tests/testzip_longest.cpp
@@ -30,7 +30,8 @@ int main() {
             std::cout << std::get<1>(e) << std::endl; 
         }
 
-        for (auto e : zip_longest("helloworld", ivec)) {
+        for (auto e : zip_longest("helloworld",
+                    std::vector<int>{1,2,3})) {
             std::cout << std::get<0>(e) << std::endl; 
             std::cout << std::get<1>(e) << std::endl; 
         }

From 9d3b1f1ddb50080f22891c3c6ef4fdd2203e4e20 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 8 Aug 2014 23:17:37 -0700
Subject: [PATCH 0449/1866] adds this to cope with clang

---
 sliding_window.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/sliding_window.hpp b/sliding_window.hpp
index cc6f640d..516daf9e 100644
--- a/sliding_window.hpp
+++ b/sliding_window.hpp
@@ -75,7 +75,7 @@ namespace iter {
                     { }
 
                     Iterator& operator++() {
-                        for (auto&& iter : section) {
+                        for (auto&& iter : this->section) {
                             ++iter;
                         }
                         return *this;
@@ -87,7 +87,7 @@ namespace iter {
 
                     DerefVec operator*() {
                         DerefVec vec;
-                        for (auto&& iter : section) {
+                        for (auto&& iter : this->section) {
                             vec.push_back(*iter);
                         }
                         return vec;

From f1f401b91b6d596cf00411c5466897c21ab3056b Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 13 Aug 2014 02:02:10 -0700
Subject: [PATCH 0450/1866] const correctness

---
 groupby.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/groupby.hpp b/groupby.hpp
index 51360bfb..e26a7e04 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -96,7 +96,7 @@ namespace iter {
                         return this->sub_iter == this->sub_end;
                     }
 
-                    iterator_deref<Container> current() const {
+                    iterator_deref<Container> current() {
                         return *this->sub_iter;
                     }
 
@@ -184,7 +184,7 @@ namespace iter {
                                 return *this;
                             }
 
-                            iterator_deref<Container> operator*() const {
+                            iterator_deref<Container> operator*() {
                                 return this->group.owner.current();
                             }
                     };

From 9832d57bba421a8e3249a71955a171384ab04842 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 13 Aug 2014 02:02:23 -0700
Subject: [PATCH 0451/1866] adds frontgetter overload for lvalues

---
 unique_justseen.hpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/unique_justseen.hpp b/unique_justseen.hpp
index 878e2e33..eaf81747 100644
--- a/unique_justseen.hpp
+++ b/unique_justseen.hpp
@@ -17,6 +17,11 @@ namespace iter
                 decltype(*std::begin(gb.second)) {
             return *std::begin(gb.second);
         }
+
+        auto operator()(iterator_deref<GroupByType>& gb) ->
+                decltype(*std::begin(gb.second)) {
+            return *std::begin(gb.second);
+        }
     };
 
 

From 9236beb24b0ca488c253c735230548e69c84cdf0 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 13 Aug 2014 02:05:56 -0700
Subject: [PATCH 0452/1866] ziplongest tests look a lot nicer

---
 tests/testzip_longest.cpp | 47 +++++++++++++++++++--------------------
 1 file changed, 23 insertions(+), 24 deletions(-)

diff --git a/tests/testzip_longest.cpp b/tests/testzip_longest.cpp
index 8ce7753a..63dc8fd0 100644
--- a/tests/testzip_longest.cpp
+++ b/tests/testzip_longest.cpp
@@ -9,14 +9,13 @@
 using iter::zip_longest;
 
 template <typename T>
-std::ostream & operator<<(std::ostream & o, const boost::optional<T> & opt) {
+std::ostream & operator<<(std::ostream & out, const boost::optional<T>& opt) {
     if (opt) {
-        std::cout << *opt << std::endl;
+        out << "Just " << *opt;
+    } else {
+        out << "Nothing";
     }
-    else {
-        std::cout << "Object disengaged of type " << typeid(T).name() << std::endl;
-    }
-    return o;
+    return out;
 }
 
 int main() {
@@ -44,39 +43,39 @@ int main() {
         std::array<double,5> d{{1.2,1.2,1.2,1.2,1.2}};
         std::cout << std::endl << "Variadic template zip_longest" << std::endl;
         for (auto e : iter::zip_longest(i,f,s,d)) {
-            std::cout << std::get<0>(e)
-                << std::get<1>(e) 
-                << std::get<2>(e) 
+            std::cout << std::get<0>(e) << ' '
+                << std::get<1>(e) << ' '
+                << std::get<2>(e) << ' '
                 << std::get<3>(e) << std::endl;
             *std::get<1>(e)=2.2f; //modify the float array
         }
         std::cout<<"modified array" <<std::endl;
         for (auto e : iter::zip_longest(i,s,f,d)) {
-            std::cout << std::get<0>(e) 
-                << std::get<1>(e) 
-                << std::get<2>(e) 
+            std::cout << std::get<0>(e) << ' '
+                << std::get<1>(e) << ' '
+                << std::get<2>(e) << ' '
                 << std::get<3>(e) << std::endl;
         }
         std::cout << std::endl << "Try some weird range differences" << std::endl;
         std::vector<int> empty{};
         for (auto e : iter::zip_longest(empty,f,s,d)) {
-            std::cout << std::get<0>(e) 
-                << std::get<1>(e) 
-                << std::get<2>(e) 
+            std::cout << std::get<0>(e) << ' '
+                << std::get<1>(e) << ' '
+                << std::get<2>(e) << ' '
                 << std::get<3>(e) << std::endl;
         }
         std::cout<<std::endl;
         for (auto e : iter::zip_longest(f,empty,s,d)) {
-            std::cout << std::get<0>(e) 
-                << std::get<1>(e) 
-                << std::get<2>(e) 
+            std::cout << std::get<0>(e) << ' '
+                << std::get<1>(e) << ' '
+                << std::get<2>(e) << ' '
                 << std::get<3>(e) << std::endl;
         }
         std::cout<<std::endl;
         for (auto e : iter::zip_longest(f,s,i,d)) { 
-            std::cout << std::get<0>(e) 
-                << std::get<1>(e) 
-                << std::get<2>(e) 
+            std::cout << std::get<0>(e) << ' '
+                << std::get<1>(e) << ' '
+                << std::get<2>(e) << ' '
                 << std::get<3>(e) << std::endl;
         }
         std::cout<<std::endl;
@@ -84,9 +83,9 @@ int main() {
                     std::initializer_list<double>{1.1,2.2,3.3,4.4},
                     std::initializer_list<double>{1.1,2.2,3.3,4.4},
                     std::array<int,3>{{1,2,3}})) { 
-            std::cout << std::get<0>(e) 
-                << std::get<1>(e) 
-                << std::get<2>(e) 
+            std::cout << std::get<0>(e) << ' '
+                << std::get<1>(e) << ' '
+                << std::get<2>(e) << ' '
                 << std::get<3>(e) << std::endl;
         }
         std::cout<<std::endl;

From 76abc11ec91b5c6ab7b1f7fcc5b2a41b79eceabb Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 13 Aug 2014 10:41:42 -0700
Subject: [PATCH 0453/1866] adds Google to list of copyright holders

---
 LICENSE.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/LICENSE.md b/LICENSE.md
index 3b340456..3d3c6ef0 100644
--- a/LICENSE.md
+++ b/LICENSE.md
@@ -1,4 +1,4 @@
-Copyright (c) 2013, Ryan Haining, Aaron Josephs
+Copyright (c) 2013, Ryan Haining, Aaron Josephs, Google
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without modification,

From 424e8de4c4c9e235152b1709c4b20a63d38aad76 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 17 Aug 2014 14:02:34 -0700
Subject: [PATCH 0454/1866] corrects chainfrom_iterable id

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index e62a8cce..570ea278 100644
--- a/README.md
+++ b/README.md
@@ -23,7 +23,7 @@ evaluation wherever possible.
 [accumulate](#accumulate)<br />
 [compress](#compress)<br />
 [chain](#chain)<br />
-[chain.from\_iterable](#chain.from_iterable)<br />
+[chain.from\_iterable](#chainfrom_iterable)<br />
 [reversed](#reversed)<br />
 [slice](#slice)<br />
 [sliding_window](#sliding_window)<br />

From d3e444fc975157374bce3a4fcea10185aa18efb4 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 19 Aug 2014 13:28:21 -0700
Subject: [PATCH 0455/1866] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 570ea278..1602f3af 100644
--- a/README.md
+++ b/README.md
@@ -432,7 +432,7 @@ for (auto sec : sliding_window(v,4)) {
 grouper
 ------
 
-grouper is very similar to moving section, exception instead of the 
+grouper is very similar to sliding window, except instead of the 
 section sliding by only 1 it goes the length of the full section.
 
 Example usage:

From 90c899bbd5e016f9e4ec8a02985866714d8a696e Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 20 Aug 2014 11:59:28 -0700
Subject: [PATCH 0456/1866] fixes typo on filterfalse

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 1602f3af..7d44c246 100644
--- a/README.md
+++ b/README.md
@@ -126,7 +126,7 @@ Similar to filter, but only prints values that are false under the predicate.
 Prints values not greater than 4: `1 4 3 2 3 2 1 `
 ```c++
 vector<int> vec{1, 5, 4, 0, 6, 7, 3, 0, 2, 8, 3, 2, 1};
-for (auto i : filter([] (int i) { return i > 4; }, vec)) {
+for (auto i : filterfalse([] (int i) { return i > 4; }, vec)) {
     cout << i <<'\n';
 }
 

From 5b157f29435ccbbcd57000f9eeb8c148feee2514 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 24 Aug 2014 00:09:14 -0700
Subject: [PATCH 0457/1866] Adds tests with temporary and array

---
 tests/testgrouper.cpp | 25 ++++++++++++++++---------
 1 file changed, 16 insertions(+), 9 deletions(-)

diff --git a/tests/testgrouper.cpp b/tests/testgrouper.cpp
index 50b18554..a1ea0d66 100644
--- a/tests/testgrouper.cpp
+++ b/tests/testgrouper.cpp
@@ -9,14 +9,22 @@ int main() {
             std::cout << i << " ";
             i.get() *= 2;
         }
-        std::cout << std::endl;
+        std::cout << '\n';
     }
+
+    for (auto sec : grouper(std::vector<int>{1,2,3,4,5,6,7,8,9}, 4)) {
+        for (auto i : sec) {
+            std::cout << i << " ";
+            i.get() *= 2;
+        }
+        std::cout << '\n';
+    }
+
     for (auto sec : grouper(v,3)) {
         for (auto i : sec) {
             std::cout << i << " ";
-            //i.get() = 90;
         }
-        std::cout << std::endl;
+        std::cout << '\n';
     }
     std::vector<int> empty {};
     for (auto sec : grouper(empty,3)) {
@@ -25,14 +33,13 @@ int main() {
             std::cout << i << " Shouldn't print\n";
         }
     }
-    //works when perfect forwarding implemented
-    /*
-    for (auto sec : grouper({1,2,3,4,5,6,7,8},3)) {
+
+    int arr[] = {1,2,3,4,5,6,7};
+    for (auto sec : grouper(arr, 2)) {
         for (auto i : sec) {
-            std::cout << i << " ";
+            std::cout << i << ' ';
         }
-        std::cout << std::endl;
+        std::cout << '\n';
     }
-    */
     return 0;
 }

From ce0dabd8439099a4d16c44e120e92af0abd3fb1a Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 24 Aug 2014 00:09:45 -0700
Subject: [PATCH 0458/1866] reworks to support temporaries

---
 grouper.hpp | 179 +++++++++++++++++++++++++++-------------------------
 1 file changed, 93 insertions(+), 86 deletions(-)

diff --git a/grouper.hpp b/grouper.hpp
index 192fd255..b67f12bb 100644
--- a/grouper.hpp
+++ b/grouper.hpp
@@ -1,7 +1,7 @@
-#ifndef GROUPER_HPP 
-#define GROUPER_HPP 
+#ifndef GROUPER_HPP_
+#define GROUPER_HPP_
 
-#include "iterator_range.hpp"
+#include "iterbase.hpp"
 
 #include <vector>
 #include <algorithm>
@@ -11,106 +11,113 @@
 #include <iterator>
 
 namespace iter {
+#if 0
     template <typename Container>
     class grouper_iter;
 
     template <typename Container>
     iterator_range<grouper_iter<Container>> grouper(
-            Container && container, size_t s) {
+            Container && container, std::size_t s) {
         auto begin = grouper_iter<Container>(std::forward<Container>(container), s);
         auto end = grouper_iter<Container>(std::forward<Container>(container));
         return iterator_range<grouper_iter<Container>>(begin, end);
     }
+#endif
 
     template <typename Container>
-    class grouper_iter {
+    class Grouper {
         private:
-            typename 
-                std::conditional<std::is_lvalue_reference<Container>::value,
-                Container&,
-                const Container &>::type container;
-            //Container && container;
-            //using Iterator = decltype(container.begin());
-            using Iterator = decltype(std::begin(container));
-            using Deref_type =
-                std::vector<
-                    std::reference_wrapper<
-                        typename std::remove_reference<
-                            decltype(*std::declval<Iterator>())>::type>>;
-
-
-            std::vector<Iterator> group;
-
-            size_t group_size = 0;
-            bool not_done = true;
-
-        public: 
-            grouper_iter(Container && c, size_t s) :
-                container(std::forward<Container>(c)),group_size(s) 
-            {
-                // if the group size is 0 or the container is empty produce
-                // nothing
-                if (this->group_size == 0 ||
-                        !(std::begin(this->container) != std::end(this->container))) {
-                    this->not_done = false;
-                    return;
-                }
-                size_t i = 0;
-                for (auto iter = std::begin(container); i < group_size;++i,++iter) {
-                    group.push_back(iter);
-                }
-                //for (size_t i = 0; i < this->group_size; ++i) 
-                  //  this->group.push_back(this->container.begin() + i);
-            }
+            Container container;
+            std::size_t group_size;
+        public:
+            Grouper(Container c, std::size_t sz)
+                : container(std::forward<Container>(c)),
+                group_size{sz}
+            { }
 
-            //seems like conclassor is same as sliding_window_iter
-            grouper_iter(Container && c) :
-                container(std::forward<Container>(c))
-            {
-                //creates the end iterator
-                group.push_back(std::end(container));
-            }
+            class Iterator {
+                private:
+                    Container& container;
+                    std::vector<iterator_type<Container>> group;
+                    std::size_t group_size = 0;
+                    bool not_done = true;
 
-            //plan to conditionally check for existence of +=
-            grouper_iter & operator++() {
-                for (auto & iter : this->group) {
-                    std::advance(iter,this->group_size);
-                }
-                return *this;
-            }
-            /*
-            grouper_iter & operator++() {
-                for (auto & iter : this->group) {
-                    for(size_t i = 0; i < group_size;++i,++iter);
-                }
-                return *this;
-            }
-            */
-            bool operator!=(const grouper_iter &) const {
-                return this->not_done;
-            }
+                    using Deref_type =
+                        std::vector<
+                            std::reference_wrapper<
+                                typename std::remove_reference<
+                                    iterator_deref<Container>>::type>>;
+
+
+                public: 
+                    Iterator(Container& c, std::size_t s)
+                        : container(c),
+                        group_size(s) 
+                    {
+                        // if the group size is 0 or the container is empty produce
+                        // nothing
+                        if (this->group_size == 0
+                                || (!(std::begin(this->container)
+                                        != std::end(this->container)))) {
+                            this->not_done = false;
+                            return;
+                        }
+                        std::size_t i = 0;
+                        for (auto iter = std::begin(container);
+                                i < group_size;
+                                ++i, ++iter) {
+                            group.push_back(iter);
+                        }
+                    }
+
+                    //seems like conclassor is same as sliding_window_iter
+                    Iterator(Container& c)
+                        : container(c)
+                    {
+                        //creates the end iterator
+                        group.push_back(std::end(container));
+                    }
 
-            Deref_type operator*() {
-                Deref_type vec;
-                for (auto i : this->group) {
-                    if(!(i != std::end(this->container))) {
-                        this->not_done = false;
-                        break;
-                    } 
-                    //if the group is at the end the vector will be smaller 
-                    else { 
-                        vec.push_back(*i);
+                    //plan to conditionally check for existence of +=
+                    Iterator & operator++() {
+                        for (auto & iter : this->group) {
+                            std::advance(iter,this->group_size);
+                        }
+                        return *this;
                     }
-                }
-                return vec;
+
+                    bool operator!=(const Iterator &) const {
+                        return this->not_done;
+                    }
+
+                    Deref_type operator*() {
+                        Deref_type vec;
+                        for (auto i : this->group) {
+                            if(!(i != std::end(this->container))) {
+                                this->not_done = false;
+                                break;
+                            } 
+                            //if the group is at the end the vector will be smaller 
+                            else { 
+                                vec.push_back(*i);
+                            }
+                        }
+                        return vec;
+                    }
+            };
+
+            Iterator begin() {
+                return {this->container, group_size};
+            }
+
+            Iterator end() {
+                return {this->container};
             }
     };
-}
-namespace std {
+
     template <typename Container>
-        struct iterator_traits<iter::grouper_iter<Container>> {
-            using difference_type = ptrdiff_t;
-            using iterator_category = input_iterator_tag;
-        };
+    Grouper<Container> grouper(Container&& container, std::size_t group_size) {
+        return {std::forward<Container>(container), group_size};
+    }
 }
-#endif // ifndef GROUPER_HPP
+#endif // #ifndef GROUPER_HPP_

From aed011cf98a550105301f7414b2c902ed7f59496 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 24 Aug 2014 00:12:26 -0700
Subject: [PATCH 0459/1866] removes iter_ideas.txt

---
 iter_ideas.txt | 56 --------------------------------------------------
 1 file changed, 56 deletions(-)
 delete mode 100644 iter_ideas.txt

diff --git a/iter_ideas.txt b/iter_ideas.txt
deleted file mode 100644
index 465fe336..00000000
--- a/iter_ideas.txt
+++ /dev/null
@@ -1,56 +0,0 @@
-movingsection(Container & container,size_t section_size);
-Lets say you have a list
-    [1,2,3,4,5,6,7,8]
-and you want to iterate over 3 elements at a time. You could create three 
-iterators and incrment them simulatneously, or do something like this.
-    for (auto tuple : group_x(list,4))
-In this you get the first 4 then all iters are incremeted by 1 each time so 
-the iterations would be  
-
-1 2 3
-2 3 4
-3 4 5
-4 5 6
-5 6 7
-6 7 8
-
-
-zip_longest using boost::optional or std::optional when support exists.
-useful if a lot of the containers are of different sizes. may want to write
-a different zip_get that works better with optional
-
-Might be a good idea to do a powerset function
-
-Recipes: 
-Not all of the recipes are useful, IMO here are the ones I think we should do
-
-------------------------------------------------------------------------------
-take(n, range)
-
-takes first n items from range and turns it into its own list
-
-------------------------------------------------------------------------------
-quantify(range,predicate)
-
-return amount of times predicate is true
-
-------------------------------------------------------------------------------
-def flatten(listoflists)
-
-flattens one level of nesting
-would be tricky in c++ but kinda useful
-
-------------------------------------------------------------------------------
-roundrobin(Containers ... containers)
-    
-takes the first element off in sequence
-
-------------------------------------------------------------------------------
-unique_everseen(range)
-
-only shows unique elements
-
-------------------------------------------------------------------------------
-unique_justseen(range)
-
-if multiple are the same in a row only display the first one

From f2664c1c3734bf6779c3c79bf1f2f215c22df772 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 24 Aug 2014 01:03:14 -0700
Subject: [PATCH 0460/1866] adds test with init list

---
 tests/testgrouper.cpp | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/tests/testgrouper.cpp b/tests/testgrouper.cpp
index a1ea0d66..b16ebc98 100644
--- a/tests/testgrouper.cpp
+++ b/tests/testgrouper.cpp
@@ -41,5 +41,11 @@ int main() {
         }
         std::cout << '\n';
     }
-    return 0;
+
+    for (auto sec : grouper({1,2,3,4,5,6,7}, 2)) {
+        for (auto i : sec) {
+            std::cout << i << ' ';
+        }
+        std::cout << '\n';
+    }
 }

From 066d6ea3694c2811d76dd1d00e0fa7ac48b0997c Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 24 Aug 2014 01:03:32 -0700
Subject: [PATCH 0461/1866] adds support for init lists

---
 grouper.hpp | 22 ++++++++--------------
 1 file changed, 8 insertions(+), 14 deletions(-)

diff --git a/grouper.hpp b/grouper.hpp
index b67f12bb..314dc1ad 100644
--- a/grouper.hpp
+++ b/grouper.hpp
@@ -5,25 +5,13 @@
 
 #include <vector>
 #include <algorithm>
-#include <functional>
 #include <type_traits>
+#include <functional>
 #include <utility>
 #include <iterator>
+#include <initializer_list>
 
 namespace iter {
-#if 0
-    template <typename Container>
-    class grouper_iter;
-
-    template <typename Container>
-    iterator_range<grouper_iter<Container>> grouper(
-            Container && container, std::size_t s) {
-        auto begin = grouper_iter<Container>(std::forward<Container>(container), s);
-        auto end = grouper_iter<Container>(std::forward<Container>(container));
-        return iterator_range<grouper_iter<Container>>(begin, end);
-    }
-#endif
-
     template <typename Container>
     class Grouper {
         private:
@@ -119,5 +107,11 @@ namespace iter {
     Grouper<Container> grouper(Container&& container, std::size_t group_size) {
         return {std::forward<Container>(container), group_size};
     }
+
+    template <typename T>
+    Grouper<std::initializer_list<T>> grouper(
+            std::initializer_list<T> il, std::size_t group_size) {
+        return {il, group_size};
+    }
 }
 #endif // #ifndef GROUPER_HPP_

From bd52ee1a308481c0a5b4182a7dd2257349979ca1 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 24 Aug 2014 01:08:16 -0700
Subject: [PATCH 0462/1866] makes constructor private

---
 grouper.hpp | 18 +++++++++++++++++-
 1 file changed, 17 insertions(+), 1 deletion(-)

diff --git a/grouper.hpp b/grouper.hpp
index 314dc1ad..af75ade3 100644
--- a/grouper.hpp
+++ b/grouper.hpp
@@ -12,17 +12,33 @@
 #include <initializer_list>
 
 namespace iter {
+    template <typename Container>
+    class Grouper;
+
+    template <typename Container>
+    Grouper<Container> grouper(Container&&, std::size_t);
+
+    template <typename T>
+    Grouper<std::initializer_list<T>> grouper(
+            std::initializer_list<T>, std::size_t);
+
     template <typename Container>
     class Grouper {
         private:
             Container container;
             std::size_t group_size;
-        public:
+
             Grouper(Container c, std::size_t sz)
                 : container(std::forward<Container>(c)),
                 group_size{sz}
             { }
 
+            friend Grouper grouper<Container>(Container&&, std::size_t);
+            template <typename T>
+            friend Grouper<std::initializer_list<T>> grouper(
+                    std::initializer_list<T>, std::size_t);
+
+        public:
             class Iterator {
                 private:
                     Container& container;

From 42d387cd0f26b0aa256f065e9c3117267354675c Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 28 Aug 2014 17:59:37 -0400
Subject: [PATCH 0463/1866] adds test with empty zip()

---
 tests/testzip.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tests/testzip.cpp b/tests/testzip.cpp
index 06e3ebbf..0aa809bd 100644
--- a/tests/testzip.cpp
+++ b/tests/testzip.cpp
@@ -13,6 +13,8 @@ using iter::zip;
 int main() {
     //Ryan's test
     {
+        for (auto t : zip()) { }
+
         std::vector<int> ivec{1, 4, 9, 16, 25, 36};
         std::vector<std::string> svec{"hello", "good day", "goodbye"};
 

From 583db7e91ca60cbdecc7518c4349b7595a520a1d Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 28 Aug 2014 18:16:59 -0400
Subject: [PATCH 0464/1866] Supports empty zip(); removes Zipped<T>

Instead of specializating on Zipped<T>, specialized for Zipped<T, Ts...>
and lets the normal Zipped class (non-specialized) handle the 0 type
case. It makes the template instantiation recursion one level deeper by
using an empty base case, but in doing so eliminates the duplicate logic
in the one-type specialization, and supports zip() as well.
---
 zip.hpp | 69 ++++++++++++++++++++++++++-------------------------------
 1 file changed, 32 insertions(+), 37 deletions(-)

diff --git a/zip.hpp b/zip.hpp
index 8f33d099..e4b3bf94 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -1,5 +1,5 @@
-#ifndef ZIP__H__
-#define ZIP__H__
+#ifndef ITER_ZIP_HPP_
+#define ITER_ZIP_HPP_
 
 #include "iterbase.hpp"
 
@@ -9,21 +9,22 @@
 
 
 namespace iter {
-    template <typename Container, typename... RestContainers>
+    template <typename... RestContainers>
     class Zipped;
 
     template <typename... Containers>
     Zipped<Containers...> zip(Containers&&...);
 
+    // specialization for at least 1 template argument
     template <typename Container, typename... RestContainers>
-    class Zipped {
+    class Zipped <Container, RestContainers...> {
         static_assert(!std::is_rvalue_reference<Container>::value,
                 "Itertools cannot be templated with rvalue references");
 
         friend Zipped zip<Container, RestContainers...>(
                 Container&&, RestContainers&&...);
 
-        template <typename C, typename... RC>
+        template <typename... RC>
         friend class Zipped;
 
         private:
@@ -43,6 +44,7 @@ namespace iter {
                     iterator_type<Container> iter;
                     RestIter rest_iter;
                 public:
+                    constexpr static const bool is_base_iter = false;
                     Iterator(iterator_type<Container> it, const RestIter& rest)
                         : iter{it},
                         rest_iter{rest}
@@ -56,7 +58,8 @@ namespace iter {
 
                     bool operator!=(const Iterator& other) const {
                         return this->iter != other.iter &&
-                            this->rest_iter != other.rest_iter;
+                            (RestIter::is_base_iter ||
+                                this->rest_iter != other.rest_iter);
                     }
 
                     auto operator*() ->
@@ -84,53 +87,45 @@ namespace iter {
     };
 
 
-    template <typename Container>
-    class Zipped<Container> {
-        static_assert(!std::is_rvalue_reference<Container>::value,
-                "Itertools cannot be templated with rvalue references");
-
-        friend Zipped zip<Container>(Container&&);
-
-        template <typename C, typename... RC>
-        friend class Zipped;
-
-        private:
-            Container container;
-            Zipped(Container container)
-                : container(std::forward<Container>(container))
-            { }
-
+    // any number of arguments, should only be instantiated if there are 0
+    // arguments, since the specialized version gets 1 or more
+    template <typename... Ts>
+    class Zipped {
+        static_assert(sizeof...(Ts) == 0,
+                "attempt to instantiate base case with more than 0 types");
         public:
-
             class Iterator {
-                private:
-                    iterator_type<Container> iter;
                 public:
-                    Iterator(iterator_type<Container> it)
-                        : iter{it}
-                    { }
+                    constexpr static const bool is_base_iter = true;
+
+                    Iterator() { }
+                    Iterator(const Iterator&) { }
+                    Iterator& operator=(const Iterator&) { return *this; }
 
                     Iterator& operator++() {
-                        ++this->iter;
                         return *this;
                     }
 
-                    bool operator!=(const Iterator& other) const {
-                        return this->iter != other.iter;
+                    // if this were to return true, there would be no need
+                    // for the is_base_iter static class attribute.
+                    // However, returning false causes an empty zip() call
+                    // to reach the "end" immediately. Returning true here
+                    // instead results in an infinite loop in the zip() case
+                    bool operator!=(const Iterator&) const {
+                        return false; 
                     }
 
-                    std::tuple<iterator_deref<Container>> operator*() {
-                        return std::tuple<iterator_deref<Container>>{
-                            *this->iter};
+                    std::tuple<> operator*() {
+                        return std::tuple<>{};
                     }
             };
 
             Iterator begin() {
-                return {std::begin(this->container)};
+                return {};
             }
 
             Iterator end() {
-                return {std::end(this->container)};
+                return {};
             }
     };
 
@@ -140,4 +135,4 @@ namespace iter {
     }
 }
 
-#endif //#ifndef ZIP__H__
+#endif // #ifndef ITER_ZIP_HPP_

From 606b4bac6575d542129fa2bc6c28742b7f94702d Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 29 Aug 2014 22:59:06 -0400
Subject: [PATCH 0465/1866] replaces general Zipped with specialization

instead of Zipped<T, Ts...> and Zipped<Ts...>, the latter being the
empty case. I now have Zipped<T, Ts...> and Zipped<>. This is a clearer
expression of what's actually going on.
---
 zip.hpp | 10 +++-------
 1 file changed, 3 insertions(+), 7 deletions(-)

diff --git a/zip.hpp b/zip.hpp
index e4b3bf94..08d2ec1a 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -87,12 +87,8 @@ namespace iter {
     };
 
 
-    // any number of arguments, should only be instantiated if there are 0
-    // arguments, since the specialized version gets 1 or more
-    template <typename... Ts>
-    class Zipped {
-        static_assert(sizeof...(Ts) == 0,
-                "attempt to instantiate base case with more than 0 types");
+    template <>
+    class Zipped<> {
         public:
             class Iterator {
                 public:
@@ -112,7 +108,7 @@ namespace iter {
                     // to reach the "end" immediately. Returning true here
                     // instead results in an infinite loop in the zip() case
                     bool operator!=(const Iterator&) const {
-                        return false; 
+                        return false;
                     }
 
                     std::tuple<> operator*() {

From cdbb9fa30850d67902db361b2d0d9b8089f86c5a Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 6 Sep 2014 18:13:24 -0400
Subject: [PATCH 0466/1866] Adds tests with array, temporary, empty product()

My laptop died while doing something gitty, so a few commits got lost
and I had to put them back in this one.
---
 tests/testproduct.cpp | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/tests/testproduct.cpp b/tests/testproduct.cpp
index 94e38944..a07b252b 100644
--- a/tests/testproduct.cpp
+++ b/tests/testproduct.cpp
@@ -42,5 +42,21 @@ int main() {
         std::cout << std::get<0>(t) << ", "
           << std::get<1>(t)  << std::endl;
     }
+    std::cout << '\n';
+
+    for (auto t : product()) { t=t; }
+
+    for (auto t : product(std::string{"hi"}, v1)) {
+        std::cout << std::get<0>(t) << ", "
+            << std::get<1>(t) << std::endl;
+    }
+    std::cout << '\n';
+
+    int arr[] = {1,2};
+    for (auto t : product(std::string{"hi"}, arr)) {
+        std::cout << std::get<0>(t) << ", "
+            << std::get<1>(t) << std::endl;
+    }
+
     return 0;
 }

From 744c6b9fb5cd7937c760262d297296a64c3e5d37 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 6 Sep 2014 18:14:28 -0400
Subject: [PATCH 0467/1866] Rewritten to support temporaries

This is basically zip() modified.
---
 product.hpp | 248 ++++++++++++++++++++++++++++------------------------
 1 file changed, 136 insertions(+), 112 deletions(-)

diff --git a/product.hpp b/product.hpp
index e934c362..07bd8849 100644
--- a/product.hpp
+++ b/product.hpp
@@ -1,124 +1,148 @@
-#ifndef PRODUCT_HPP
-#define PRODUCT_HPP
-#include "iterator_range.hpp"
+#ifndef ITER_PRODUCT_HPP_
+#define ITER_PRODUCT_HPP_
 
+#include "iterbase.hpp"
+
+#include <iterator>
 #include <tuple>
 #include <utility>
-#include <iterator>
+
 
 namespace iter {
-    template <typename ... Containers>
-        struct product_iter;
-    template <typename ... Containers>
-        iterator_range<product_iter<Containers...>>
-        product(const Containers & ... containers) {
-            auto begin = product_iter<Containers...>(containers...);
-            auto end = product_iter<Containers...>(containers...);
-            return iterator_range<decltype(begin)>(begin,end);
-        }
-    //template <typenam
-    template <typename Container>
-        struct product_iter<Container> {
-            public:
-                using Iterator = decltype(std::begin(std::declval<Container>()));
-            private:
-                Iterator begin;
-                Iterator mover;
-                const Iterator end;
-            public:
-                product_iter(const Container & c) :
-                    begin(std::begin(c)),
-                    mover(std::begin(c)),
-                    end(std::end(c)){}
-                decltype(std::make_tuple(*mover)) operator*()
-                //since you can't modify anything anyway it's ok to return a
-                //tuple of whatever the iterator derefs to
-                {
-                    return std::make_tuple(*mover);
-                }
-                product_iter & operator++()
-                {
-                    ++mover;
-                    return *this;
-                }
-                bool is_not_empty_range() {
-                    return begin != end;
-                }
-                bool operator!=(const product_iter&) const 
-                {
-                    return mover != end;
-                }
-                bool is_next_iteration()
-                {
-                    if (!(mover != end)) {
-                        mover = begin;
-                        return true;
+    template <typename... RestContainers>
+    class Productor;
+
+    template <typename... Containers>
+    Productor<Containers...> product(Containers&&...);
+
+    // specialization for at least 1 template argument
+    template <typename Container, typename... RestContainers>
+    class Productor <Container, RestContainers...> {
+        static_assert(!std::is_rvalue_reference<Container>::value,
+                "Itertools cannot be templated with rvalue references");
+
+        friend Productor product<Container, RestContainers...>(
+                Container&&, RestContainers&&...);
+
+        template <typename... RC>
+        friend class Productor;
+
+        private:
+            Container container;
+            Productor<RestContainers...> rest_products;
+            Productor(Container container, RestContainers&&... rest)
+                : container(std::forward<Container>(container)),
+                rest_products{std::forward<RestContainers>(rest)...}
+            { }
+
+        public:
+            class Iterator {
+                private:
+                    using RestIter =
+                        typename Productor<RestContainers...>::Iterator;
+
+                    iterator_type<Container> iter;
+                    const iterator_type<Container> begin;
+
+                    RestIter rest_iter;
+                    const RestIter rest_end;
+                public:
+                    constexpr static const bool is_base_iter = false;
+                    Iterator(iterator_type<Container> it,
+                            const RestIter& rest,
+                            const RestIter& in_rest_end)
+                        : iter{it},
+                        begin{it},
+                        rest_iter{rest},
+                        rest_end{in_rest_end}
+                    { }
+
+                    void reset() {
+                        this->iter = this->begin;
+                    }
+
+                    Iterator& operator++() {
+                        ++this->rest_iter;
+                        if (!(this->rest_iter != this->rest_end)) {
+                            this->rest_iter.reset();
+                            ++this->iter;
+                        }
+                        return *this;
                     }
-                    else return false;
-                }
-        };
-
-    template <typename Container, typename ...Containers>
-        struct product_iter<Container,Containers...>
-        {
-            public:
-                using Iterator = decltype(std::begin(std::declval<Container>()));
-            private:
-                Iterator begin;
-                Iterator mover;
-                const Iterator end;
-                product_iter<Containers...> inner_iter;
-                bool no_empty_ranges;
-            public:
-                using Tuple_type = decltype(std::tuple_cat(std::make_tuple(*mover),*inner_iter));
-                bool is_not_empty_range() {
-                    return begin != end && inner_iter.is_not_empty_range();
-                }
-                product_iter(const Container & c, const Containers & ... containers):
-                    begin(std::begin(c)),
-                    mover(std::begin(c)),
-                    end(std::end(c)),
-                    inner_iter(containers...){
-                        no_empty_ranges = is_not_empty_range();
+
+                    bool operator!=(const Iterator& other) const {
+                        return this->iter != other.iter &&
+                            (RestIter::is_base_iter ||
+                                this->rest_iter != other.rest_iter);
                     }
-                Tuple_type operator*()
-                {
-                    return std::tuple_cat(std::make_tuple(*mover),*inner_iter);
-                }
-                product_iter & operator++()
-                {
-                    ++inner_iter;
-                    if(inner_iter.is_next_iteration())
+
+                    auto operator*() ->
+                        decltype(std::tuple_cat(
+                                    std::tuple<iterator_deref<Container>>{
+                                        *this->iter},
+                                    *this->rest_iter))
                     {
-                        ++mover;
+                        return std::tuple_cat(
+                                std::tuple<iterator_deref<Container>>{
+                                    *this->iter},
+                                *this->rest_iter);
+                    }
+            };
+
+            Iterator begin() {
+                return {std::begin(this->container),
+                    std::begin(this->rest_products),
+                    std::end(this->rest_products)};
+            }
+
+            Iterator end() {
+                return {std::end(this->container),
+                    std::end(this->rest_products),
+                    std::end(this->rest_products)};
+            }
+    };
+
+
+    template <>
+    class Productor<> {
+        public:
+            class Iterator {
+                public:
+                    constexpr static const bool is_base_iter = true;
+
+                    Iterator() { }
+                    Iterator(const Iterator&) { }
+                    Iterator& operator=(const Iterator&) { return *this; }
+
+                    void reset() { }
+
+                    Iterator& operator++() {
+                        return *this;
                     }
-                    return *this;
-                }
-                bool is_next_iteration()
-                {
-                    if(!(mover != end)) {
-                        mover = begin;
-                        return true;
+
+                    // see note in zip about base case operator!=
+                    bool operator!=(const Iterator&) const {
+                        return false;
                     }
-                    else return false;
-                }
-                
-                bool operator!=(const product_iter&)const
-                {
-                    return mover != end && no_empty_ranges;
-                }
-                //will seg fault if anything but the first is an empty range 
-                //since != only checks the first one
-        };
-}
-namespace std {
-    template <typename ... Containers>
-        struct iterator_traits<iter::product_iter<Containers...>> {
-            using difference_type = ptrdiff_t;
-            using iterator_category = input_iterator_tag;
-        };
+
+                    std::tuple<> operator*() {
+                        return std::tuple<>{};
+                    }
+            };
+
+            Iterator begin() {
+                return {};
+            }
+
+            Iterator end() {
+                return {};
+            }
+    };
+
+    template <typename... Containers>
+    Productor<Containers...> product(Containers&&... containers) {
+        return {std::forward<Containers>(containers)...};
+    }
 }
-#endif //PRODUCT_HPP
-                    
-                    
 
+#endif // #ifndef ITER_PRODUCT_HPP_

From 1e0e4a983317ddbfeaf717861fba5bddc249522c Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 7 Sep 2014 15:12:58 -0400
Subject: [PATCH 0468/1866] silences unused variable warning

---
 tests/testzip.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/testzip.cpp b/tests/testzip.cpp
index 0aa809bd..76a95fd7 100644
--- a/tests/testzip.cpp
+++ b/tests/testzip.cpp
@@ -13,7 +13,7 @@ using iter::zip;
 int main() {
     //Ryan's test
     {
-        for (auto t : zip()) { }
+        for (auto t : zip()) { t=t; }
 
         std::vector<int> ivec{1, 4, 9, 16, 25, 36};
         std::vector<std::string> svec{"hello", "good day", "goodbye"};

From 680b7861406638970f26f3d5414413d3cb3c0366 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 7 Sep 2014 15:18:10 -0400
Subject: [PATCH 0469/1866] adds product test with moveonly type

---
 tests/samples.hpp     | 32 ++++++++++++++++++++++++++++++++
 tests/testproduct.cpp | 12 ++++++++++++
 2 files changed, 44 insertions(+)
 create mode 100644 tests/samples.hpp

diff --git a/tests/samples.hpp b/tests/samples.hpp
new file mode 100644
index 00000000..f98f5c91
--- /dev/null
+++ b/tests/samples.hpp
@@ -0,0 +1,32 @@
+#ifndef ITERTOOLS_SAMPLE_CLASSES_HPP
+#define ITERTOOLS_SAMPLE_CLASSES_HPP
+
+#include <iostream>
+
+namespace itertest {
+    class MoveOnly {
+        private:
+            int i; // not an aggregate
+        public:
+            MoveOnly(int v)
+                : i{v}
+            { }
+
+            MoveOnly(const MoveOnly&) = delete;
+            MoveOnly& operator=(const MoveOnly&) = delete;
+
+            MoveOnly(MoveOnly&& other) noexcept
+                : i{other.i}
+            { }
+            MoveOnly& operator=(MoveOnly&& other) noexcept {
+                this->i = other.i;
+                return *this;
+            }
+            friend std::ostream& operator<<(
+                    std::ostream& out, const MoveOnly& self) {
+                return out << self.i;
+            }
+    };
+
+}
+#endif // #ifndef ITERTOOLS_SAMPLE_CLASSES_HPP
diff --git a/tests/testproduct.cpp b/tests/testproduct.cpp
index a07b252b..7cc07143 100644
--- a/tests/testproduct.cpp
+++ b/tests/testproduct.cpp
@@ -1,4 +1,7 @@
+#include "samples.hpp"
+
 #include <product.hpp>
+#include <range.hpp>
 
 #include <vector>
 #include <iostream>
@@ -7,12 +10,21 @@
 using iter::product;
 //has trouble with empty ranges and more than 2 ranges
 int main() {
+
+    std::vector<itertest::MoveOnly> mv;
+    for (auto i : iter::range(10)) {
+        mv.emplace_back(i);
+    }
     std::vector<int> empty{};
     std::vector<int> v1{1,2,3};
     std::vector<int> v2{7,8};
     std::vector<std::string> v3{"the","cat"};
     std::vector<std::string> v4{"hi","what","up","dude"};
 
+    for (auto t : product(v1, mv)) {
+        std::cout << std::get<0>(t) << ", "
+            << std::get<1>(t) << std::endl;
+    }
     for (auto t : product(empty,v1)) {
         std::cout << std::get<0>(t) << ", "
             << std::get<1>(t) << std::endl;

From 539ebe0ea01593dfef9a002727fa4bcb54ea908d Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 7 Sep 2014 15:39:54 -0400
Subject: [PATCH 0470/1866] removes older (and now, wrong) comment

---
 tests/testproduct.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/tests/testproduct.cpp b/tests/testproduct.cpp
index 7cc07143..4af55226 100644
--- a/tests/testproduct.cpp
+++ b/tests/testproduct.cpp
@@ -8,7 +8,6 @@
 #include <string>
 
 using iter::product;
-//has trouble with empty ranges and more than 2 ranges
 int main() {
 
     std::vector<itertest::MoveOnly> mv;

From aecdda1734e388e4476f002e9c72b22a3a191b1a Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 7 Sep 2014 15:43:42 -0400
Subject: [PATCH 0471/1866] includes accumulate

---
 itertools.hpp | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/itertools.hpp b/itertools.hpp
index 67a59e37..55039902 100644
--- a/itertools.hpp
+++ b/itertools.hpp
@@ -1,6 +1,7 @@
 #ifndef ITERTOOLS_HPP
 #define ITERTOOLS_HPP
 
+#include "accumulate.hpp"
 #include "chain.hpp"
 #include "combinations.hpp"
 #include "combinations_with_replacement.hpp"
@@ -14,7 +15,6 @@
 #include "groupby.hpp"
 #include "grouper.hpp"
 #include "imap.hpp"
-#include "iterator_range.hpp"
 #include "sliding_window.hpp"
 #include "permutations.hpp"
 #include "powerset.hpp"
@@ -30,8 +30,6 @@
 #include "wrap_iter.hpp"
 #include "zip.hpp"
 #include "zip_longest.hpp"
-//not sure if should include "iterator_range.hpp"
-//since it's already in everything
 
 #endif
 

From 85f3a33e31cf1d86bd7bd4abfe0301493f0e2f2e Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 7 Sep 2014 15:44:30 -0400
Subject: [PATCH 0472/1866] removes unused include of iterator_range

---
 sliding_window.hpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/sliding_window.hpp b/sliding_window.hpp
index 516daf9e..202191f1 100644
--- a/sliding_window.hpp
+++ b/sliding_window.hpp
@@ -1,7 +1,6 @@
 #ifndef SLIDING_WINDOW_HPP_
 #define SLIDING_WINDOW_HPP_
 
-#include "iterator_range.hpp"
 #include "iterbase.hpp"
 
 #include <vector>

From 1e35b4a09ec8c12049988e7b4e4164eaaa6e9ebd Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 7 Sep 2014 15:44:42 -0400
Subject: [PATCH 0473/1866] removes iterator_range

---
 iterator_range.hpp | 30 ------------------------------
 1 file changed, 30 deletions(-)
 delete mode 100644 iterator_range.hpp

diff --git a/iterator_range.hpp b/iterator_range.hpp
deleted file mode 100644
index f2b4e789..00000000
--- a/iterator_range.hpp
+++ /dev/null
@@ -1,30 +0,0 @@
-#ifndef ITERATOR_RANGE_HPP__
-#define ITERATOR_RANGE_HPP__
-
-namespace iter {
-
-    template <typename Iterator>
-    class iterator_range {
-        private:
-            const Iterator begin_;
-            const Iterator end_;
-
-        public:
-            // TODO decide what contstructors should be enabled and disabled
-            iterator_range(const Iterator & begin, const Iterator & end) :
-                begin_(begin),
-                end_(end)
-            { }
-
-            Iterator begin() const {
-                return this->begin_;
-            }
-
-            Iterator end() const {
-                return this->end_;
-            }
-    };
-
-}
-
-#endif //ITERATOR_RANGE_HPP__

From 03b38d316581d3e92155fe89dea53453b08b8c0c Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 7 Sep 2014 15:45:16 -0400
Subject: [PATCH 0474/1866] major reworking of testcommand_chains

---
 tests/testcommand_chains.cpp | 23 ++++++++++++++---------
 1 file changed, 14 insertions(+), 9 deletions(-)

diff --git a/tests/testcommand_chains.cpp b/tests/testcommand_chains.cpp
index 07cae5c5..6c5e44c2 100644
--- a/tests/testcommand_chains.cpp
+++ b/tests/testcommand_chains.cpp
@@ -9,16 +9,14 @@
 using namespace iter;
 
 template <typename T>
-std::ostream & operator<<(std::ostream & o, const boost::optional<T> & opt) {
+std::ostream & operator<<(std::ostream & out, const boost::optional<T>& opt) {
     if (opt) {
-        std::cout << *opt; 
+        out << "Just " << *opt;
+    } else {
+        out << "Nothing";
     }
-    else {
-        std::cout << "Object disengaged of type " << typeid(T).name();
-    }
-    return o;
+    return out;
 }
-
 int main() {
     {
         std::vector<int> vec1{1,2,3,4,5,6};
@@ -30,8 +28,13 @@ int main() {
                 << std::get<1>(t) << std::endl;
         }
     }
+
+    std::string str = "hello world";
+    std::vector<int> vec = {6, 9, 6, 9};
+    for (auto p : enumerate(enumerate(str))) { }
+    for (auto p : enumerate(zip(str, vec))) { }
+
     std::cout << std::endl;
-    /*
     {
         std::vector<int> vec1{1,2,3,4,5,6};
         std::vector<int> vec2{7,8,9,10};
@@ -42,7 +45,6 @@ int main() {
                 << std::get<1>(t) << std::endl;
         }
     }
-    */
     std::cout << std::endl;
     {
         std::vector<int> vec1{1,2,3,4,5,6};
@@ -53,6 +55,8 @@ int main() {
         }
     }
     std::cout << std::endl;
+
+#if 0
     {
         std::vector<int> vec1{1,2,3,4,5,6};
         std::vector<int> vec2{7,8,9,10};
@@ -61,5 +65,6 @@ int main() {
             std::cout<<std::endl;
         }
     }
+#endif
     return 0;
 }

From 3fb09c7b7b22735657f6a905d0e6bad1ede208c8 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 7 Sep 2014 16:01:23 -0400
Subject: [PATCH 0475/1866] adds command chains back to SConstruct

---
 tests/SConstruct | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tests/SConstruct b/tests/SConstruct
index 9ca7f7fd..eb1c70a7 100644
--- a/tests/SConstruct
+++ b/tests/SConstruct
@@ -43,6 +43,7 @@ progs = Split('''
               sorted
               unique_justseen
               unique_everseen
+              command_chains
               ''')
 
 

From c5e26f4d1d96ea0a438539716fee1c6226c282c4 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 7 Sep 2014 17:41:16 -0400
Subject: [PATCH 0476/1866] Makes Enumerable copyable (rule of zero)

---
 enumerate.hpp | 11 -----------
 1 file changed, 11 deletions(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index 0bee1f4a..15fd605d 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -33,8 +33,6 @@ namespace iter {
 
     template <typename Container>
     class Enumerable {
-        static_assert(!std::is_rvalue_reference<Container>::value,
-                "Itertools cannot be templated with rvalue references");
         private:
             Container container;
 
@@ -51,15 +49,6 @@ namespace iter {
             { }
             
         public:
-            Enumerable() = delete;
-            Enumerable& operator=(const Enumerable&) = delete;
-            Enumerable(const Enumerable&) = delete;
-            Enumerable& operator=(Enumerable&&) = delete;
-
-            // movable only
-            Enumerable(Enumerable&&) = default;
-            ~Enumerable() = default;
-
             // "yielded" by the Enumerable::Iterator.  Has a .index, and a 
             // .element referencing the value yielded by the subiterator
             class IterYield {

From 7c7df597f73500d0deffc8a62903a62f6d02742d Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 7 Sep 2014 20:59:28 -0400
Subject: [PATCH 0477/1866] adds test with non-reference-deref'ing iterator

Iterator with T operator*() rather than T& operator*()
---
 tests/samples.hpp          | 41 ++++++++++++++++++++++++++++++++++++++
 tests/testcombinations.cpp | 16 ++++++++++++++-
 2 files changed, 56 insertions(+), 1 deletion(-)

diff --git a/tests/samples.hpp b/tests/samples.hpp
index f98f5c91..31a7ac0d 100644
--- a/tests/samples.hpp
+++ b/tests/samples.hpp
@@ -2,6 +2,7 @@
 #define ITERTOOLS_SAMPLE_CLASSES_HPP
 
 #include <iostream>
+#include <cstddef>
 
 namespace itertest {
     class MoveOnly {
@@ -28,5 +29,45 @@ namespace itertest {
             }
     };
 
+    class DerefByValue {
+        private:
+            static constexpr std::size_t N = 3;
+            int array[N] = {0};
+        public:
+            DerefByValue() = default;
+
+            class Iterator {
+                private:
+                    int *current;
+                public:
+                    Iterator() = default;
+                    Iterator(int *p)
+                        : current{p}
+                    { }
+
+                    bool operator!=(const Iterator& other) const {
+                        return this->current != other.current;
+                    }
+
+                    // for testing, iterator derefences to an int instead of
+                    // an int&
+                    int operator*() {
+                        return *this->current;
+                    }
+
+                    Iterator& operator++() {
+                        ++this->current;
+                        return *this;
+                    }
+            };
+
+            Iterator begin() {
+                return {this->array};
+            }
+
+            Iterator end() {
+                return {this->array + N};
+            }
+    };
 }
 #endif // #ifndef ITERTOOLS_SAMPLE_CLASSES_HPP
diff --git a/tests/testcombinations.cpp b/tests/testcombinations.cpp
index f8c67582..89be1bc5 100644
--- a/tests/testcombinations.cpp
+++ b/tests/testcombinations.cpp
@@ -1,3 +1,4 @@
+#include "samples.hpp"
 #include <combinations.hpp>
 
 #include <vector>
@@ -7,29 +8,42 @@
 
 using iter::combinations;
 int main() {
+    itertest::DerefByValue dbv; 
     std::vector<int> v = {1,2,3,4,5};
-    //doesn't work with 0
+
     for (auto i : combinations(v,0)) {
         for (auto j : i ) std::cout << j << " ";
         std::cout<<std::endl;
     }
+
     for (auto i : combinations(v,3)) {
         for (auto j : i ) std::cout << j << " ";
         std::cout<<std::endl;
     }
+
     for (auto i : combinations(v,1)) {
         for (auto j : i ) std::cout << j << " ";
         std::cout<<std::endl;
     }
+
     for (auto i : combinations(v,5)) {
         for (auto j : i ) std::cout << j << " ";
         std::cout<<std::endl;
     }
+
+    std::cout << "deref by value\n";
+    for (auto i : combinations(dbv, 2)) {
+        for (auto j : i) std::cout << j << " ";
+        std::cout << '\n';
+    }
+
     std::cout << "initializer list\n";
     for (auto i : combinations({1,2,3,4},3)) {
         for (auto j : i ) std::cout << j << " ";
         std::cout<<std::endl;
+
     }
+
     std::cout << "initializer list\n";
     for (auto i : combinations({1,2,3,4},1)) {
         for (auto j : i ) std::cout << j << " ";

From f4f826b5d09675e24af8cae3b261c3237990306c Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 7 Sep 2014 21:01:07 -0400
Subject: [PATCH 0478/1866] removes random access requirement for combinations

Just forward iterator now.
---
 combinations.hpp | 25 ++++++++++++++-----------
 iterbase.hpp     | 38 +++++++++++++++++++++++++++++++++++---
 2 files changed, 49 insertions(+), 14 deletions(-)

diff --git a/combinations.hpp b/combinations.hpp
index 65e92425..5eed7b04 100644
--- a/combinations.hpp
+++ b/combinations.hpp
@@ -49,18 +49,20 @@ namespace iter {
                             iterator_deref<Container>>::type>::type;
 
             public:
-                Iterator(Container& i, size_t N)
+                Iterator(Container& i, std::size_t n)
                     : items(i),
-                    indicies(N)
+                    indicies(n)
                 {
-                    if (N == 0) {
+                    if (n == 0) {
                         not_done = false;
                         return;
                     }
                     size_t inc = 0;
                     for (auto& iter : this->indicies) {
-                        if (std::begin(items) + inc != std::end(items)) {
-                            iter = std::begin(items)+inc;
+                        auto it = std::begin(this->items);
+                        dumb_advance(it, std::end(this->items), inc);
+                        if (it != std::end(this->items)) {
+                            iter = it;
                             ++inc;
                         } else {
                             not_done = false;
@@ -83,20 +85,21 @@ namespace iter {
                             iter != indicies.rend();
                             ++iter) {
                         ++(*iter);
+
                         //what we have to check here is if the distance between
                         //the index and the end of indicies is >= the distance
                         //between the item and end of item
-                        if ((*iter + std::distance(indicies.rbegin(),iter)) ==
-                                std::end(items)) {
+                        auto dist = std::distance(
+                                this->indicies.rbegin(),iter);
+
+                        if (!(dumb_next(*iter, dist) !=
+                                std::end(this->items))) {
                             if ( (iter + 1) != indicies.rend()) {
                                 size_t inc = 1;
                                 for (auto down = iter;
                                         down != indicies.rbegin()-1;
                                         --down) {
-                                    (*down) = (*(iter + 1)) + 1 + inc;
-                                    /*if (*down == items.cend()) {
-                                        iter = iter + 1;
-                                    }*/
+                                    (*down) = dumb_next(*(iter + 1), 1 + inc);
                                     ++inc;
                                 }
                             } else {
diff --git a/iterbase.hpp b/iterbase.hpp
index 85595b3a..00bd88e4 100644
--- a/iterbase.hpp
+++ b/iterbase.hpp
@@ -1,5 +1,5 @@
-#ifndef ITERBASE__HPP__
-#define ITERBASE__HPP__
+#ifndef ITERBASE_HPP_
+#define ITERBASE_HPP_
 
 
 // This file consists of utilities used for the generic nature of the
@@ -10,8 +10,40 @@
 
 #include <utility>
 #include <iterator>
+#include <cstddef>
 
 namespace iter {
+    // because std::advance assumes a lot and is actually smart, I need a dumb
+    // version that will work with most things
+    template <typename InputIt, typename Distance>
+    void dumb_advance(InputIt& iter, Distance distance) {
+        for (Distance i(0); i < distance; ++i) {
+            ++iter;
+        }
+    }
+
+    // iter will not be incremented past end
+    template <typename InputIt, typename Distance>
+    void dumb_advance(InputIt& iter, const InputIt& end, Distance distance=1) {
+        for (Distance i(0); i < distance && iter != end; ++i) {
+            ++iter;
+        }
+    }
+
+    template <typename ForwardIt, typename Distance>
+    ForwardIt dumb_next(ForwardIt it, Distance distance) {
+        dumb_advance(it, distance);
+        return it;
+    }
+
+    template <typename ForwardIt, typename Distance>
+    ForwardIt dumb_next(
+            ForwardIt it, const ForwardIt& end, Distance distance=1) {
+        dumb_advance(it, end, distance);
+        return it;
+    }
+
+
     // iterator_type<C> is the type of C's iterator
     template <typename Container>
     using iterator_type =
@@ -35,4 +67,4 @@ namespace iter {
         decltype(*std::declval<reverse_iterator_type<Container>&>());
 }
 
-#endif // #ifndef ITERBASE__HPP__
+#endif // #ifndef ITERBASE_HPP_

From 7ddcf6e883875cdaff50b0003f9779f54ff99981 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 7 Sep 2014 21:45:48 -0400
Subject: [PATCH 0479/1866] adds test with container of move-only objects

---
 tests/testcombinations.cpp | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/tests/testcombinations.cpp b/tests/testcombinations.cpp
index 89be1bc5..4dce1139 100644
--- a/tests/testcombinations.cpp
+++ b/tests/testcombinations.cpp
@@ -1,5 +1,6 @@
 #include "samples.hpp"
 #include <combinations.hpp>
+#include <range.hpp>
 
 #include <vector>
 #include <string>
@@ -9,8 +10,17 @@
 using iter::combinations;
 int main() {
     itertest::DerefByValue dbv; 
+    std::vector<itertest::MoveOnly> mv;
+    for (auto i : iter::range(3)) {
+        mv.emplace_back(i);
+    }
     std::vector<int> v = {1,2,3,4,5};
 
+    for (auto i : combinations(mv,2)) {
+        for (auto j : i ) std::cout << j << " ";
+        std::cout<<std::endl;
+    }
+
     for (auto i : combinations(v,0)) {
         for (auto j : i ) std::cout << j << " ";
         std::cout<<std::endl;
@@ -62,6 +72,4 @@ int main() {
         for (auto j : i) std::cout << j << " ";
         std::cout << '\n';
     }
-
-    return 0;
 }

From d043ca7c756596ea8c6974ce0e87355ad2e5ba2a Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 7 Sep 2014 22:41:26 -0400
Subject: [PATCH 0480/1866] supports containers of move-only in combinations

---
 combinations.hpp | 19 +++++++++++++------
 1 file changed, 13 insertions(+), 6 deletions(-)

diff --git a/combinations.hpp b/combinations.hpp
index 5eed7b04..c7de09ce 100644
--- a/combinations.hpp
+++ b/combinations.hpp
@@ -7,6 +7,7 @@
 #include <type_traits>
 #include <iterator>
 #include <initializer_list>
+#include <functional>
 
 namespace iter {
     template <typename Container>
@@ -43,11 +44,17 @@ namespace iter {
                 std::vector<iterator_type<Container>> indicies;
                 bool not_done = true;
 
-                using item_t =
-                    typename std::remove_const<
+                // if the iterator dereferences to a reference type,
+                // then reference_wrapper<T>
+                // else T
+                using item_type  = 
+                    typename std::conditional<
+                    std::is_reference<iterator_deref<Container>>::value,
+                    std::reference_wrapper<
                         typename std::remove_reference<
-                            iterator_deref<Container>>::type>::type;
-
+                        iterator_deref<Container>>::type>,
+                    typename std::remove_const<
+                        iterator_deref<Container>>::type>::type;
             public:
                 Iterator(Container& i, std::size_t n)
                     : items(i),
@@ -71,8 +78,8 @@ namespace iter {
                     }
                 }
 
-                std::vector<item_t> operator*() {
-                    std::vector<item_t> values;
+                std::vector<item_type> operator*() {
+                    std::vector<item_type> values;
                     for (auto i : indicies) {
                         values.push_back(*i);
                     }

From cb42ed1ca5ac80fb2777b30a637d26df8569c16e Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 8 Sep 2014 22:06:03 -0400
Subject: [PATCH 0481/1866] test with container of move-only objects

---
 tests/testcombinations_with_replacement.cpp | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/tests/testcombinations_with_replacement.cpp b/tests/testcombinations_with_replacement.cpp
index 0f0a194c..2e9ace64 100644
--- a/tests/testcombinations_with_replacement.cpp
+++ b/tests/testcombinations_with_replacement.cpp
@@ -1,4 +1,6 @@
+#include "samples.hpp"
 #include <combinations_with_replacement.hpp>
+#include <range.hpp>
 
 #include <vector>
 #include <string>
@@ -8,12 +10,23 @@
 using iter::combinations_with_replacement;
 
 int main() {
+    std::vector<itertest::MoveOnly> mv;
+    for (auto i : iter::range(3)) {
+        mv.emplace_back(i);
+    }
+
     std::vector<int> v = {1,2,3,};
     for (auto i : combinations_with_replacement(v,4)) {
         for (auto j : i ) std::cout << j << " ";
         std::cout<<std::endl;
     }
 
+    std::cout << "with container of move-only\n";
+    for (auto i : combinations_with_replacement(mv,2)) {
+        for (auto j : i ) std::cout << j << " ";
+        std::cout<<std::endl;
+    }
+
     std::cout << "with temporary\n";
     for (auto i : combinations_with_replacement(std::vector<int>{1,2,3},4)) {
         for (auto j : i ) std::cout << j << " ";

From 247f63279990ce6568526a7fbebd4de4524dc6f0 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 8 Sep 2014 22:07:09 -0400
Subject: [PATCH 0482/1866] supports containers of move-only objects

---
 combinations_with_replacement.hpp | 14 ++++----------
 1 file changed, 4 insertions(+), 10 deletions(-)

diff --git a/combinations_with_replacement.hpp b/combinations_with_replacement.hpp
index f56d7d2b..63914faa 100644
--- a/combinations_with_replacement.hpp
+++ b/combinations_with_replacement.hpp
@@ -4,6 +4,7 @@
 #include "iterbase.hpp"
 
 #include <iterator>
+#include <functional>
 #include <vector>
 #include <type_traits>
 #include <initializer_list>
@@ -49,11 +50,6 @@ namespace iter {
                    bool not_done;
 
                public:
-                   using item_t =
-                       typename std::remove_const<
-                           typename std::remove_reference<
-                               iterator_deref<Container>>::type>::type;
-
                    Iterator(
                            Container& container, std::size_t n)
                        : items(container),
@@ -61,9 +57,8 @@ namespace iter {
                        not_done{n != 0}
                    { }
 
-                   std::vector<item_t> operator*()
-                   {
-                       std::vector<item_t> values;
+                   std::vector<collection_item_type<Container>> operator*() {
+                       std::vector<collection_item_type<Container>> values;
                        for (auto i : indicies) {
                            values.push_back(*i);
                        }
@@ -96,8 +91,7 @@ namespace iter {
                        return *this;
                    }
 
-                   bool operator !=(const Iterator&) const
-                   {
+                   bool operator !=(const Iterator&) const {
                        //because of the way this is done you have to start from
                        //the begining of the range and end at the end, you
                        //could break in the middle of the loop though, it's not

From 4dc6b207ceb53ff9a2696d2686e751e75a21b34c Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 8 Sep 2014 22:14:28 -0400
Subject: [PATCH 0483/1866] make distances default to 1 (correctly)

---
 iterbase.hpp | 27 ++++++++++++++++++++-------
 1 file changed, 20 insertions(+), 7 deletions(-)

diff --git a/iterbase.hpp b/iterbase.hpp
index 00bd88e4..6bea1cfd 100644
--- a/iterbase.hpp
+++ b/iterbase.hpp
@@ -15,35 +15,34 @@
 namespace iter {
     // because std::advance assumes a lot and is actually smart, I need a dumb
     // version that will work with most things
-    template <typename InputIt, typename Distance>
-    void dumb_advance(InputIt& iter, Distance distance) {
+    template <typename InputIt, typename Distance =std::size_t>
+    void dumb_advance(InputIt& iter, Distance distance=1) {
         for (Distance i(0); i < distance; ++i) {
             ++iter;
         }
     }
 
     // iter will not be incremented past end
-    template <typename InputIt, typename Distance>
+    template <typename InputIt, typename Distance =std::size_t>
     void dumb_advance(InputIt& iter, const InputIt& end, Distance distance=1) {
         for (Distance i(0); i < distance && iter != end; ++i) {
             ++iter;
         }
     }
 
-    template <typename ForwardIt, typename Distance>
-    ForwardIt dumb_next(ForwardIt it, Distance distance) {
+    template <typename ForwardIt, typename Distance =std::size_t>
+    ForwardIt dumb_next(ForwardIt it, Distance distance=1) {
         dumb_advance(it, distance);
         return it;
     }
 
-    template <typename ForwardIt, typename Distance>
+    template <typename ForwardIt, typename Distance =std::size_t>
     ForwardIt dumb_next(
             ForwardIt it, const ForwardIt& end, Distance distance=1) {
         dumb_advance(it, end, distance);
         return it;
     }
 
-
     // iterator_type<C> is the type of C's iterator
     template <typename Container>
     using iterator_type =
@@ -65,6 +64,20 @@ namespace iter {
     template <typename Container>
     using reverse_iterator_deref = 
         decltype(*std::declval<reverse_iterator_type<Container>&>());
+
+    // For combinatoric functions, if the Containers iterator dereferences
+    // to a reference, then this is a std::reference_wrapper for that type
+    // otherwise it's a non-const of that type
+    template <typename Container>
+    using collection_item_type =
+        typename std::conditional<
+        std::is_reference<iterator_deref<Container>>::value,
+        std::reference_wrapper<
+            typename std::remove_reference<
+            iterator_deref<Container>>::type>,
+        typename std::remove_const<
+            iterator_deref<Container>>::type>::type;
+
 }
 
 #endif // #ifndef ITERBASE_HPP_

From 61d6c9ef58f185e03a06250c1cfd64a44a690530 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 8 Sep 2014 22:18:02 -0400
Subject: [PATCH 0484/1866] adds test with value-dereferencing iterator

---
 tests/testcombinations_with_replacement.cpp | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/tests/testcombinations_with_replacement.cpp b/tests/testcombinations_with_replacement.cpp
index 2e9ace64..78b8751e 100644
--- a/tests/testcombinations_with_replacement.cpp
+++ b/tests/testcombinations_with_replacement.cpp
@@ -21,6 +21,13 @@ int main() {
         std::cout<<std::endl;
     }
 
+    itertest::DerefByValue dbv;
+    std::cout << "with deref by value iterator\n";
+    for (auto i : combinations_with_replacement(dbv, 2)) {
+        for (auto j : i ) std::cout << j << " ";
+        std::cout<<std::endl;
+    }
+
     std::cout << "with container of move-only\n";
     for (auto i : combinations_with_replacement(mv,2)) {
         for (auto j : i ) std::cout << j << " ";
@@ -45,6 +52,4 @@ int main() {
         for (auto j : i ) std::cout << j << " ";
         std::cout<<std::endl;
     }
-
-    return 0;
 }

From a9bd0636baf37b98e56f07c00105adcb53aed848 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 8 Sep 2014 22:19:58 -0400
Subject: [PATCH 0485/1866] uses the ridiculous typedef from iterbase instead

---
 combinations.hpp | 15 ++-------------
 1 file changed, 2 insertions(+), 13 deletions(-)

diff --git a/combinations.hpp b/combinations.hpp
index c7de09ce..54a2994a 100644
--- a/combinations.hpp
+++ b/combinations.hpp
@@ -44,17 +44,6 @@ namespace iter {
                 std::vector<iterator_type<Container>> indicies;
                 bool not_done = true;
 
-                // if the iterator dereferences to a reference type,
-                // then reference_wrapper<T>
-                // else T
-                using item_type  = 
-                    typename std::conditional<
-                    std::is_reference<iterator_deref<Container>>::value,
-                    std::reference_wrapper<
-                        typename std::remove_reference<
-                        iterator_deref<Container>>::type>,
-                    typename std::remove_const<
-                        iterator_deref<Container>>::type>::type;
             public:
                 Iterator(Container& i, std::size_t n)
                     : items(i),
@@ -78,8 +67,8 @@ namespace iter {
                     }
                 }
 
-                std::vector<item_type> operator*() {
-                    std::vector<item_type> values;
+                std::vector<collection_item_type<Container>> operator*() {
+                    std::vector<collection_item_type<Container>> values;
                     for (auto i : indicies) {
                         values.push_back(*i);
                     }

From 13d96c1125962fcaf158764b2da4f1f6551a0845 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 8 Sep 2014 22:20:41 -0400
Subject: [PATCH 0486/1866] Supports iterators without random access

---
 combinations_with_replacement.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/combinations_with_replacement.hpp b/combinations_with_replacement.hpp
index 63914faa..0dc01703 100644
--- a/combinations_with_replacement.hpp
+++ b/combinations_with_replacement.hpp
@@ -71,12 +71,12 @@ namespace iter {
                                iter != indicies.rend();
                                ++iter) {
                            ++(*iter);
-                           if (*iter == std::end(items)) {
+                           if (!(*iter != std::end(items))) {
                                if ( (iter + 1) != indicies.rend()) {
                                    for (auto down = iter;
                                            down != indicies.rbegin()-1;
                                            --down) {
-                                       (*down) = (*(iter + 1)) + 1; 
+                                       (*down) = dumb_next(*(iter + 1)); 
                                    }
                                } else {
                                    not_done = false;

From 09c81a00066b38c7f98d999bc3a182bd8cf2cd11 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 8 Sep 2014 22:25:51 -0400
Subject: [PATCH 0487/1866] adds missing <functional> include

---
 iterbase.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/iterbase.hpp b/iterbase.hpp
index 6bea1cfd..15f0a0a0 100644
--- a/iterbase.hpp
+++ b/iterbase.hpp
@@ -10,6 +10,7 @@
 
 #include <utility>
 #include <iterator>
+#include <functional>
 #include <cstddef>
 
 namespace iter {

From cfe6e1689e0af76cebf499575ead910b3f0f45c4 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 8 Sep 2014 22:26:47 -0400
Subject: [PATCH 0488/1866] removes unused includes of <functional>

---
 combinations.hpp                  | 1 -
 combinations_with_replacement.hpp | 1 -
 2 files changed, 2 deletions(-)

diff --git a/combinations.hpp b/combinations.hpp
index 54a2994a..2ae69dff 100644
--- a/combinations.hpp
+++ b/combinations.hpp
@@ -7,7 +7,6 @@
 #include <type_traits>
 #include <iterator>
 #include <initializer_list>
-#include <functional>
 
 namespace iter {
     template <typename Container>
diff --git a/combinations_with_replacement.hpp b/combinations_with_replacement.hpp
index 0dc01703..ead4319a 100644
--- a/combinations_with_replacement.hpp
+++ b/combinations_with_replacement.hpp
@@ -4,7 +4,6 @@
 #include "iterbase.hpp"
 
 #include <iterator>
-#include <functional>
 #include <vector>
 #include <type_traits>
 #include <initializer_list>

From 01fc9467b4dda18ee91e31f367560c51fb67360f Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 8 Sep 2014 22:28:20 -0400
Subject: [PATCH 0489/1866] adds test with container of move-only objects

it just works because powerset uses container
---
 tests/testpowerset.cpp | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/tests/testpowerset.cpp b/tests/testpowerset.cpp
index 712cae14..31af7a97 100644
--- a/tests/testpowerset.cpp
+++ b/tests/testpowerset.cpp
@@ -1,4 +1,6 @@
+#include "samples.hpp"
 #include <powerset.hpp>
+#include <range.hpp>
 #include <vector>
 #include <iostream>
 
@@ -20,8 +22,12 @@ int main() {
         for (auto i : v) std::cout << i << " ";
         std::cout << std::endl;
     }
-#if 0
-#endif
+
+    std::cout << "with container of move-only objects\n";
+    std::vector<itertest::MoveOnly> mv;
+    for (auto i : iter::range(3)) {
+        mv.emplace_back(i);
+    }
 
     return 0;
 }

From 30975801f86eb3a68598f8cdac69b275f394cddb Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 8 Sep 2014 22:29:12 -0400
Subject: [PATCH 0490/1866] trailing whitespace...removed

---
 powerset.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/powerset.hpp b/powerset.hpp
index ef532917..be8e60a8 100644
--- a/powerset.hpp
+++ b/powerset.hpp
@@ -18,7 +18,7 @@ namespace iter {
     class Powersetter {
         private:
             Container container;
-            
+
             std::vector<CombinatorType> combinators;
         public:
             Powersetter(Container in_container)

From 1b83af4fcaf46992f77b533587569041cf80d095 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 8 Sep 2014 22:32:06 -0400
Subject: [PATCH 0491/1866] actually adds the test for move-only objects

it really does just work though. heh.
---
 tests/testpowerset.cpp | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/tests/testpowerset.cpp b/tests/testpowerset.cpp
index 31af7a97..4a8a93b8 100644
--- a/tests/testpowerset.cpp
+++ b/tests/testpowerset.cpp
@@ -28,6 +28,9 @@ int main() {
     for (auto i : iter::range(3)) {
         mv.emplace_back(i);
     }
-
+    for (auto v : powerset(mv)) {
+        for (auto i : v) std::cout << i << " ";
+        std::cout << std::endl;
+    }
     return 0;
 }

From 81e20b4f3f41ee3051c8e3e31808fc51ecbf193a Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 8 Sep 2014 22:33:42 -0400
Subject: [PATCH 0492/1866] adds test with deref-by-value iterator

also "just works"
---
 tests/testpowerset.cpp | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/tests/testpowerset.cpp b/tests/testpowerset.cpp
index 4a8a93b8..20ca0098 100644
--- a/tests/testpowerset.cpp
+++ b/tests/testpowerset.cpp
@@ -32,5 +32,13 @@ int main() {
         for (auto i : v) std::cout << i << " ";
         std::cout << std::endl;
     }
+
+    std::cout << "with deref-by-value iterator\n";
+    itertest::DerefByValue dbv;
+    for (auto v : powerset(dbv)) {
+        for (auto i : v) std::cout << i << " ";
+        std::cout << std::endl;
+    }
+
     return 0;
 }

From e9539599b3270bc8938b944d8ace20c996cb7490 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 9 Sep 2014 19:39:33 -0400
Subject: [PATCH 0493/1866] adds test with container of move-only objects

---
 tests/testpermutations.cpp | 19 ++++++++++++++++---
 1 file changed, 16 insertions(+), 3 deletions(-)

diff --git a/tests/testpermutations.cpp b/tests/testpermutations.cpp
index 6ebc03b4..bac92ae3 100644
--- a/tests/testpermutations.cpp
+++ b/tests/testpermutations.cpp
@@ -1,5 +1,9 @@
-#include <iostream>
+#include "samples.hpp"
+
 #include <permutations.hpp>
+#include <range.hpp>
+
+#include <iostream>
 #include <vector>
 #include <string>
 
@@ -19,7 +23,7 @@ int main() {
             std::cout << c << " ";
         }
         std::cout << std::endl;
-    } 
+    }
     s = "abc";
     for (auto vec : permutations(s)) {
         for (auto c : vec) {
@@ -36,5 +40,14 @@ int main() {
         }
         std::cout << std::endl;
     }
-    return 0;
+
+    std::cout << "with container of move-only objects\n";
+    std::vector<itertest::MoveOnly> mv;
+    for (auto i : iter::range(3)) {
+        mv.emplace_back(i);
+    }
+    for (auto v : permutations(mv)) {
+        for (auto i : v) std::cout << i << " ";
+        std::cout << std::endl;
+    }
 }

From a98f57d2998927b856ea98effa9de060925151cf Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 9 Sep 2014 20:29:41 -0400
Subject: [PATCH 0494/1866] makes MoveOnly less-than comparable

---
 tests/samples.hpp | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/tests/samples.hpp b/tests/samples.hpp
index 31a7ac0d..c23fa024 100644
--- a/tests/samples.hpp
+++ b/tests/samples.hpp
@@ -2,6 +2,7 @@
 #define ITERTOOLS_SAMPLE_CLASSES_HPP
 
 #include <iostream>
+#include <utility>
 #include <cstddef>
 
 namespace itertest {
@@ -19,14 +20,22 @@ namespace itertest {
             MoveOnly(MoveOnly&& other) noexcept
                 : i{other.i}
             { }
+
             MoveOnly& operator=(MoveOnly&& other) noexcept {
                 this->i = other.i;
                 return *this;
             }
+
+            // for std::next_permutation compatibility
+            friend bool operator<(const MoveOnly& lhs, const MoveOnly& rhs) {
+                return lhs.i < rhs.i;
+            }
+
             friend std::ostream& operator<<(
                     std::ostream& out, const MoveOnly& self) {
                 return out << self.i;
             }
+
     };
 
     class DerefByValue {

From f0a45816a8020592f7d0d3fb8912121ed77f85ee Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 9 Sep 2014 20:29:54 -0400
Subject: [PATCH 0495/1866] permutations supports containers of move-only

---
 permutations.hpp | 21 ++++++++++++---------
 1 file changed, 12 insertions(+), 9 deletions(-)

diff --git a/permutations.hpp b/permutations.hpp
index ef6a3dff..d9e64a99 100644
--- a/permutations.hpp
+++ b/permutations.hpp
@@ -1,9 +1,11 @@
 #ifndef PERMUTATIONS_HPP
 #define PERMUTATIONS_HPP
+#include "iterbase.hpp"
 
 #include <algorithm>
 #include <initializer_list>
 #include <vector>
+#include <utility>
 
 
 namespace iter {
@@ -24,29 +26,30 @@ namespace iter {
 
             class Iterator {
                 private:
-                    Container& container;
+                    using Permutable =
+                        std::vector<collection_item_type<Container>>;
+                    Permutable working_set;
                     bool is_not_last = true;
 
                 public:
                     Iterator(Container& c)
-                        : container(c) 
+                        : working_set{std::begin(c), std::end(c)}
                     { }
 
-                    Container& operator*() {
-                        return container;
+                    Permutable& operator*() {
+                        return working_set;
                     }
 
                     Iterator& operator++() {
                         is_not_last =
-                            std::next_permutation(std::begin(container),
-                                    std::end(container));
+                            std::next_permutation(std::begin(working_set),
+                                    std::end(working_set));
                         return *this;
                     }
 
                     bool operator!=(const Iterator&) const {
                         return is_not_last;
                     }
-
             };
 
             Iterator begin() {
@@ -63,8 +66,8 @@ namespace iter {
     // NOTE unlike other itertools, this one copies the input container
     // rather than taking a universal ref
     template <typename Container>
-    Permuter<Container> permutations(const Container& container) {
-        return {container};
+    Permuter<Container> permutations(Container&& container) {
+        return {std::forward<Container>(container)};
     }
 
     //since initializer_list doesn't have bidir iters this is a hack

From 9bf7264442780b1f7b11391d92756cef852aac7a Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 9 Sep 2014 21:15:45 -0400
Subject: [PATCH 0496/1866] adds DerefByValueFancy with random access iterator

(it's just a pointer)
---
 tests/samples.hpp | 18 +++++++++++++++++-
 1 file changed, 17 insertions(+), 1 deletion(-)

diff --git a/tests/samples.hpp b/tests/samples.hpp
index c23fa024..820d2c1e 100644
--- a/tests/samples.hpp
+++ b/tests/samples.hpp
@@ -41,7 +41,7 @@ namespace itertest {
     class DerefByValue {
         private:
             static constexpr std::size_t N = 3;
-            int array[N] = {0};
+            int array[N] = {0, 1, 2};
         public:
             DerefByValue() = default;
 
@@ -78,5 +78,21 @@ namespace itertest {
                 return {this->array + N};
             }
     };
+
+    class DerefByValueFancy {
+        private:
+            static constexpr std::size_t N = 3;
+            int array[N] = {0, 1, 2};
+        public:
+            DerefByValueFancy() = default;
+
+            int *begin() {
+                return this->array;
+            }
+
+            int *end() {
+                return this->array + N;
+            }
+    };
 }
 #endif // #ifndef ITERTOOLS_SAMPLE_CLASSES_HPP

From 1004ebfb92323e29c82f1d2c3b97cec87658b99f Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 9 Sep 2014 21:16:24 -0400
Subject: [PATCH 0497/1866] adds test with deref-by-value fancy

---
 tests/testpermutations.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/tests/testpermutations.cpp b/tests/testpermutations.cpp
index bac92ae3..0e9b7a06 100644
--- a/tests/testpermutations.cpp
+++ b/tests/testpermutations.cpp
@@ -50,4 +50,10 @@ int main() {
         for (auto i : v) std::cout << i << " ";
         std::cout << std::endl;
     }
+
+    itertest::DerefByValueFancy dbv;
+    for (auto v : permutations(dbv)) {
+        for (auto i : v) std::cout << i << " ";
+        std::cout << std::endl;
+    }
 }

From 953b33c8fae7f701675150f599e4721e82692f93 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 9 Sep 2014 21:20:19 -0400
Subject: [PATCH 0498/1866] make permutations work more expectedly

instead of always copying, it works like the other itertools. Only the
vector of collection_item_types is sorted, rather than the container
itself. Additionally, there need not be any strange behavior for
initializer_lists anymore.
---
 permutations.hpp | 27 +++++++++++----------------
 1 file changed, 11 insertions(+), 16 deletions(-)

diff --git a/permutations.hpp b/permutations.hpp
index d9e64a99..5b5ce4cb 100644
--- a/permutations.hpp
+++ b/permutations.hpp
@@ -1,5 +1,5 @@
-#ifndef PERMUTATIONS_HPP
-#define PERMUTATIONS_HPP
+#ifndef ITER_PERMUTATIONS_HPP_
+#define ITER_PERMUTATIONS_HPP_
 #include "iterbase.hpp"
 
 #include <algorithm>
@@ -16,13 +16,9 @@ namespace iter {
             Container container;
 
         public:
-            // always copy, never move
             Permuter(Container in_container)
                 : container(in_container)
-            {
-                    std::sort(std::begin(this->container),
-                        std::end(this->container));
-            }
+            { }
 
             class Iterator {
                 private:
@@ -34,7 +30,10 @@ namespace iter {
                 public:
                     Iterator(Container& c)
                         : working_set{std::begin(c), std::end(c)}
-                    { }
+                    {
+                        std::sort(std::begin(working_set),
+                                std::end(working_set));
+                    }
 
                     Permutable& operator*() {
                         return working_set;
@@ -63,22 +62,18 @@ namespace iter {
 
     };
 
-    // NOTE unlike other itertools, this one copies the input container
-    // rather than taking a universal ref
     template <typename Container>
     Permuter<Container> permutations(Container&& container) {
         return {std::forward<Container>(container)};
     }
 
-    //since initializer_list doesn't have bidir iters this is a hack
-    //to get it to work by using a vector in its place
     template <typename T>
-    Permuter<std::vector<T>> permutations(std::initializer_list<T> il) {
-        std::vector<T> vec = il;
-        return {std::move(vec)};
+    Permuter<std::initializer_list<T>> permutations(
+            std::initializer_list<T> il) {
+        return {il};
     }
 
 }
 
-#endif //PERMUTATIONS_HPP
+#endif // ITER_PERMUTATIONS_HPP_
 

From 86e6d66bc00859dcff44d51ddaecbcb8259cf4a0 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 9 Sep 2014 21:26:32 -0400
Subject: [PATCH 0499/1866] test with normal deref-by-value

---
 tests/testpermutations.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tests/testpermutations.cpp b/tests/testpermutations.cpp
index 0e9b7a06..a73a2a3b 100644
--- a/tests/testpermutations.cpp
+++ b/tests/testpermutations.cpp
@@ -51,7 +51,8 @@ int main() {
         std::cout << std::endl;
     }
 
-    itertest::DerefByValueFancy dbv;
+    std::cout << "with deref-by-value iterator\n";
+    itertest::DerefByValue dbv;
     for (auto v : permutations(dbv)) {
         for (auto i : v) std::cout << i << " ";
         std::cout << std::endl;

From 16774baf8576e116cb67acb0203145d5eb88ba71 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 9 Sep 2014 21:27:36 -0400
Subject: [PATCH 0500/1866] Permutations supports minimal iterator type

I knew it could be done.
---
 permutations.hpp | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/permutations.hpp b/permutations.hpp
index 5b5ce4cb..08b24ef0 100644
--- a/permutations.hpp
+++ b/permutations.hpp
@@ -29,8 +29,13 @@ namespace iter {
 
                 public:
                     Iterator(Container& c)
-                        : working_set{std::begin(c), std::end(c)}
                     {
+                        // done like this instead of using vector ctor with
+                        // two iterators because that causes a substitution
+                        // failure when the iterator is minimal
+                        for (auto&& i : c) {
+                            working_set.emplace_back(i);
+                        }
                         std::sort(std::begin(working_set),
                                 std::end(working_set));
                     }

From 8fae67b7448cdc59f72cc454a4655dbb0a423777 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 22 Sep 2014 18:55:21 -0400
Subject: [PATCH 0501/1866] tests producte with range()es

---
 tests/testproduct.cpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/tests/testproduct.cpp b/tests/testproduct.cpp
index 4af55226..22d132ec 100644
--- a/tests/testproduct.cpp
+++ b/tests/testproduct.cpp
@@ -68,6 +68,10 @@ int main() {
         std::cout << std::get<0>(t) << ", "
             << std::get<1>(t) << std::endl;
     }
+    std::cout << '\n';
+    for (auto&& ij: iter::product(iter::range(10), iter::range(5))) {
+        std::cout << std::get<0>(ij) << "," << std::get<1>(ij) << std::endl;
+    }
 
     return 0;
 }

From 0063f019d1702cfe02f9b1d85cfd3e4157cc5628 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 22 Sep 2014 18:55:27 -0400
Subject: [PATCH 0502/1866] removes const qualifier on step

it doesn't really help anything, and prevents the range iterators
from being assignable.
---
 range.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/range.hpp b/range.hpp
index 5359379c..53752a3f 100644
--- a/range.hpp
+++ b/range.hpp
@@ -66,7 +66,7 @@ namespace iter {
             class Iterator {
                 private:
                     T value;
-                    const T step;
+                    T step;
 
                     // compare unsigned values
                     bool not_equal_to(

From c7e2fc15d4838821752d9f37f52f860054733509 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 23 Sep 2014 21:59:55 -0400
Subject: [PATCH 0503/1866] Adds test with const deref of product

---
 tests/testcommand_chains.cpp | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/tests/testcommand_chains.cpp b/tests/testcommand_chains.cpp
index 6c5e44c2..137bc0b2 100644
--- a/tests/testcommand_chains.cpp
+++ b/tests/testcommand_chains.cpp
@@ -66,5 +66,13 @@ int main() {
         }
     }
 #endif
+    auto prod_range = iter::product(iter::range(10), iter::range(5));
+
+    for (auto&& ij: iter::filter(
+                [](std::tuple<unsigned, unsigned> const& c)
+                {return std::get<0>(c) >= std::get<1>(c);},
+                prod_range)) {
+                    std::cout << std::get<0>(ij) << "," << std::get<1>(ij) << std::endl;
+    }
     return 0;
 }

From d0438877e6998a829dcd03619189de602ce3b371 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 23 Sep 2014 22:01:14 -0400
Subject: [PATCH 0504/1866] const correctness for product operator*

---
 product.hpp | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/product.hpp b/product.hpp
index 07bd8849..40887e64 100644
--- a/product.hpp
+++ b/product.hpp
@@ -87,6 +87,17 @@ namespace iter {
                                     *this->iter},
                                 *this->rest_iter);
                     }
+                    auto operator*() const ->
+                        decltype(std::tuple_cat(
+                                    std::tuple<const iterator_deref<Container>>{
+                                        *this->iter},
+                                    *this->rest_iter))
+                    {
+                        return std::tuple_cat(
+                                std::tuple<const iterator_deref<Container>>{
+                                    *this->iter},
+                                *this->rest_iter);
+                    }
             };
 
             Iterator begin() {
@@ -125,7 +136,7 @@ namespace iter {
                         return false;
                     }
 
-                    std::tuple<> operator*() {
+                    std::tuple<> operator*() const {
                         return std::tuple<>{};
                     }
             };

From 967c0d4bf5a7ca99a1d55ee137d8d5d96f666bc5 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 25 Sep 2014 00:05:05 -0400
Subject: [PATCH 0505/1866] removes extra const in filter

---
 filter.hpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/filter.hpp b/filter.hpp
index d8986128..50871be9 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -1,5 +1,5 @@
-#ifndef FILTER__H__
-#define FILTER__H__
+#ifndef ITER_FILTER_H_
+#define ITER_FILTER_H_
 
 #include "iterbase.hpp"
 
@@ -71,7 +71,7 @@ namespace iter {
                         this->skip_failures();
                     } 
 
-                    iterator_deref<Container> operator*() const {
+                    iterator_deref<Container> operator*() {
                         return *this->sub_iter;
                     }
 
@@ -154,4 +154,4 @@ namespace iter {
 
 }
 
-#endif //ifndef FILTER__H__
+#endif // #ifndef ITER_FILTER_H_

From 4b5e9a86430b234f32de947a687d7164fb907bcb Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 25 Sep 2014 00:06:47 -0400
Subject: [PATCH 0506/1866] removes const product operator*

shouldn't have had it it in the first place, it was masking
the real issue, in filter
---
 product.hpp | 11 -----------
 1 file changed, 11 deletions(-)

diff --git a/product.hpp b/product.hpp
index 40887e64..4b14353d 100644
--- a/product.hpp
+++ b/product.hpp
@@ -87,17 +87,6 @@ namespace iter {
                                     *this->iter},
                                 *this->rest_iter);
                     }
-                    auto operator*() const ->
-                        decltype(std::tuple_cat(
-                                    std::tuple<const iterator_deref<Container>>{
-                                        *this->iter},
-                                    *this->rest_iter))
-                    {
-                        return std::tuple_cat(
-                                std::tuple<const iterator_deref<Container>>{
-                                    *this->iter},
-                                *this->rest_iter);
-                    }
             };
 
             Iterator begin() {

From 31872b1b8796362c89b34658128ca82c13cd2521 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 25 Sep 2014 00:11:49 -0400
Subject: [PATCH 0507/1866] fixes include macro

---
 enumerate.hpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index 15fd605d..52ee3db5 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -1,5 +1,5 @@
-#ifndef ENUMERABLE__H__
-#define ENUMERABLE__H__
+#ifndef ITER_ENUMERATE_H_
+#define ITER_ENUMERATE_H_
 
 #include "iterbase.hpp"
 
@@ -113,4 +113,4 @@ namespace iter {
     }
 }
 
-#endif //ifndef ENUMERABLE__H__
+#endif //#ifndef ITER_ENUMERATE_H_

From fce71b6e7623b29349f9a6be2ffd82167b73c887 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 28 Sep 2014 20:41:00 -0400
Subject: [PATCH 0508/1866] uses -std=c++14 in SConstruct

---
 tests/SConstruct | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/SConstruct b/tests/SConstruct
index eb1c70a7..7a4abeec 100644
--- a/tests/SConstruct
+++ b/tests/SConstruct
@@ -4,7 +4,7 @@ import os
 env = Environment(
     CXX='c++',
     CXXFLAGS= ['-g', '-Wall', '-Wextra',
-               '-pedantic', '-std=c++11',
+               '-pedantic', '-std=c++14',
                 '-fdiagnostics-color=always',
                '-I/usr/local/include'],
     CPPPATH='..',

From 84d382bda543af17f30371ca53cc5a3730dace8e Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 28 Sep 2014 20:41:07 -0400
Subject: [PATCH 0509/1866] Flattens zip implementation

No recursive template. Using std::index_sequence everywhere now.
---
 zip.hpp | 137 ++++++++++++++++++++++++--------------------------------
 1 file changed, 58 insertions(+), 79 deletions(-)

diff --git a/zip.hpp b/zip.hpp
index 08d2ec1a..d5066b7a 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -6,9 +6,14 @@
 #include <iterator>
 #include <tuple>
 #include <utility>
+#include <algorithm>
 
 
 namespace iter {
+
+    template <typename... Ts>
+    void absorb(Ts&&...) { }
+
     template <typename... RestContainers>
     class Zipped;
 
@@ -16,114 +21,88 @@ namespace iter {
     Zipped<Containers...> zip(Containers&&...);
 
     // specialization for at least 1 template argument
-    template <typename Container, typename... RestContainers>
-    class Zipped <Container, RestContainers...> {
-        static_assert(!std::is_rvalue_reference<Container>::value,
-                "Itertools cannot be templated with rvalue references");
-
-        friend Zipped zip<Container, RestContainers...>(
-                Container&&, RestContainers&&...);
-
-        template <typename... RC>
-        friend class Zipped;
-
+    template <typename... Containers>
+    class Zipped {
         private:
-            Container container;
-            Zipped<RestContainers...> rest_zipped;
-            Zipped(Container container, RestContainers&&... rest)
-                : container(std::forward<Container>(container)),
-                rest_zipped{std::forward<RestContainers>(rest)...}
+            std::tuple<Containers...> containers;
+            std::make_index_sequence<sizeof...(Containers)> indices;
+            
+        public:
+            Zipped(Containers... in_containers)
+                : containers{std::forward<Containers>(in_containers)...}
             { }
 
-        public:
             class Iterator {
                 private:
-                    using RestIter =
-                        typename Zipped<RestContainers...>::Iterator;
+                    std::tuple<iterator_type<Containers>...> iters;
+                    std::make_index_sequence<sizeof...(Containers)> indices;
+
+                    template <std::size_t... Is>
+                    bool not_equal(const Iterator& other,
+                                   std::index_sequence<Is...>) const {
+                        if (sizeof...(Is) == 0) {
+                            // empty zip() case, return false right away
+                            return false;
+                        }
+                        bool results[] = { true,
+                            (std::get<Is>(this->iters) !=
+                             std::get<Is>(other.iters))...
+                        };
+                        return std::all_of(
+                                std::begin(results), std::end(results),
+                                [](bool b){ return b; } );
+                    }
+
+                    template <std::size_t... Is>
+                    void increment(std::index_sequence<Is...>) {
+                        absorb(++std::get<Is>(this->iters)...);
+                    }
+
+                    template <std::size_t... Is>
+                    auto deref(std::index_sequence<Is...>) {
+                        return std::tuple<iterator_deref<Containers>...>{
+                            (*std::get<Is>(this->iters))...};
+                    }
 
-                    iterator_type<Container> iter;
-                    RestIter rest_iter;
                 public:
-                    constexpr static const bool is_base_iter = false;
-                    Iterator(iterator_type<Container> it, const RestIter& rest)
-                        : iter{it},
-                        rest_iter{rest}
+                    Iterator(iterator_type<Containers>... its)
+                        : iters{its...}
                     { }
 
                     Iterator& operator++() {
-                        ++this->iter;
-                        ++this->rest_iter;
+                        this->increment(this->indices);
                         return *this;
                     }
 
                     bool operator!=(const Iterator& other) const {
-                        return this->iter != other.iter &&
-                            (RestIter::is_base_iter ||
-                                this->rest_iter != other.rest_iter);
+                        return this->not_equal(other, this->indices);
                     }
 
-                    auto operator*() ->
-                        decltype(std::tuple_cat(
-                                    std::tuple<iterator_deref<Container>>{
-                                        *this->iter},
-                                    *this->rest_iter))
-                    {
-                        return std::tuple_cat(
-                                std::tuple<iterator_deref<Container>>{
-                                    *this->iter},
-                                *this->rest_iter);
+                    auto operator*() {
+                        return this->deref(this->indices);
                     }
             };
-
-            Iterator begin() {
-                return {std::begin(this->container),
-                    std::begin(this->rest_zipped)};
+        private:
+            template <std::size_t... Is>
+            Iterator make_begin(std::index_sequence<Is...>) {
+                return {std::begin(std::get<Is>(this->containers))...};
             }
 
-            Iterator end() {
-                return {std::end(this->container),
-                    std::end(this->rest_zipped)};
+            template <std::size_t... Is>
+            Iterator make_end(std::index_sequence<Is...>) {
+                return {std::end(std::get<Is>(this->containers))...};
             }
-    };
 
-
-    template <>
-    class Zipped<> {
         public:
-            class Iterator {
-                public:
-                    constexpr static const bool is_base_iter = true;
-
-                    Iterator() { }
-                    Iterator(const Iterator&) { }
-                    Iterator& operator=(const Iterator&) { return *this; }
-
-                    Iterator& operator++() {
-                        return *this;
-                    }
-
-                    // if this were to return true, there would be no need
-                    // for the is_base_iter static class attribute.
-                    // However, returning false causes an empty zip() call
-                    // to reach the "end" immediately. Returning true here
-                    // instead results in an infinite loop in the zip() case
-                    bool operator!=(const Iterator&) const {
-                        return false;
-                    }
-
-                    std::tuple<> operator*() {
-                        return std::tuple<>{};
-                    }
-            };
 
             Iterator begin() {
-                return {};
+                return this->make_begin(this->indices);
             }
 
             Iterator end() {
-                return {};
+                return this->make_end(this->indices);
             }
-    };
+        };
 
     template <typename... Containers>
     Zipped<Containers...> zip(Containers&&... containers) {

From 528836d57f2485b2857e18ba75cf449e40cdb34b Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 28 Sep 2014 22:20:06 -0400
Subject: [PATCH 0510/1866] replaces empty zip if check with overload

---
 zip.hpp | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/zip.hpp b/zip.hpp
index d5066b7a..1a449dac 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -37,13 +37,14 @@ namespace iter {
                     std::tuple<iterator_type<Containers>...> iters;
                     std::make_index_sequence<sizeof...(Containers)> indices;
 
+                    bool not_equal(
+                            const Iterator&, std::index_sequence<>) const {
+                        return false;
+                    }
+
                     template <std::size_t... Is>
                     bool not_equal(const Iterator& other,
                                    std::index_sequence<Is...>) const {
-                        if (sizeof...(Is) == 0) {
-                            // empty zip() case, return false right away
-                            return false;
-                        }
                         bool results[] = { true,
                             (std::get<Is>(this->iters) !=
                              std::get<Is>(other.iters))...

From f7b5c3028321bd73338c525b6312b2d61614d1cc Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 29 Sep 2014 00:32:57 -0400
Subject: [PATCH 0511/1866] Simplifies by templating on tuple and Is

rather than repeating the deduction all over the place.
---
 zip.hpp | 103 +++++++++++++++++++++++++-------------------------------
 1 file changed, 45 insertions(+), 58 deletions(-)

diff --git a/zip.hpp b/zip.hpp
index 1a449dac..cc8c58ab 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -8,106 +8,93 @@
 #include <utility>
 #include <algorithm>
 
-
 namespace iter {
 
     template <typename... Ts>
     void absorb(Ts&&...) { }
 
+#if 0
     template <typename... RestContainers>
     class Zipped;
 
     template <typename... Containers>
     Zipped<Containers...> zip(Containers&&...);
+#endif
 
     // specialization for at least 1 template argument
-    template <typename... Containers>
+    template <typename TupType, std::size_t... Is>
     class Zipped {
         private:
-            std::tuple<Containers...> containers;
-            std::make_index_sequence<sizeof...(Containers)> indices;
-            
+            TupType containers;
+            using iters_tuple =
+                std::tuple<iterator_type<decltype(
+                        std::get<Is>(std::declval<TupType>()))>...>;
         public:
-            Zipped(Containers... in_containers)
-                : containers{std::forward<Containers>(in_containers)...}
+            Zipped(TupType&& in_containers)
+                : containers(std::move(in_containers))
             { }
 
             class Iterator {
                 private:
-                    std::tuple<iterator_type<Containers>...> iters;
-                    std::make_index_sequence<sizeof...(Containers)> indices;
+                    using iters_tuple =
+                        std::tuple<iterator_type<decltype(
+                                std::get<Is>(std::declval<TupType>()))>...>;
+                    using iters_deref_tuple =
+                        std::tuple<iterator_deref<decltype(
+                                std::get<Is>(std::declval<TupType>()))>...>;
 
-                    bool not_equal(
-                            const Iterator&, std::index_sequence<>) const {
-                        return false;
-                    }
-
-                    template <std::size_t... Is>
-                    bool not_equal(const Iterator& other,
-                                   std::index_sequence<Is...>) const {
-                        bool results[] = { true,
-                            (std::get<Is>(this->iters) !=
-                             std::get<Is>(other.iters))...
-                        };
-                        return std::all_of(
-                                std::begin(results), std::end(results),
-                                [](bool b){ return b; } );
-                    }
-
-                    template <std::size_t... Is>
-                    void increment(std::index_sequence<Is...>) {
-                        absorb(++std::get<Is>(this->iters)...);
-                    }
-
-                    template <std::size_t... Is>
-                    auto deref(std::index_sequence<Is...>) {
-                        return std::tuple<iterator_deref<Containers>...>{
-                            (*std::get<Is>(this->iters))...};
-                    }
+                    iters_tuple iters;
 
                 public:
-                    Iterator(iterator_type<Containers>... its)
-                        : iters{its...}
+                    Iterator(iters_tuple&& its)
+                        : iters(std::move(its))
                     { }
 
                     Iterator& operator++() {
-                        this->increment(this->indices);
+                        absorb(++std::get<Is>(this->iters)...);
                         return *this;
                     }
 
                     bool operator!=(const Iterator& other) const {
-                        return this->not_equal(other, this->indices);
+                        if (sizeof...(Is) == 0) return false;
+
+                        bool results[] = { true,
+                            (std::get<Is>(this->iters) !=
+                                 std::get<Is>(other.iters))...
+                        };
+                        return std::all_of(
+                                std::begin(results), std::end(results),
+                                [](bool b){ return b; } );
                     }
 
                     auto operator*() {
-                        return this->deref(this->indices);
+                        return iters_deref_tuple{
+                            (*std::get<Is>(this->iters))...};
                     }
             };
-        private:
-            template <std::size_t... Is>
-            Iterator make_begin(std::index_sequence<Is...>) {
-                return {std::begin(std::get<Is>(this->containers))...};
-            }
-
-            template <std::size_t... Is>
-            Iterator make_end(std::index_sequence<Is...>) {
-                return {std::end(std::get<Is>(this->containers))...};
-            }
-
-        public:
 
             Iterator begin() {
-                return this->make_begin(this->indices);
+                return iters_tuple{
+                    std::begin(std::get<Is>(this->containers))...};
             }
 
             Iterator end() {
-                return this->make_end(this->indices);
+                return iters_tuple{
+                    std::end(std::get<Is>(this->containers))...};
             }
-        };
+    };
+
+    template <typename TupType, std::size_t... Is>
+    Zipped<TupType, Is...> zip_impl(
+            TupType&& in_containers, std::index_sequence<Is...>) {
+        return {std::move(in_containers)};
+    }
 
     template <typename... Containers>
-    Zipped<Containers...> zip(Containers&&... containers) {
-        return {std::forward<Containers>(containers)...};
+    auto zip(Containers&&... containers) {
+        return zip_impl(std::tuple<Containers...>{
+            std::forward<Containers>(containers)...},
+            std::index_sequence_for<Containers...>{});
     }
 }
 

From 77fc126990b5b7bcebab9009103990c6f3938a7b Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 29 Sep 2014 20:42:00 -0400
Subject: [PATCH 0512/1866] makes Zipped constructor private again

---
 zip.hpp | 33 ++++++++++++++++-----------------
 1 file changed, 16 insertions(+), 17 deletions(-)

diff --git a/zip.hpp b/zip.hpp
index cc8c58ab..fb49ecac 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -13,36 +13,35 @@ namespace iter {
     template <typename... Ts>
     void absorb(Ts&&...) { }
 
-#if 0
-    template <typename... RestContainers>
+    template <typename TupleType, std::size_t... Is>
     class Zipped;
 
-    template <typename... Containers>
-    Zipped<Containers...> zip(Containers&&...);
-#endif
+    template <typename TupleType, std::size_t... Is>
+    Zipped<TupleType, Is...> zip_impl(TupleType&&, std::index_sequence<Is...>);
 
-    // specialization for at least 1 template argument
-    template <typename TupType, std::size_t... Is>
+    template <typename TupleType, std::size_t... Is>
     class Zipped {
         private:
-            TupType containers;
+            TupleType containers;
             using iters_tuple =
                 std::tuple<iterator_type<decltype(
-                        std::get<Is>(std::declval<TupType>()))>...>;
-        public:
-            Zipped(TupType&& in_containers)
+                        std::get<Is>(std::declval<TupleType>()))>...>;
+            friend Zipped zip_impl<TupleType, Is...>(
+                    TupleType&&, std::index_sequence<Is...>);
+
+            Zipped(TupleType&& in_containers)
                 : containers(std::move(in_containers))
             { }
+        public:
 
             class Iterator {
                 private:
                     using iters_tuple =
                         std::tuple<iterator_type<decltype(
-                                std::get<Is>(std::declval<TupType>()))>...>;
+                                std::get<Is>(std::declval<TupleType>()))>...>;
                     using iters_deref_tuple =
                         std::tuple<iterator_deref<decltype(
-                                std::get<Is>(std::declval<TupType>()))>...>;
-
+                                std::get<Is>(std::declval<TupleType>()))>...>;
                     iters_tuple iters;
 
                 public:
@@ -84,9 +83,9 @@ namespace iter {
             }
     };
 
-    template <typename TupType, std::size_t... Is>
-    Zipped<TupType, Is...> zip_impl(
-            TupType&& in_containers, std::index_sequence<Is...>) {
+    template <typename TupleType, std::size_t... Is>
+    Zipped<TupleType, Is...> zip_impl(
+            TupleType&& in_containers, std::index_sequence<Is...>) {
         return {std::move(in_containers)};
     }
 

From dee21e2f69b5713246d86159284312d50d8fb119 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 29 Sep 2014 21:16:15 -0400
Subject: [PATCH 0513/1866] refactors type aliases

---
 iterbase.hpp | 34 ++++++++++++++++++++++++++++++++++
 zip.hpp      | 26 +++++++-------------------
 2 files changed, 41 insertions(+), 19 deletions(-)

diff --git a/iterbase.hpp b/iterbase.hpp
index 15f0a0a0..63bd142c 100644
--- a/iterbase.hpp
+++ b/iterbase.hpp
@@ -9,6 +9,7 @@
 // this file directly.
 
 #include <utility>
+#include <tuple>
 #include <iterator>
 #include <functional>
 #include <cstddef>
@@ -79,6 +80,39 @@ namespace iter {
         typename std::remove_const<
             iterator_deref<Container>>::type>::type;
 
+
+    namespace detail {
+        template <typename... Ts>
+        std::tuple<iterator_type<Ts>...> iterator_tuple_type_helper(
+                const std::tuple<Ts...>&);
+    }
+    // Given a tuple template argument, evaluates to a tuple of iterators
+    // for the template argument's contained types.
+    template <typename TupleType>
+    using iterator_tuple_type =
+        decltype(detail::iterator_tuple_type_helper(
+                    std::declval<TupleType>()));
+
+    namespace detail {
+        template <typename... Ts>
+        std::tuple<iterator_deref<Ts>...> iterator_tuple_deref_helper(
+                const std::tuple<Ts...>&);
+    }
+
+    // Given a tuple template argument, evaluates to a tuple of
+    // what the iterators for the template argument's contained types
+    // dereference to
+    template <typename TupleType>
+    using iterator_deref_tuple =
+        decltype(detail::iterator_tuple_deref_helper(
+                    std::declval<TupleType>()));
+
+    // function absorbing all arguments passed to it. used when
+    // applying a function to a parameter pack but not passing the evaluated
+    // results anywhere
+    template <typename... Ts>
+    void absorb(Ts&&...) { }
+
 }
 
 #endif // #ifndef ITERBASE_HPP_
diff --git a/zip.hpp b/zip.hpp
index fb49ecac..f8622553 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -10,9 +10,6 @@
 
 namespace iter {
 
-    template <typename... Ts>
-    void absorb(Ts&&...) { }
-
     template <typename TupleType, std::size_t... Is>
     class Zipped;
 
@@ -23,9 +20,6 @@ namespace iter {
     class Zipped {
         private:
             TupleType containers;
-            using iters_tuple =
-                std::tuple<iterator_type<decltype(
-                        std::get<Is>(std::declval<TupleType>()))>...>;
             friend Zipped zip_impl<TupleType, Is...>(
                     TupleType&&, std::index_sequence<Is...>);
 
@@ -36,16 +30,10 @@ namespace iter {
 
             class Iterator {
                 private:
-                    using iters_tuple =
-                        std::tuple<iterator_type<decltype(
-                                std::get<Is>(std::declval<TupleType>()))>...>;
-                    using iters_deref_tuple =
-                        std::tuple<iterator_deref<decltype(
-                                std::get<Is>(std::declval<TupleType>()))>...>;
-                    iters_tuple iters;
+                    iterator_tuple_type<TupleType> iters;
 
                 public:
-                    Iterator(iters_tuple&& its)
+                    Iterator(iterator_tuple_type<TupleType>&& its)
                         : iters(std::move(its))
                     { }
 
@@ -67,19 +55,19 @@ namespace iter {
                     }
 
                     auto operator*() {
-                        return iters_deref_tuple{
+                        return iterator_deref_tuple<TupleType>{
                             (*std::get<Is>(this->iters))...};
                     }
             };
 
             Iterator begin() {
-                return iters_tuple{
-                    std::begin(std::get<Is>(this->containers))...};
+                return {iterator_tuple_type<TupleType>{
+                    std::begin(std::get<Is>(this->containers))...}};
             }
 
             Iterator end() {
-                return iters_tuple{
-                    std::end(std::get<Is>(this->containers))...};
+                return {iterator_tuple_type<TupleType>{
+                    std::end(std::get<Is>(this->containers))...}};
             }
     };
 

From 14aec8013a0fae127ece1efcf35a63e74b0ee6df Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 29 Sep 2014 21:20:40 -0400
Subject: [PATCH 0514/1866] makes imap infer Zipped type

---
 imap.hpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/imap.hpp b/imap.hpp
index ad00a193..74e316a7 100644
--- a/imap.hpp
+++ b/imap.hpp
@@ -73,10 +73,11 @@ namespace iter {
         // The imap function is the only thing allowed to create a IMap
         friend IMap imap<MapFunc, Containers...>(MapFunc, Containers&& ...);
 
-        using ZippedIterType = iterator_type<Zipped<Containers...>>;
+        using ZippedType = decltype(zip(std::declval<Containers>()...));
+        using ZippedIterType = iterator_type<ZippedType>;
         private:
             MapFunc map_func;
-            Zipped<Containers...> zipped;
+            ZippedType zipped;
             
             // Value constructor for use only in the imap function
             IMap(MapFunc map_func, Containers&& ... containers) :

From dc7fcd67a40cc9b6ec2464175b8d24ecdb946f97 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 29 Sep 2014 21:21:21 -0400
Subject: [PATCH 0515/1866] removes mutable (idk why it was ever there)

---
 imap.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/imap.hpp b/imap.hpp
index 74e316a7..2418b149 100644
--- a/imap.hpp
+++ b/imap.hpp
@@ -94,7 +94,7 @@ namespace iter {
             class Iterator {
                 private:
                     MapFunc map_func;
-                    mutable ZippedIterType zipiter;
+                    ZippedIterType zipiter;
 
                 public:
                     Iterator(MapFunc map_func, ZippedIterType zipiter) :

From 90985204a348c843c6d8d3ef6002bc450acf2e77 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 29 Sep 2014 21:21:21 -0400
Subject: [PATCH 0516/1866] removes mutable (idk why it was ever there)

---
 imap.hpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/imap.hpp b/imap.hpp
index 74e316a7..fd6f0ecc 100644
--- a/imap.hpp
+++ b/imap.hpp
@@ -1,5 +1,5 @@
-#ifndef IMAP__H__
-#define IMAP__H__
+#ifndef ITER_IMAP_H_
+#define ITER_IMAP_H_
 
 #include "zip.hpp"
 
@@ -94,7 +94,7 @@ namespace iter {
             class Iterator {
                 private:
                     MapFunc map_func;
-                    mutable ZippedIterType zipiter;
+                    ZippedIterType zipiter;
 
                 public:
                     Iterator(MapFunc map_func, ZippedIterType zipiter) :
@@ -139,4 +139,4 @@ namespace iter {
 
 }
 
-#endif //ifndef IMAP__H__
+#endif // #ifndef ITER_IMAP_H_

From fb8feb024ce2d5746a7c0414ac211e89f577c56f Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 29 Sep 2014 21:26:26 -0400
Subject: [PATCH 0517/1866] silences unused variable warnings

---
 tests/testcommand_chains.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/testcommand_chains.cpp b/tests/testcommand_chains.cpp
index 137bc0b2..e116f131 100644
--- a/tests/testcommand_chains.cpp
+++ b/tests/testcommand_chains.cpp
@@ -31,8 +31,8 @@ int main() {
 
     std::string str = "hello world";
     std::vector<int> vec = {6, 9, 6, 9};
-    for (auto p : enumerate(enumerate(str))) { }
-    for (auto p : enumerate(zip(str, vec))) { }
+    for (auto p : enumerate(enumerate(str))) { (void)p; }
+    for (auto p : enumerate(zip(str, vec))) { (void)p; }
 
     std::cout << std::endl;
     {

From 034681307b09c4dd74282dd8428378dbdc2c3f89 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 29 Sep 2014 23:12:05 -0400
Subject: [PATCH 0518/1866] Cuts down unique_justseen with a lambda

This was my original intention, but since lambdas can't appear in an
unevaluated context, it didn't work with a trailing return type. With an
inferred return type, however, it's fine.
---
 unique_justseen.hpp | 48 ++++++++++++---------------------------------
 1 file changed, 13 insertions(+), 35 deletions(-)

diff --git a/unique_justseen.hpp b/unique_justseen.hpp
index eaf81747..366e747e 100644
--- a/unique_justseen.hpp
+++ b/unique_justseen.hpp
@@ -1,7 +1,6 @@
-#ifndef UNIQUE_JUSTSEEN_HPP
-#define UNIQUE_JUSTSEEN_HPP
+#ifndef ITER_UNIQUE_JUSTSEEN_H_
+#define ITER_UNIQUE_JUSTSEEN_H_
 
-#include "iterbase.hpp"
 #include "groupby.hpp"
 #include "imap.hpp"
 
@@ -9,44 +8,23 @@
 #include <iterator>
 #include <initializer_list>
 
-namespace iter 
-{
-    template <typename GroupByType>
-    struct GroupFrontGetter{
-        auto operator()(iterator_deref<GroupByType>&& gb) ->
-                decltype(*std::begin(gb.second)) {
-            return *std::begin(gb.second);
-        }
+namespace iter {
 
-        auto operator()(iterator_deref<GroupByType>& gb) ->
-                decltype(*std::begin(gb.second)) {
-            return *std::begin(gb.second);
-        }
-    };
-
-
-    // gets first of each group.  since each group is decided based on equality
-    // with the previous item, this results in each item only appearing once
     template <typename Container>
-    auto unique_justseen(Container&& container) ->
-        decltype(imap(GroupFrontGetter<decltype(
-                        groupby(std::forward<Container>(container)))>{},
-                groupby(std::forward<Container>(container)))) {
-        return imap(GroupFrontGetter<decltype(
-                    groupby(std::forward<Container>(container)))>{},
+    auto unique_justseen(Container&& container) {
+        // explicit return type in lambda so reference types are preserved
+        return imap([] (auto&& group) -> iterator_deref<Container> {
+                    return *std::begin(group.second); },
                 groupby(std::forward<Container>(container)));
     }
 
     template <typename T>
-    auto unique_justseen(std::initializer_list<T> il) ->
-        decltype(imap(GroupFrontGetter<decltype(
-                        groupby(std::forward<std::initializer_list<T>>(il)))>{},
-                groupby(std::forward<std::initializer_list<T>>(il)))) {
-        return imap(GroupFrontGetter<decltype(
-                    groupby(std::forward<std::initializer_list<T>>(il)))>{},
-                groupby(std::forward<std::initializer_list<T>>(il)));
+    auto unique_justseen(std::initializer_list<T> il) {
+        return imap(
+                [](auto&& group) -> iterator_deref<std::initializer_list<T>> {
+                    return *std::begin(group.second); },
+                groupby(il));
     }
 }
-
-#endif //UNIQUE_JUSTSEEN_HPP
     
+#endif // #ifndef ITER_UNIQUE_JUSTSEEN_H_

From 3ddb6bd9a532a19c9f4572753c55ec437ce489d0 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 12 Oct 2014 19:11:10 -0400
Subject: [PATCH 0519/1866] smarter implementation of reversed() for arrays

---
 reversed.hpp | 47 +++++++++--------------------------------------
 1 file changed, 9 insertions(+), 38 deletions(-)

diff --git a/reversed.hpp b/reversed.hpp
index 0cd836e1..dd7a0cc2 100644
--- a/reversed.hpp
+++ b/reversed.hpp
@@ -1,5 +1,5 @@
-#ifndef REVERSE_HPP__
-#define REVERSE_HPP__
+#ifndef ITER_REVERSE_HPP_
+#define ITER_REVERSE_HPP_
 
 #include "iterbase.hpp"
 
@@ -7,7 +7,6 @@
 #include <iterator>
 
 namespace iter {
-    //Forward declarations of Reverser and reversed
     template <typename Container>
     class Reverser;
 
@@ -19,11 +18,8 @@ namespace iter {
     class Reverser {
         private:
             Container container;
-            // The reversed function is the only thing allowed to create a
-            // Reverser
             friend Reverser reversed<Container>(Container&&);
             
-            // Value constructor for use only in the reversed function
             Reverser(Container container)
                 : container(std::forward<Container>(container))
             { }
@@ -70,10 +66,8 @@ namespace iter {
         return {std::forward<Container>(container)};
     }
 
-    //
     //
     // specialization for statically allocated arrays
-    // this involves some tricks
     //
     template <typename T, std::size_t N>
     Reverser<T[N]> reversed(T (&)[N]);
@@ -98,34 +92,17 @@ namespace iter {
             class Iterator {
                 private:
                     T *sub_iter;
-                    T *stop;
-                    T *dummy_end;
                 public:
-                    // iter should be the last element in the array
-                    // stop should be the first element
-                    // dummy should be what iter is set to when complete
-                    //    the implementation below sets the dummy to one-past-
-                    //    the end, since that's the only non-nullptr value that
-                    //    the pointer can be set to that is also not a part
-                    //    of the actual array
-                    Iterator (T *iter, T *stop, T *dummy)
-                        : sub_iter{iter},
-                        stop{stop},
-                        dummy_end{dummy}
+                    Iterator (T *iter)
+                        : sub_iter{iter}
                     { } 
 
                     auto operator*() -> decltype(*array) {
-                        return *this->sub_iter;
+                        return *(this->sub_iter - 1);
                     }
 
                     Iterator& operator++() { 
-                        if (this->sub_iter == this->stop) {
-                            this->sub_iter = this->dummy_end;
-                        } else {
-                            // decrementing the pointer is going forwards
-                            // in the reversed direction
-                            --this->sub_iter;
-                        }
+                        --this->sub_iter;
                         return *this;
                     }
 
@@ -134,18 +111,12 @@ namespace iter {
                     }
             };
 
-            T *dummy_end() const {
-                return this->array + N;
-            }
-
             Iterator begin() {
-                return {this->array + N - 1,
-                        this->array,
-                        this->dummy_end()};
+                return {this->array + N};
             }
 
             Iterator end() {
-            return {this->dummy_end(), this->dummy_end(), this->dummy_end()};
+            return {this->array};
             }
 
     };
@@ -157,4 +128,4 @@ namespace iter {
 
 }
 
-#endif //REVERSE_HPP__
+#endif //ITER_REVERSE_HPP_

From 327db3415b486176f7889ecd630791d54b944979 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 12 Oct 2014 19:41:08 -0400
Subject: [PATCH 0520/1866] Replaces complex call_with_tuple

With std::get<Is...> and an integer_sequence
---
 imap.hpp | 61 +++++++++-----------------------------------------------
 1 file changed, 9 insertions(+), 52 deletions(-)

diff --git a/imap.hpp b/imap.hpp
index fd6f0ecc..a88ea5fb 100644
--- a/imap.hpp
+++ b/imap.hpp
@@ -4,63 +4,23 @@
 #include "zip.hpp"
 
 #include <utility>
-#include <type_traits>
 
 namespace iter {
 
     namespace detail {
-
-    template <std::size_t Index, typename Functor, typename Tup>
-    struct Expander {
-        template <typename... Ts>
-        static auto call(Functor&& f, Tup&& tup, Ts&&... args)
-            -> decltype(Expander<Index-1, Functor, Tup>::call(
-                    std::forward<Functor>(f),
-                    std::forward<Tup>(tup),
-                    std::get<Index-1>(tup),
-                    std::forward<Ts>(args)...))
-        {
-            // recurse
-            return Expander<Index-1, Functor, Tup>::call(
-                    std::forward<Functor>(f),
-                    std::forward<Tup>(tup),
-                    std::get<Index-1>(tup), // pull out one element
-                    std::forward<Ts>(args)...); // everything already expanded
+        template <typename MapFunc, typename TupleType, std::size_t... Is>
+        auto call_with_tuple_impl(MapFunc&& mf, TupleType&& tup,
+                             std::index_sequence<Is...>) {
+            return mf(std::get<Is>(tup)...);
         }
-    };
 
-    template <typename Functor, typename Tup>
-    struct Expander<0, Functor, Tup> {
-        template <typename... Ts>
-        static auto call(Functor&& f, Tup&&, Ts&&... args)
-            -> decltype(f(std::forward<Ts>(args)...))
-        {
-            static_assert(
-                std::tuple_size<
-                    typename std::remove_reference<Tup>::type>::value
-                    == sizeof...(Ts),
-                "tuple has not been fully expanded");
-            return f(std::forward<Ts>(args)...); // the actual call
+        template <typename MapFunc, typename... Ts>
+        auto call_with_tuple(MapFunc&& mf, std::tuple<Ts...>&& tup){
+            return call_with_tuple_impl(
+                    mf, tup, std::index_sequence_for<Ts...>{});
         }
-    };
-
-    template <typename Functor, typename Tup>
-    auto call_with_tuple(Functor&& f, Tup&& tup)
-        -> decltype(Expander<std::tuple_size<
-                    typename std::remove_reference<Tup>::type>::value,
-                    Functor, Tup>::call(
-                        std::forward<Functor>(f),
-                        std::forward<Tup>(tup)))
-    {
-        return Expander<std::tuple_size<
-            typename std::remove_reference<Tup>::type>::value,
-            Functor, Tup>::call(
-                std::forward<Functor>(f),
-                std::forward<Tup>(tup));
     }
 
-    } // end detail
-
     //Forward declarations of IMap and imap
     template <typename MapFunc, typename... Containers>
     class IMap;
@@ -102,10 +62,7 @@ namespace iter {
                         zipiter(zipiter)
                     { } 
 
-                    auto operator*() -> 
-                        decltype(detail::call_with_tuple(
-                                    this->map_func, *(this->zipiter)))
-                    {
+                    auto operator*() {
                         return detail::call_with_tuple(
                                 this->map_func, *(this->zipiter));
                     }

From 2f3df24376ce6304d92ba46ce98674052f6971b1 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 15 Oct 2014 10:29:30 -0400
Subject: [PATCH 0521/1866] Moves call_with_tuple into iterbase

and makes it more flexible
---
 imap.hpp     | 16 +---------------
 iterbase.hpp | 21 +++++++++++++++++++++
 2 files changed, 22 insertions(+), 15 deletions(-)

diff --git a/imap.hpp b/imap.hpp
index a88ea5fb..38d7241a 100644
--- a/imap.hpp
+++ b/imap.hpp
@@ -7,20 +7,6 @@
 
 namespace iter {
 
-    namespace detail {
-        template <typename MapFunc, typename TupleType, std::size_t... Is>
-        auto call_with_tuple_impl(MapFunc&& mf, TupleType&& tup,
-                             std::index_sequence<Is...>) {
-            return mf(std::get<Is>(tup)...);
-        }
-
-        template <typename MapFunc, typename... Ts>
-        auto call_with_tuple(MapFunc&& mf, std::tuple<Ts...>&& tup){
-            return call_with_tuple_impl(
-                    mf, tup, std::index_sequence_for<Ts...>{});
-        }
-    }
-
     //Forward declarations of IMap and imap
     template <typename MapFunc, typename... Containers>
     class IMap;
@@ -63,7 +49,7 @@ namespace iter {
                     { } 
 
                     auto operator*() {
-                        return detail::call_with_tuple(
+                        return call_with_tuple(
                                 this->map_func, *(this->zipiter));
                     }
 
diff --git a/iterbase.hpp b/iterbase.hpp
index 63bd142c..da6e703e 100644
--- a/iterbase.hpp
+++ b/iterbase.hpp
@@ -107,12 +107,33 @@ namespace iter {
         decltype(detail::iterator_tuple_deref_helper(
                     std::declval<TupleType>()));
 
+    // ---- Tuple utilities ---- //
+    
     // function absorbing all arguments passed to it. used when
     // applying a function to a parameter pack but not passing the evaluated
     // results anywhere
     template <typename... Ts>
     void absorb(Ts&&...) { }
 
+    namespace detail {
+        template <typename Func, typename TupleType, std::size_t... Is>
+        auto call_with_tuple_impl(Func&& mf, TupleType&& tup,
+                std::index_sequence<Is...>) {
+            return mf(std::get<Is>(tup)...);
+        }
+    }
+
+    // expand a TupleType into individual arguments when calling a Func
+    template <typename Func, typename TupleType>
+    auto call_with_tuple(Func&& mf, TupleType&& tup) {
+        constexpr auto TUP_SIZE = std::tuple_size<
+            typename std::remove_reference<TupleType>::type>::value;
+        return detail::call_with_tuple_impl(
+                std::forward<Func>(mf),
+                std::forward<TupleType>(tup),
+                std::make_index_sequence<TUP_SIZE>{});
+    }
+
 }
 
 #endif // #ifndef ITERBASE_HPP_

From e23c73d54fe75e78dafb300fdefd4fa5f97a63f0 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 17 Oct 2014 14:12:29 -0400
Subject: [PATCH 0522/1866] describes purpose of c++14 branch

---
 README.md | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 7d44c246..81cd774c 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,12 @@
-CPPItertools
+CPPItertools C++14 development Branch
 ============
 
+**NOTE**: this branch is for refining and moving forward with the C++14
+standard.  It will be merged into master when compiler and library
+support for the standard approaches completion in common compilers.
+Specifically I'm considering clang and gcc, along with libstdc++
+and libc++
+
 range-based for loop add-ons inspired by the Python builtins and itertools
 library.  Like itertools and the Python3 builtins, this library uses lazy
 evaluation wherever possible.

From f3e78488bc30b0fe763d0e1a135d09d1b221e498 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 18 Oct 2014 15:10:43 -0400
Subject: [PATCH 0523/1866] relaced decay with decay_t

---
 iterbase.hpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/iterbase.hpp b/iterbase.hpp
index da6e703e..d0eade82 100644
--- a/iterbase.hpp
+++ b/iterbase.hpp
@@ -117,7 +117,7 @@ namespace iter {
 
     namespace detail {
         template <typename Func, typename TupleType, std::size_t... Is>
-        auto call_with_tuple_impl(Func&& mf, TupleType&& tup,
+        decltype(auto) call_with_tuple_impl(Func&& mf, TupleType&& tup,
                 std::index_sequence<Is...>) {
             return mf(std::get<Is>(tup)...);
         }
@@ -125,9 +125,9 @@ namespace iter {
 
     // expand a TupleType into individual arguments when calling a Func
     template <typename Func, typename TupleType>
-    auto call_with_tuple(Func&& mf, TupleType&& tup) {
+    decltype(auto) call_with_tuple(Func&& mf, TupleType&& tup) {
         constexpr auto TUP_SIZE = std::tuple_size<
-            typename std::remove_reference<TupleType>::type>::value;
+            std::decay_t<TupleType>>::value;
         return detail::call_with_tuple_impl(
                 std::forward<Func>(mf),
                 std::forward<TupleType>(tup),

From 26755551c32b956cfa40811199fbe6eee5853348 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 18 Oct 2014 17:35:09 -0400
Subject: [PATCH 0524/1866] marks operator* as decltype(auto) in imap iterator

---
 imap.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/imap.hpp b/imap.hpp
index 38d7241a..e39a468c 100644
--- a/imap.hpp
+++ b/imap.hpp
@@ -48,7 +48,7 @@ namespace iter {
                         zipiter(zipiter)
                     { } 
 
-                    auto operator*() {
+                    decltype(auto) operator*() {
                         return call_with_tuple(
                                 this->map_func, *(this->zipiter));
                     }

From c250beb3a3a63335ceedfe2b1c9e8592e80ea48b Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 18 Oct 2014 20:09:54 -0400
Subject: [PATCH 0525/1866] adds test for starmap

---
 tests/teststarmap.cpp | 75 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 75 insertions(+)
 create mode 100644 tests/teststarmap.cpp

diff --git a/tests/teststarmap.cpp b/tests/teststarmap.cpp
new file mode 100644
index 00000000..0d293abc
--- /dev/null
+++ b/tests/teststarmap.cpp
@@ -0,0 +1,75 @@
+#include <starmap.hpp>
+
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <utility>
+#include <tuple>
+#include <list>
+#include <vector>
+#include <array>
+
+using iter::starmap;
+
+double f(double d, int i) {
+    return d * i;
+}
+
+std::string g(const std::string& s, int i, double d) {
+    std::stringstream ss;
+    ss << s << ' ' << i << ' ' << d;
+    return ss.str();
+}
+
+void test_normal() {
+    std::cout << "vector<pair<double, int>>\n";
+    std::vector<std::pair<double, int>> v1 = {{1.0, 2}, {3.2, 42}, {6.9, 7}};
+    for (auto&& i : starmap(f, v1)) {
+        std::cout << i << '\n';
+    }
+    std::cout << '\n';
+
+    std::cout << "list<type<string, int, double>\n";
+    {
+        using T = std::tuple<std::string, int, double>;
+        std::list<T> li =
+            {T{"hey", 42, 6.9}, T{"there", 3, 4.0}, T{"yall", 5, 3.1}};
+        for (auto&& s : starmap(g, li)) {
+            std::cout << s << '\n';
+        }
+    }
+    std::cout << '\n';
+}
+
+struct Callable {
+    int operator()(int a, int b, int c) {
+        return a + b + c;
+    }
+
+    int operator()(int a) {
+        return a;
+    }
+};
+
+void test_tuple_of_tuples() {
+    auto tup = std::make_tuple(std::make_tuple(10, 19, 60),std::make_tuple(7));
+    Callable c;
+    std::cout << "tuple<tuple<int, int, int>, tuple<int>>\n";
+    for (auto&& i : starmap(c, tup)) {
+        std::cout << i << '\n';
+    }
+
+    auto tup2 = std::make_tuple(std::array<int, 3>{15, 100, 2000},
+                               std::make_tuple(16));
+    std::cout << "tuple<array<int>, tuple<int>>\n";
+    for (auto&& i : starmap(c, tup2)) {
+        std::cout << i << '\n';
+    }
+    std::cout << '\n';
+}
+
+int main() {
+    test_normal();
+    test_tuple_of_tuples();
+
+}

From adbf9ece561b3b7ab60501255080c4c20b71a50e Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 18 Oct 2014 20:10:21 -0400
Subject: [PATCH 0526/1866] adds starmap

---
 starmap.hpp      | 160 +++++++++++++++++++++++++++++++++++++++++++++++
 tests/.gitignore |   1 +
 tests/SConstruct |   1 +
 3 files changed, 162 insertions(+)
 create mode 100644 starmap.hpp

diff --git a/starmap.hpp b/starmap.hpp
new file mode 100644
index 00000000..165cc363
--- /dev/null
+++ b/starmap.hpp
@@ -0,0 +1,160 @@
+#ifndef ITER_STARMAP_H_
+#define ITER_STARMAP_H_
+
+#include "iterbase.hpp"
+
+#include <utility>
+#include <cassert>
+
+namespace iter {
+    template <typename Func, typename Container>
+    class StarMapper {
+        private:
+            Func func;
+            Container container;
+        public:
+            StarMapper(Func f, Container c)
+                : func(f),
+                container(std::forward<Container>(c))
+            { }
+
+            class Iterator {
+                private:
+                    Func func;
+                    iterator_type<Container> sub_iter;
+                public:
+                    Iterator(Func f, iterator_type<Container> iter)
+                        : func(f),
+                        sub_iter(iter)
+                    { }
+
+                    bool operator!=(const Iterator& other) const {
+                        return this->sub_iter != other.sub_iter;
+                    }
+
+                    Iterator operator++() {
+                        ++this->sub_iter;
+                        return *this;
+                    }
+
+                    decltype(auto) operator*() {
+                        return call_with_tuple(this->func, *this->sub_iter);
+                    }
+            };
+
+            Iterator begin() {
+                return {this->func, std::begin(this->container)};
+            }
+
+            Iterator end() {
+                return {this->func, std::end(this->container)};
+            }
+    };
+
+    template <typename Func, typename Container>
+    StarMapper<Func, Container> starmap(Func func, Container&& container) {
+        return {func, std::forward<Container>(container)};
+    }
+
+    template <typename Func, typename TupleType,
+             std::size_t Size =std::tuple_size<std::decay_t<TupleType>>::value>
+    class TupleStarMapper {
+        private:
+            Func func;
+            TupleType tup;
+        public:
+            TupleStarMapper(Func f, TupleType t)
+                : func(f),
+                tup(std::forward<TupleType>(t))
+            { }
+
+            template <std::size_t Dummy, std::size_t Idx>
+            class Iterator {
+                private:
+                    Func func;
+                    TupleType& tup;
+                    bool passed;
+                    Iterator<0, Idx + 1> next_level;
+
+                public:
+                    Iterator(Func f, TupleType& t, bool done)
+                        : func(f),
+                        tup(t),
+                        passed{done},
+                        next_level(f, t, done)
+                    { }
+
+                    decltype(auto) operator*() {
+                        if (this->passed) {
+                            return *this->next_level;
+                        } else {
+                            return call_with_tuple(
+                                    this->func, std::get<Idx>(this->tup));
+                        }
+                    }
+
+                    Iterator operator++() {
+                        if (!this->passed) {
+                            this->passed = true;
+                        } else {
+                            ++this->next_level;
+                        }
+                        return *this;
+                    }
+
+                    bool operator!=(const Iterator& other) const {
+                        return this->passed != other.passed
+                            || this->next_level != other.next_level;
+                    }
+            };
+
+            template <std::size_t Dummy>
+            class Iterator<Dummy, Size> {
+                private:
+                    // data members unused since this should never get
+                    // dereferenced, but are needed to compile
+                    Func func;
+                    TupleType& tup;
+                public:
+                    Iterator(Func f, TupleType& t, bool)
+                        : func(f),
+                        tup(t)
+                    { }
+                    
+                    decltype(auto) operator*() {
+                        assert(false && "deref of last level in starmap");
+                        return call_with_tuple(func, std::get<0>(tup));
+                    }
+
+                    Iterator operator++() {
+                        assert(false && "++ on last level of starmap");
+                        return *this;
+                    }
+
+                    bool operator!=(const Iterator&) const {
+                        return false;
+                    }
+            };
+
+            Iterator<0, 0> begin() {
+                return {this->func, this->tup, false};
+            }
+
+            Iterator<0, 0> end() {
+                return {this->func, this->tup, true};
+            }
+    };
+
+    template <typename Func, typename... Ts>
+    TupleStarMapper<Func, std::tuple<Ts...>> starmap(
+            Func func, std::tuple<Ts...> tup) {
+        return {func, tup};
+    }
+    
+
+}
+
+
+
+
+#endif // #ifndef ITER_STARMAP_H_
diff --git a/tests/.gitignore b/tests/.gitignore
index 7daa7f9d..a72824de 100644
--- a/tests/.gitignore
+++ b/tests/.gitignore
@@ -28,6 +28,7 @@ testgrouper
 testcommand_chains
 testgroupby
 testsorted
+teststarmap
 testunique_justseen
 testunique_everseen
 .sconsign.dblite
diff --git a/tests/SConstruct b/tests/SConstruct
index 7a4abeec..d1271d7d 100644
--- a/tests/SConstruct
+++ b/tests/SConstruct
@@ -34,6 +34,7 @@ progs = Split('''
               powerset
               sliding_window
               imap
+              starmap
               count
               filterfalse
               grouper

From ba4c3b940664855ebbcf4aea64cc3043d375a2c2 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 18 Oct 2014 20:10:58 -0400
Subject: [PATCH 0527/1866] adds starmap to itertools.hpp

---
 itertools.hpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/itertools.hpp b/itertools.hpp
index 55039902..3ef9dd1e 100644
--- a/itertools.hpp
+++ b/itertools.hpp
@@ -1,5 +1,5 @@
-#ifndef ITERTOOLS_HPP
-#define ITERTOOLS_HPP
+#ifndef ITERTOOLS_HPP_
+#define ITERTOOLS_HPP_
 
 #include "accumulate.hpp"
 #include "chain.hpp"
@@ -24,6 +24,7 @@
 #include "reversed.hpp"
 #include "slice.hpp"
 #include "sorted.hpp"
+#include "starmap.hpp"
 #include "takewhile.hpp"
 #include "unique_everseen.hpp"
 #include "unique_justseen.hpp"

From bc9b13799fc96452f7a5fcaef3181cef97f29a9c Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 19 Oct 2014 12:32:22 -0400
Subject: [PATCH 0528/1866] Replaces recursive iterators with flat array

Because TupleStarMapper::Iterator::operator* causes a recursive call, it
gets slower as one goes further along, the cost of longer tuples is
unexpectedly high.  This new scheme uses a set of classes templated on
the index they use in std::get, all inheriting from a common base.
An array of base class pointers can then be indexed into.  It incurs a
virtual function call but that's worth it.  The dynamic allocation seems
to be the bigger cost, but it's possible that can be alleviated as well.
---
 starmap.hpp | 123 +++++++++++++++++++++++++++-------------------------
 1 file changed, 65 insertions(+), 58 deletions(-)

diff --git a/starmap.hpp b/starmap.hpp
index 165cc363..14f14108 100644
--- a/starmap.hpp
+++ b/starmap.hpp
@@ -4,9 +4,13 @@
 #include "iterbase.hpp"
 
 #include <utility>
+#include <type_traits>
+#include <array>
 #include <cassert>
+#include <memory>
 
 namespace iter {
+    // starmap with a container<T> where T is one of tuple, pair, array
     template <typename Func, typename Container>
     class StarMapper {
         private:
@@ -56,101 +60,104 @@ namespace iter {
         return {func, std::forward<Container>(container)};
     }
 
+
+    // starmap for a tuple or pair of tuples or pairs
     template <typename Func, typename TupleType,
              std::size_t Size =std::tuple_size<std::decay_t<TupleType>>::value>
     class TupleStarMapper {
         private:
-            Func func;
-            TupleType tup;
-        public:
-            TupleStarMapper(Func f, TupleType t)
-                : func(f),
-                tup(std::forward<TupleType>(t))
-            { }
+            class TupleExpanderBase {
+                protected:
+                    // deduced return type to return of Func when called with
+                    // one of TupleType
+                    using ResultType = 
+                        decltype(call_with_tuple(
+                                    std::declval<Func&>(),
+                                    std::get<0>(std::declval<TupleType&>())));
+                public:
+                    virtual ResultType call() = 0;
 
-            template <std::size_t Dummy, std::size_t Idx>
-            class Iterator {
+                    virtual ~TupleExpanderBase() { }
+            };
+
+            template <std::size_t Idx>
+            class TupleExpander : public TupleExpanderBase {
                 private:
                     Func func;
                     TupleType& tup;
-                    bool passed;
-                    Iterator<0, Idx + 1> next_level;
-
                 public:
-                    Iterator(Func f, TupleType& t, bool done)
+                    TupleExpander(Func f, TupleType& t)
                         : func(f),
-                        tup(t),
-                        passed{done},
-                        next_level(f, t, done)
+                        tup(t)
                     { }
 
-                    decltype(auto) operator*() {
-                        if (this->passed) {
-                            return *this->next_level;
-                        } else {
-                            return call_with_tuple(
-                                    this->func, std::get<Idx>(this->tup));
-                        }
+                    typename TupleExpanderBase::ResultType call() override {
+                        return call_with_tuple(
+                                this->func, std::get<Idx>(this->tup));
                     }
+            };
 
-                    Iterator operator++() {
-                        if (!this->passed) {
-                            this->passed = true;
-                        } else {
-                            ++this->next_level;
-                        }
-                        return *this;
-                    }
+        private:
+            Func func;
+            TupleType tup;
+            std::array<std::unique_ptr<TupleExpanderBase>, Size> tuple_getters;
 
-                    bool operator!=(const Iterator& other) const {
-                        return this->passed != other.passed
-                            || this->next_level != other.next_level;
-                    }
-            };
+            template <std::size_t... Is>
+            TupleStarMapper(Func f, TupleType t, std::index_sequence<Is...>)
+                : func(f),
+                tup(std::forward<TupleType>(t)),
+                tuple_getters(
+                        {std::make_unique<TupleExpander<Is>>(func, tup)...})
+            { }
+
+        public:
+            TupleStarMapper(Func f, TupleType t)
+                : TupleStarMapper(f, std::forward<TupleType>(t),
+                    std::make_index_sequence<Size>{})
+            { }
 
-            template <std::size_t Dummy>
-            class Iterator<Dummy, Size> {
+            class Iterator {
                 private:
-                    // data members unused since this should never get
-                    // dereferenced, but are needed to compile
-                    Func func;
-                    TupleType& tup;
+                    std::array<std::unique_ptr<TupleExpanderBase>, Size>&
+                        tuple_getters;
+                    std::size_t index;
+
                 public:
-                    Iterator(Func f, TupleType& t, bool)
-                        : func(f),
-                        tup(t)
+                    Iterator(std::array<
+                                std::unique_ptr<TupleExpanderBase>, Size>& tg,
+                            std::size_t i)
+                        : tuple_getters(tg),
+                        index{i}
                     { }
-                    
+
                     decltype(auto) operator*() {
-                        assert(false && "deref of last level in starmap");
-                        return call_with_tuple(func, std::get<0>(tup));
+                        return this->tuple_getters[this->index]->call();
                     }
 
                     Iterator operator++() {
-                        assert(false && "++ on last level of starmap");
+                        ++this->index;
                         return *this;
                     }
 
-                    bool operator!=(const Iterator&) const {
-                        return false;
+                    bool operator!=(const Iterator& other) const {
+                        return this->index != other.index;
                     }
             };
 
-            Iterator<0, 0> begin() {
-                return {this->func, this->tup, false};
+            Iterator begin() {
+                return {this->tuple_getters, 0};
             }
 
-            Iterator<0, 0> end() {
-                return {this->func, this->tup, true};
+            Iterator end() {
+                return {this->tuple_getters, Size};
             }
     };
 
     template <typename Func, typename... Ts>
-    TupleStarMapper<Func, std::tuple<Ts...>> starmap(
-            Func func, std::tuple<Ts...> tup) {
+    TupleStarMapper<Func, std::tuple<Ts...>&> starmap(
+            Func func, std::tuple<Ts...>& tup) {
         return {func, tup};
     }
-    
 
 }
 

From 917ad43c328e8720d58fe796209fd381e755694e Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 20 Oct 2014 00:07:13 -0400
Subject: [PATCH 0529/1866] adds starmap test with pair of tuples

---
 tests/teststarmap.cpp | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/tests/teststarmap.cpp b/tests/teststarmap.cpp
index 0d293abc..992c7ce3 100644
--- a/tests/teststarmap.cpp
+++ b/tests/teststarmap.cpp
@@ -66,6 +66,14 @@ void test_tuple_of_tuples() {
         std::cout << i << '\n';
     }
     std::cout << '\n';
+
+    std::cout << "pair<array<int>, tuple<int>>\n";
+    auto p = std::make_pair(std::array<int, 3>{15, 100, 2000},
+                            std::make_tuple(16));
+    for (auto&& i : starmap(c, p)) {
+        std::cout << i << '\n';
+    }
+    std::cout << '\n';
 }
 
 int main() {

From 7350d07421db5c3be58b8563bf9565775da036a3 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 20 Oct 2014 00:08:27 -0400
Subject: [PATCH 0530/1866] supports starmap over a pair

---
 starmap.hpp | 29 +++++++++++++++++++++++------
 1 file changed, 23 insertions(+), 6 deletions(-)

diff --git a/starmap.hpp b/starmap.hpp
index 14f14108..920825ec 100644
--- a/starmap.hpp
+++ b/starmap.hpp
@@ -55,12 +55,14 @@ namespace iter {
             }
     };
 
+
+
     template <typename Func, typename Container>
-    StarMapper<Func, Container> starmap(Func func, Container&& container) {
+    StarMapper<Func, Container> starmap_helper(
+            Func func, Container&& container, std::false_type) {
         return {func, std::forward<Container>(container)};
     }
 
-
     // starmap for a tuple or pair of tuples or pairs
     template <typename Func, typename TupleType,
              std::size_t Size =std::tuple_size<std::decay_t<TupleType>>::value>
@@ -153,12 +155,27 @@ namespace iter {
             }
     };
 
-    template <typename Func, typename... Ts>
-    TupleStarMapper<Func, std::tuple<Ts...>&> starmap(
-            Func func, std::tuple<Ts...>& tup) {
-        return {func, tup};
+    template <typename Func, typename TupleType>
+    TupleStarMapper<Func, TupleType> starmap_helper(
+            Func func, TupleType&& tup, std::true_type) {
+        return {func, std::forward<TupleType>(tup)};
     }
 
+    // "tag dispatch" to differentiate between normal containers and
+    // tuple-like containers, things that work with std::get
+    template <typename T, typename U =void>
+    struct is_tuple_like : public std::false_type { };
+
+    template <typename T>
+    struct is_tuple_like<T, decltype(std::get<0>(std::declval<T>()), void())>
+        : public std::true_type { };
+
+    template <typename Func, typename Seq>
+    auto starmap(Func func, Seq&& sequence) {
+        return starmap_helper(
+                func, std::forward<Seq>(sequence),
+                is_tuple_like<Seq>{});
+    }
 }
 
 

From f9209106698999a3ea0b363054acbf4e30d64876 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 20 Oct 2014 00:11:45 -0400
Subject: [PATCH 0531/1866] implements imap in terms of starmap

and gets rid of nearly the entire imap.hpp in the process
---
 imap.hpp | 75 +++-----------------------------------------------------
 1 file changed, 3 insertions(+), 72 deletions(-)

diff --git a/imap.hpp b/imap.hpp
index e39a468c..8c5721aa 100644
--- a/imap.hpp
+++ b/imap.hpp
@@ -2,84 +2,15 @@
 #define ITER_IMAP_H_
 
 #include "zip.hpp"
+#include "starmap.hpp"
 
 #include <utility>
 
 namespace iter {
-
-    //Forward declarations of IMap and imap
-    template <typename MapFunc, typename... Containers>
-    class IMap;
-
-    template <typename MapFunc, typename... Containers>
-    IMap<MapFunc, Containers...> imap(MapFunc, Containers&&...);
-
-    template <typename MapFunc, typename... Containers>
-    class IMap {
-        // The imap function is the only thing allowed to create a IMap
-        friend IMap imap<MapFunc, Containers...>(MapFunc, Containers&& ...);
-
-        using ZippedType = decltype(zip(std::declval<Containers>()...));
-        using ZippedIterType = iterator_type<ZippedType>;
-        private:
-            MapFunc map_func;
-            ZippedType zipped;
-            
-            // Value constructor for use only in the imap function
-            IMap(MapFunc map_func, Containers&& ... containers) :
-                map_func(map_func),
-                zipped(zip(std::forward<Containers>(containers)...))
-            { }
-            IMap() = delete;
-            IMap& operator=(const IMap&) = delete;
-
-        public:
-            IMap(const IMap&) = default;
-            IMap(IMap&&) = default;
-
-            class Iterator {
-                private:
-                    MapFunc map_func;
-                    ZippedIterType zipiter;
-
-                public:
-                    Iterator(MapFunc map_func, ZippedIterType zipiter) :
-                        map_func(map_func),
-                        zipiter(zipiter)
-                    { } 
-
-                    decltype(auto) operator*() {
-                        return call_with_tuple(
-                                this->map_func, *(this->zipiter));
-                    }
-
-                    Iterator& operator++() { 
-                        ++this->zipiter;
-                        return *this;
-                    }
-
-                    bool operator!=(const Iterator& other) const {
-                        return this->zipiter != other.zipiter;
-                    }
-            };
-
-            Iterator begin() {
-                return {this->map_func, this->zipped.begin()};
-            }
-
-            Iterator end() {
-                return {this->map_func, this->zipped.end()};
-            }
-
-    };
-
-    // Helper function to instantiate a IMap
     template <typename MapFunc, typename... Containers>
-    IMap<MapFunc, Containers...> imap(
-            MapFunc map_func, Containers&& ... containers) {
-        return {map_func, std::forward<Containers>(containers)...};
+    auto imap(MapFunc map_func, Containers&& ... containers) {
+        return starmap(map_func, zip(std::forward<Containers>(containers)...));
     }
-
 }
 
 #endif // #ifndef ITER_IMAP_H_

From c413262eea9329ed534062f7f83ec54459daa3dc Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 23 Oct 2014 11:13:49 -0400
Subject: [PATCH 0532/1866] Adds braces around array initliazation

---
 starmap.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/starmap.hpp b/starmap.hpp
index 920825ec..dadc5884 100644
--- a/starmap.hpp
+++ b/starmap.hpp
@@ -109,7 +109,7 @@ namespace iter {
                 : func(f),
                 tup(std::forward<TupleType>(t)),
                 tuple_getters(
-                        {std::make_unique<TupleExpander<Is>>(func, tup)...})
+                        {{std::make_unique<TupleExpander<Is>>(func, tup)...}})
             { }
 
         public:

From 0d6811c0a1deeb2329830f6bd1efd47f674d8c38 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 23 Oct 2014 11:14:07 -0400
Subject: [PATCH 0533/1866] Adds braces around array initializations

---
 tests/teststarmap.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/teststarmap.cpp b/tests/teststarmap.cpp
index 992c7ce3..f85bd40d 100644
--- a/tests/teststarmap.cpp
+++ b/tests/teststarmap.cpp
@@ -59,7 +59,7 @@ void test_tuple_of_tuples() {
         std::cout << i << '\n';
     }
 
-    auto tup2 = std::make_tuple(std::array<int, 3>{15, 100, 2000},
+    auto tup2 = std::make_tuple(std::array<int, 3>{{15, 100, 2000}},
                                std::make_tuple(16));
     std::cout << "tuple<array<int>, tuple<int>>\n";
     for (auto&& i : starmap(c, tup2)) {
@@ -68,7 +68,7 @@ void test_tuple_of_tuples() {
     std::cout << '\n';
 
     std::cout << "pair<array<int>, tuple<int>>\n";
-    auto p = std::make_pair(std::array<int, 3>{15, 100, 2000},
+    auto p = std::make_pair(std::array<int, 3>{{15, 100, 2000}},
                             std::make_tuple(16));
     for (auto&& i : starmap(c, p)) {
         std::cout << i << '\n';

From 6dc80a1ef247f0cb78206b50822e75de0ae893fa Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 23 Oct 2014 11:16:12 -0400
Subject: [PATCH 0534/1866] makes absorb() non-templated

---
 iterbase.hpp | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/iterbase.hpp b/iterbase.hpp
index d0eade82..c60713df 100644
--- a/iterbase.hpp
+++ b/iterbase.hpp
@@ -112,8 +112,7 @@ namespace iter {
     // function absorbing all arguments passed to it. used when
     // applying a function to a parameter pack but not passing the evaluated
     // results anywhere
-    template <typename... Ts>
-    void absorb(Ts&&...) { }
+    void absorb(...) { }
 
     namespace detail {
         template <typename Func, typename TupleType, std::size_t... Is>

From 0ce44f35f578feef8536ac5829cf65969c9e80b9 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 24 Oct 2014 10:53:17 -0400
Subject: [PATCH 0535/1866] uses anonymous template parm in is_tuple_like

---
 starmap.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/starmap.hpp b/starmap.hpp
index 920825ec..34b91737 100644
--- a/starmap.hpp
+++ b/starmap.hpp
@@ -163,7 +163,7 @@ namespace iter {
 
     // "tag dispatch" to differentiate between normal containers and
     // tuple-like containers, things that work with std::get
-    template <typename T, typename U =void>
+    template <typename T, typename =void>
     struct is_tuple_like : public std::false_type { };
 
     template <typename T>

From 5fe7c0f381d5e1d1fcd7e4f16f1a7fe772404873 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 28 Oct 2014 16:36:15 -0400
Subject: [PATCH 0536/1866] Flattens chain

Chain is flattened using a similar approach to starmap.  A different
instantiation of each ChainIterWrapper for each index.  This avoids
having a nested class structure, and the time to perform operator*
doesn't increase as one gets further into the chain.  An index keeps
track of which iterator we're on each step of the way.

It's not very pretty though.
---
 chain.hpp | 182 ++++++++++++++++++++++++++++++------------------------
 1 file changed, 102 insertions(+), 80 deletions(-)

diff --git a/chain.hpp b/chain.hpp
index e5df892d..0c75c4c5 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -8,128 +8,140 @@
 #include <memory>
 #include <initializer_list>
 #include <type_traits>
+#include <tuple>
+#include <array>
 
 namespace iter {
     // rather than a chain function, use a callable object to support
     // from_iterable
     class ChainMaker;
 
-    template <typename Container, typename... RestContainers>
+    template <typename TupleType, std::size_t... Is>
     class Chained {
         friend class ChainMaker;
-        template <typename C, typename... RC>
-        friend class Chained;
 
         private:
-            Container container;
-            Chained<RestContainers...> rest_chained;
-            Chained(Container container, RestContainers&&... rest)
-                : container(std::forward<Container>(container)),
-                rest_chained{std::forward<RestContainers>(rest)...}
-            { }
+            class ChainIterWrapperBase {
+                protected:
+                    using ResultType =
+                        iterator_deref<std::tuple_element_t<0, TupleType>>;
+                public:
+                    virtual ~ChainIterWrapperBase() { }
+                    virtual bool operator!=(
+                            const ChainIterWrapperBase&) const = 0;
+                    virtual bool operator==(
+                            const ChainIterWrapperBase&) const = 0;
+                    virtual ResultType operator*() = 0;
+                    virtual ChainIterWrapperBase& operator++() = 0;
+            };
 
-        public:
-            class Iterator {
+            template <typename Container>
+            class ChainIterWrapper : public ChainIterWrapperBase {
                 private:
-                    using RestIter =
-                        typename Chained<RestContainers...>::Iterator;
                     iterator_type<Container> sub_iter;
-                    const iterator_type<Container> sub_end;
-                    RestIter rest_iter;
-                    bool at_end;
 
                 public:
-                    Iterator(const iterator_type<Container>& s_begin,
-                            const iterator_type<Container>& s_end,
-                            RestIter rest_iter)
-                        : sub_iter{s_begin},
-                        sub_end{s_end},
-                        rest_iter{rest_iter},
-                        at_end{!(sub_iter != sub_end)}
+                    ChainIterWrapper(const iterator_type<Container>& iter)
+                        : sub_iter{iter}
                     { }
-                    
-                    Iterator& operator++() {
-                        if (this->at_end) {
-                            ++this->rest_iter;
-                        } else {
-                            ++this->sub_iter;
-                            if (!(this->sub_iter != this->sub_end)) {
-                                this->at_end = true;
-                            }
-                        }
-                        return *this;
+
+                    bool operator!=(const ChainIterWrapperBase& other)
+                            const override {
+                        return this->sub_iter !=
+                            static_cast<const ChainIterWrapper&>(
+                                    other).sub_iter;
                     }
 
-                    bool operator!=(const Iterator& other) const {
-                        return this->sub_iter != other.sub_iter ||
-                            this->rest_iter != other.rest_iter;
+                    bool operator==(const ChainIterWrapperBase& other)
+                            const override {
+                        return !(*this !=
+                                static_cast<const ChainIterWrapper&>(other));
                     }
 
-                    iterator_deref<Container> operator*() {
-                        return this->at_end ?
-                            *this->rest_iter : *this->sub_iter;
+                    typename ChainIterWrapper::ResultType operator*() {
+                        return *this->sub_iter;
                     }
-            };
 
-            Iterator begin() {
-                return {std::begin(this->container),
-                    std::end(this->container),
-                    std::begin(this->rest_chained)};
-            }
+                    ChainIterWrapper& operator++() override {
+                        ++this->sub_iter;
+                        return *this;
+                    }
+            };
 
-            Iterator end() {
-                return {std::end(this->container),
-                    std::end(this->container),
-                    std::end(this->rest_chained)};
-            }
-    };
-    template <typename Container>
-    class Chained<Container> {
-        friend class ChainMaker;
-        template <typename C, typename... RC>
-        friend class Chained;
 
         private:
-            Container container;
-            Chained(Container container)
-                : container(std::forward<Container>(container))
+            using ArrayType =
+                std::array<std::unique_ptr<ChainIterWrapperBase>,
+                sizeof...(Is)>;
+            TupleType containers;
+            ArrayType end_iter_wrappers;
+
+            Chained(TupleType&& tup_containers)
+                : containers(std::move(tup_containers)),
+                end_iter_wrappers{{std::make_unique<
+                    ChainIterWrapper<std::tuple_element_t<Is, TupleType>>>(
+                            std::end(std::get<Is>(this->containers)))...}}
             { }
 
         public:
             class Iterator {
                 private:
-                    iterator_type<Container> sub_iter;
-                    const iterator_type<Container> sub_end;
+                    using ArrayType =
+                        std::array<std::unique_ptr<ChainIterWrapperBase>,
+                        sizeof...(Is)>;
+
+                    ArrayType iter_wrappers;
+                    const ArrayType& end_iter_wrappers;
+                    std::size_t index;
+
+                    void check_index() {
+                        while (this->index < iter_wrappers.size()
+                                && *this->iter_wrappers[this->index]
+                                    == *this->end_iter_wrappers[this->index]) {
+                            ++this->index;
+                        }
+                    }
+
 
                 public:
-                    Iterator(const iterator_type<Container>& s_begin,
-                            const iterator_type<Container>& s_end)
-                        : sub_iter{s_begin},
-                        sub_end{s_end}
-                    { }
-                    
+                    Iterator(ArrayType&& iters, ArrayType& ends, std::size_t i)
+                        : iter_wrappers(std::move(iters)),
+                        end_iter_wrappers(ends),
+                        index{i}
+                    {
+                        this->check_index();
+                    }
+
                     Iterator& operator++() {
-                        ++this->sub_iter;
+                        ++*this->iter_wrappers[this->index];
+                        this->check_index();
                         return *this;
                     }
 
-                    bool operator!=(const Iterator& other) const {
-                        return this->sub_iter != other.sub_iter;
+                    decltype(auto) operator*() {
+                        return **this->iter_wrappers[this->index];
                     }
 
-                    iterator_deref<Container> operator*() {
-                        return *this->sub_iter;
+                    bool operator!=(const Iterator& other) const {
+                        return this->index != other.index;
                     }
             };
 
+
             Iterator begin() {
-                return {std::begin(this->container),
-                    std::end(this->container)};
+                ArrayType a{{
+                    std::make_unique<
+                        ChainIterWrapper<std::tuple_element_t<Is, TupleType>>>(
+                                std::begin(std::get<Is>(this->containers))
+                            )...}};
+                return {std::move(a), end_iter_wrappers, 0};
             }
 
             Iterator end() {
-                return {std::end(this->container),
-                    std::end(this->container)};
+                ArrayType a{{std::unique_ptr<
+                    ChainIterWrapper<std::tuple_element_t<Is, TupleType>>>{
+                        nullptr}...}};
+                return {std::move(a), end_iter_wrappers, sizeof...(Is)};
             }
     };
 
@@ -179,7 +191,6 @@ namespace iter {
                        }
                        return *this;
                    }
-                       
 
                    bool operator!=(const Iterator& other) const {
                        return this->top_level_iter != other.top_level_iter &&
@@ -203,11 +214,22 @@ namespace iter {
 
 
     class ChainMaker {
+        private:
+            template <typename TupleType, std::size_t... Is>
+            Chained<TupleType, Is...> chain_impl(
+                    TupleType&& in_containers,
+                    std::index_sequence<Is...>) const {
+                return {std::move(in_containers)};
+            }
+
         public:
             // expose regular call operator to provide usual chain()
             template <typename... Containers>
-            Chained<Containers...> operator()(Containers&&... cs) const {
-                return {std::forward<Containers>(cs)...};
+            auto operator()(Containers&&... cs) const {
+                return this->chain_impl(
+                        std::tuple<Containers...>{
+                            std::forward<Containers>(cs)...},
+                        std::index_sequence_for<Containers...>{});
             }
 
             // chain.from_iterable

From 37f7413c8f039920cefe24e664dffdab9833da85 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 28 Oct 2014 16:39:22 -0400
Subject: [PATCH 0537/1866] Grabs PATH from environment

---
 tests/SConstruct | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tests/SConstruct b/tests/SConstruct
index eb1c70a7..626cb51a 100644
--- a/tests/SConstruct
+++ b/tests/SConstruct
@@ -2,6 +2,7 @@ import platform
 import os
 
 env = Environment(
+    ENV = {'PATH' : os.environ['PATH']},
     CXX='c++',
     CXXFLAGS= ['-g', '-Wall', '-Wextra',
                '-pedantic', '-std=c++11',

From 920ec9b6ec912759dc1412193bef26b93bd4285b Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 28 Oct 2014 16:39:40 -0400
Subject: [PATCH 0538/1866] removes return 0

---
 tests/testchain.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/testchain.cpp b/tests/testchain.cpp
index 99d7a291..19ab374d 100644
--- a/tests/testchain.cpp
+++ b/tests/testchain.cpp
@@ -11,6 +11,7 @@ using iter::chain;
 using il = std::initializer_list<int>; 
 
 int main() {
+
     {
         std::vector<int> ivec{1, 4, 7, 9};
         std::vector<int> lvec{100, 200, 300, 400, 500, 600};
@@ -57,5 +58,4 @@ int main() {
             std::cout << i << '\n';
         }
     }
-    return 0;
 }

From 85acb28c3c7ced7aee6617b987b052a5a6f01148 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 28 Oct 2014 16:40:28 -0400
Subject: [PATCH 0539/1866] corrects include guard

---
 chain.hpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/chain.hpp b/chain.hpp
index e5df892d..3d4dc723 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -1,5 +1,5 @@
-#ifndef CHAIN__HPP__
-#define CHAIN__HPP__
+#ifndef ITER_CHAIN_HPP_
+#define ITER_CHAIN_HPP_
 
 #include "iterbase.hpp"
 
@@ -224,4 +224,4 @@ namespace iter {
 
 }
 
-#endif //#define CHAIN__HPP__
+#endif // #ifndef ITER_CHAIN_HPP_

From 0305423f4079880456fc66a0d78d538bcaaac6a3 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 9 Nov 2014 23:46:20 -0500
Subject: [PATCH 0540/1866] adds chain iterator copy ctor

---
 chain.hpp | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/chain.hpp b/chain.hpp
index d116fcd4..70e1b2f7 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -106,12 +106,21 @@ namespace iter {
                 public:
                     Iterator(ArrayType&& iters, ArrayType& ends, std::size_t i)
                         : iter_wrappers(std::move(iters)),
-                        end_iter_wrappers(ends),
+                        end_iter_wrappers{ends},
                         index{i}
                     {
                         this->check_index();
                     }
 
+                    Iterator(const Iterator& other) 
+                        : iter_wrappers{{
+                            // make this not so awful.
+                            std::unique_ptr<ChainIterWrapperBase>{new ChainIterWrapper<std::tuple_element_t<Is, TupleType>>(dynamic_cast<ChainIterWrapper<std::tuple_element_t<Is, TupleType>>&>(*std::get<Is>(other.iter_wrappers)))}...
+                        }},
+                        end_iter_wrappers{other.end_iter_wrappers},
+                        index{other.index}
+                    { }
+
                     Iterator& operator++() {
                         ++*this->iter_wrappers[this->index];
                         this->check_index();

From dd0f2c40a6e0ec1d65c9ca9553616ccce110346d Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 11 Nov 2014 20:20:07 -0500
Subject: [PATCH 0541/1866] range iterator derives std::iterator

---
 range.hpp | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/range.hpp b/range.hpp
index 53752a3f..f54de39f 100644
--- a/range.hpp
+++ b/range.hpp
@@ -1,5 +1,5 @@
-#ifndef RANGE__H__
-#define RANGE__H__
+#ifndef ITER_RANGE_H_
+#define ITER_RANGE_H_
 
 // range() for range-based loops with start, stop, and step.
 //
@@ -17,6 +17,7 @@
 
 #include <exception>
 #include <type_traits>
+#include <iterator>
 
 namespace iter {
 
@@ -63,7 +64,9 @@ namespace iter {
         public:
             Range() = delete;
             Range(const Range&) = default;
-            class Iterator {
+            class Iterator
+                : public std::iterator<std::input_iterator_tag, T>
+            {
                 private:
                     T value;
                     T step;
@@ -143,4 +146,4 @@ namespace iter {
     }
 }
 
-#endif //ifndef RANGE__H__
+#endif // #ifndef ITER_RANGE_H_

From 300caf936f7ded86b6a3d5579c1942e7dfbee60d Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 11 Nov 2014 23:55:01 -0500
Subject: [PATCH 0542/1866] Replaces polymorphic solution with std::functions

..which are also polymorphic, but it allows for a single const static
array per instatiation of TupleStarMapper
---
 iterbase.hpp |   4 ++
 starmap.hpp  | 115 +++++++++++++++++++++++++--------------------------
 2 files changed, 60 insertions(+), 59 deletions(-)

diff --git a/iterbase.hpp b/iterbase.hpp
index d0eade82..5564bcb8 100644
--- a/iterbase.hpp
+++ b/iterbase.hpp
@@ -134,6 +134,10 @@ namespace iter {
                 std::make_index_sequence<TUP_SIZE>{});
     }
 
+    // this will eventually make it into the standard, but for now:
+    template <typename...>
+    using void_t = void;
+
 }
 
 #endif // #ifndef ITERBASE_HPP_
diff --git a/starmap.hpp b/starmap.hpp
index 34b91737..272753e6 100644
--- a/starmap.hpp
+++ b/starmap.hpp
@@ -59,81 +59,56 @@ namespace iter {
 
     template <typename Func, typename Container>
     StarMapper<Func, Container> starmap_helper(
-            Func func, Container&& container, std::false_type) {
-        return {func, std::forward<Container>(container)};
+            Func&& func, Container&& container, std::false_type) {
+        return {std::forward<Func>(func), std::forward<Container>(container)};
     }
 
     // starmap for a tuple or pair of tuples or pairs
-    template <typename Func, typename TupleType,
-             std::size_t Size =std::tuple_size<std::decay_t<TupleType>>::value>
+    template <typename Func, typename TupType, std::size_t... Is>
     class TupleStarMapper {
         private:
-            class TupleExpanderBase {
-                protected:
-                    // deduced return type to return of Func when called with
-                    // one of TupleType
-                    using ResultType = 
-                        decltype(call_with_tuple(
-                                    std::declval<Func&>(),
-                                    std::get<0>(std::declval<TupleType&>())));
-                public:
-                    virtual ResultType call() = 0;
+            Func func;
+            TupType tup;
 
-                    virtual ~TupleExpanderBase() { }
-            };
+        private:
+            static_assert(sizeof...(Is)
+                    == std::tuple_size<std::decay_t<TupType>>::value,
+                    "tuple size doesn't match size of Is");
 
             template <std::size_t Idx>
-            class TupleExpander : public TupleExpanderBase {
-                private:
-                    Func func;
-                    TupleType& tup;
-                public:
-                    TupleExpander(Func f, TupleType& t)
-                        : func(f),
-                        tup(t)
-                    { }
+            static decltype(auto) get_and_call_with_tuple(Func& f, TupType &t){
+                return call_with_tuple(f, std::get<Idx>(t));
+            }
 
-                    typename TupleExpanderBase::ResultType call() override {
-                        return call_with_tuple(
-                                this->func, std::get<Idx>(this->tup));
-                    }
-            };
+            using v =
+                void_t<decltype(get_and_call_with_tuple<Is>(func, tup))...>;
 
-        private:
-            Func func;
-            TupleType tup;
-            std::array<std::unique_ptr<TupleExpanderBase>, Size> tuple_getters;
+            using ResultType = decltype(get_and_call_with_tuple<0>(func, tup));
+            using CallerFunc = std::function<ResultType(Func&, TupType&)>;
 
-            template <std::size_t... Is>
-            TupleStarMapper(Func f, TupleType t, std::index_sequence<Is...>)
-                : func(f),
-                tup(std::forward<TupleType>(t)),
-                tuple_getters(
-                        {std::make_unique<TupleExpander<Is>>(func, tup)...})
-            { }
+            const static std::array<CallerFunc, sizeof...(Is)> callers;
 
         public:
-            TupleStarMapper(Func f, TupleType t)
-                : TupleStarMapper(f, std::forward<TupleType>(t),
-                    std::make_index_sequence<Size>{})
+            TupleStarMapper(Func f, TupType t)
+                : func(std::forward<Func>(f)),
+                tup(std::forward<TupType>(t))
             { }
 
             class Iterator {
                 private:
-                    std::array<std::unique_ptr<TupleExpanderBase>, Size>&
-                        tuple_getters;
+                    Func& func;
+                    TupType& tup;
                     std::size_t index;
 
                 public:
-                    Iterator(std::array<
-                                std::unique_ptr<TupleExpanderBase>, Size>& tg,
-                            std::size_t i)
-                        : tuple_getters(tg),
+                    Iterator(Func& f, TupType& t, std::size_t i)
+                        : func{f},
+                        tup{t},
                         index{i}
                     { }
 
                     decltype(auto) operator*() {
-                        return this->tuple_getters[this->index]->call();
+                        return callers[this->index](this->func, this->tup);
                     }
 
                     Iterator operator++() {
@@ -147,20 +122,41 @@ namespace iter {
             };
 
             Iterator begin() {
-                return {this->tuple_getters, 0};
+                return {this->func, this->tup, 0};
             }
 
             Iterator end() {
-                return {this->tuple_getters, Size};
+                return {this->func, this->tup, sizeof...(Is)};
             }
     };
+    // initialize array with a caller function for each index
+    template <typename Func, typename TupType, std::size_t... Is>
+    const std::array<
+        typename TupleStarMapper<Func, TupType, Is...>::CallerFunc,
+        sizeof...(Is)>
+        TupleStarMapper<Func, TupType, Is...>::callers{{
+            get_and_call_with_tuple<Is>...}};
 
-    template <typename Func, typename TupleType>
-    TupleStarMapper<Func, TupleType> starmap_helper(
-            Func func, TupleType&& tup, std::true_type) {
-        return {func, std::forward<TupleType>(tup)};
+
+
+    template <typename Func, typename TupType, std::size_t... Is>
+    TupleStarMapper<Func, TupType, Is...> starmap_helper_impl(
+            Func&& func, TupType&& tup, std::index_sequence<Is...>)
+    {
+        return {std::forward<Func>(func), std::forward<TupType>(tup)};
     }
 
+    template <typename Func, typename TupType>
+    auto starmap_helper(
+            Func&& func, TupType&& tup, std::true_type) {
+        return starmap_helper_impl(
+            std::forward<Func>(func),
+            std::forward<TupType>(tup),
+            std::make_index_sequence<
+                std::tuple_size<std::decay_t<TupType>>::value>{});
+    }
+
+
     // "tag dispatch" to differentiate between normal containers and
     // tuple-like containers, things that work with std::get
     template <typename T, typename =void>
@@ -171,9 +167,10 @@ namespace iter {
         : public std::true_type { };
 
     template <typename Func, typename Seq>
-    auto starmap(Func func, Seq&& sequence) {
+    auto starmap(Func&& func, Seq&& sequence) {
         return starmap_helper(
-                func, std::forward<Seq>(sequence),
+                std::forward<Func>(func),
+                std::forward<Seq>(sequence),
                 is_tuple_like<Seq>{});
     }
 }

From 7d878e57fd1521a7ea29bd6f0d6d077d3a61e893 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 12 Nov 2014 00:08:51 -0500
Subject: [PATCH 0543/1866] Computes callers as constexpr

I did it constexpr.  I'm pretty happy with this, I can't see it getting
much better outside of not writing the code at all.
---
 iterbase.hpp |  4 ----
 starmap.hpp  | 14 +++++---------
 2 files changed, 5 insertions(+), 13 deletions(-)

diff --git a/iterbase.hpp b/iterbase.hpp
index 5564bcb8..d0eade82 100644
--- a/iterbase.hpp
+++ b/iterbase.hpp
@@ -134,10 +134,6 @@ namespace iter {
                 std::make_index_sequence<TUP_SIZE>{});
     }
 
-    // this will eventually make it into the standard, but for now:
-    template <typename...>
-    using void_t = void;
-
 }
 
 #endif // #ifndef ITERBASE_HPP_
diff --git a/starmap.hpp b/starmap.hpp
index 272753e6..4a41cba9 100644
--- a/starmap.hpp
+++ b/starmap.hpp
@@ -80,13 +80,11 @@ namespace iter {
                 return call_with_tuple(f, std::get<Idx>(t));
             }
 
-            using v =
-                void_t<decltype(get_and_call_with_tuple<Is>(func, tup))...>;
-
             using ResultType = decltype(get_and_call_with_tuple<0>(func, tup));
-            using CallerFunc = std::function<ResultType(Func&, TupType&)>;
+            using CallerFunc = ResultType (*)(Func&, TupType&);
 
-            const static std::array<CallerFunc, sizeof...(Is)> callers;
+            constexpr static std::array<CallerFunc, sizeof...(Is)> callers{{
+                get_and_call_with_tuple<Is>...}};
 
         public:
             TupleStarMapper(Func f, TupType t)
@@ -129,13 +127,11 @@ namespace iter {
                 return {this->func, this->tup, sizeof...(Is)};
             }
     };
-    // initialize array with a caller function for each index
     template <typename Func, typename TupType, std::size_t... Is>
-    const std::array<
+    constexpr std::array<
         typename TupleStarMapper<Func, TupType, Is...>::CallerFunc,
         sizeof...(Is)>
-        TupleStarMapper<Func, TupType, Is...>::callers{{
-            get_and_call_with_tuple<Is>...}};
+        TupleStarMapper<Func, TupType, Is...>::callers;
 
 
 

From 56b5a6498b9d430d65bb2507be62faa971be9cef Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 12 Nov 2014 21:08:58 -0500
Subject: [PATCH 0544/1866] adds test for iterator assignment to chain

---
 tests/testchain.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/tests/testchain.cpp b/tests/testchain.cpp
index 19ab374d..3dfde3d1 100644
--- a/tests/testchain.cpp
+++ b/tests/testchain.cpp
@@ -19,6 +19,11 @@ int main() {
         for (auto e : chain(ivec, lvec)) {
             std::cout << e << std::endl;
         }
+
+        auto c = chain(ivec, lvec);
+        auto it = std::begin(c);
+        auto it2 = std::begin(c);
+        it = it2;
     }
     {
         std::vector<int> empty{};
@@ -58,4 +63,5 @@ int main() {
             std::cout << i << '\n';
         }
     }
+
 }

From 3dabc8757c0865cc3824f13534e4356f8a734daf Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 12 Nov 2014 21:10:37 -0500
Subject: [PATCH 0545/1866] Uses constexpr array of funcion pointers for chain

Instead of the polymorphism and the base class, I was able to use a
similar approach as in starmap to get chain to act more dynamic than it
really is.  Starmap needed only one set of function pointers, for the
dereferencing, chain is admittedly more complicated because it needs one
for each operation that must be performed per iterator.
---
 chain.hpp | 259 ++++++++++++++++++++++++++----------------------------
 1 file changed, 124 insertions(+), 135 deletions(-)

diff --git a/chain.hpp b/chain.hpp
index 70e1b2f7..f73db8e3 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -3,156 +3,145 @@
 
 #include "iterbase.hpp"
 
-#include <utility>
+#include <array>
+#include <initializer_list>
 #include <iterator>
 #include <memory>
-#include <initializer_list>
-#include <type_traits>
 #include <tuple>
-#include <array>
+#include <type_traits>
+#include <utility>
 
 namespace iter {
     // rather than a chain function, use a callable object to support
     // from_iterable
     class ChainMaker;
 
-    template <typename TupleType, std::size_t... Is>
-    class Chained {
+template <typename TupType, std::size_t... Is>
+class Chained {
+    private:
         friend class ChainMaker;
 
-        private:
-            class ChainIterWrapperBase {
-                protected:
-                    using ResultType =
-                        iterator_deref<std::tuple_element_t<0, TupleType>>;
-                public:
-                    virtual ~ChainIterWrapperBase() { }
-                    virtual bool operator!=(
-                            const ChainIterWrapperBase&) const = 0;
-                    virtual bool operator==(
-                            const ChainIterWrapperBase&) const = 0;
-                    virtual ResultType operator*() = 0;
-                    virtual ChainIterWrapperBase& operator++() = 0;
-            };
-
-            template <typename Container>
-            class ChainIterWrapper : public ChainIterWrapperBase {
-                private:
-                    iterator_type<Container> sub_iter;
-
-                public:
-                    ChainIterWrapper(const iterator_type<Container>& iter)
-                        : sub_iter{iter}
-                    { }
-
-                    bool operator!=(const ChainIterWrapperBase& other)
-                            const override {
-                        return this->sub_iter !=
-                            static_cast<const ChainIterWrapper&>(
-                                    other).sub_iter;
-                    }
-
-                    bool operator==(const ChainIterWrapperBase& other)
-                            const override {
-                        return !(*this !=
-                                static_cast<const ChainIterWrapper&>(other));
-                    }
-
-                    typename ChainIterWrapper::ResultType operator*() {
-                        return *this->sub_iter;
-                    }
-
-                    ChainIterWrapper& operator++() override {
-                        ++this->sub_iter;
-                        return *this;
+        static_assert(std::tuple_size<std::decay_t<TupType>>::value
+                == sizeof...(Is),
+                "tuple size != sizeof Is");
+
+        using IterTupType = iterator_tuple_type<TupType>;
+
+        using DerefType =
+            iterator_deref<std::tuple_element_t<0, TupType>>;
+
+        template <std::size_t Idx>
+        static DerefType get_and_deref(IterTupType& iters) {
+            return *std::get<Idx>(iters);
+        }
+
+        template <std::size_t Idx>
+        static void get_and_increment(IterTupType& iters) {
+            ++std::get<Idx>(iters);
+        }
+
+        template <std::size_t Idx>
+        static bool get_and_check_not_equal(
+                const IterTupType& lhs, const IterTupType& rhs) {
+            return std::get<Idx>(lhs) != std::get<Idx>(rhs);
+        }
+
+        using DerefFunc = DerefType (*)(IterTupType&);
+        using IncFunc = void (*)(IterTupType&);
+        using NeqFunc = bool (*)(const IterTupType&, const IterTupType&);
+
+
+        constexpr static std::array<DerefFunc, sizeof...(Is)> derefers{{
+            get_and_deref<Is>...}};
+        
+        constexpr static std::array<IncFunc, sizeof...(Is)> incrementers{{
+            get_and_increment<Is>...}};
+
+        constexpr static std::array<NeqFunc, sizeof...(Is)> neq_comparers{{
+            get_and_check_not_equal<Is>...}};
+
+    private:
+        TupType tup;
+    public:
+        Chained(TupType t)
+            : tup(t)
+        { }
+
+        class Iterator {
+            private:
+                std::size_t index;
+                IterTupType iters;
+                IterTupType ends;
+
+                void check_for_end_and_adjust() {
+                    while (this->index < sizeof...(Is)
+                            && !(neq_comparers[this->index](
+                                    this->iters, this->ends))) {
+                        ++this->index;
                     }
+                }
+            public:
+                Iterator(std::size_t i,
+                        IterTupType&& in_iters,
+                        IterTupType&& in_ends)
+                    : index{i},
+                    iters(in_iters),
+                    ends(in_ends)
+                {
+                    this->check_for_end_and_adjust();
+                }
+
+                decltype(auto) operator*() {
+                    return derefers[this->index](this->iters);
+                }
+
+                Iterator& operator++() {
+                    incrementers[this->index](this->iters);
+                    this->check_for_end_and_adjust();
+                    return *this;
+                }
+
+                bool operator!=(const Iterator& other) const {
+                    return this->index != other.index
+                        || (this->index != sizeof...(Is)
+                                && neq_comparers.at(this->index)(
+                                    this->iters,other.iters));
+                }
+
+
+        };
+
+        Iterator begin() {
+            return {
+                0,
+                IterTupType{std::begin(std::get<Is>(this->tup))...},
+                IterTupType{std::end(std::get<Is>(this->tup))...}
             };
+        }
 
-
-        private:
-            using ArrayType =
-                std::array<std::unique_ptr<ChainIterWrapperBase>,
-                sizeof...(Is)>;
-            TupleType containers;
-            ArrayType end_iter_wrappers;
-
-            Chained(TupleType&& tup_containers)
-                : containers(std::move(tup_containers)),
-                end_iter_wrappers{{std::make_unique<
-                    ChainIterWrapper<std::tuple_element_t<Is, TupleType>>>(
-                            std::end(std::get<Is>(this->containers)))...}}
-            { }
-
-        public:
-            class Iterator {
-                private:
-                    using ArrayType =
-                        std::array<std::unique_ptr<ChainIterWrapperBase>,
-                        sizeof...(Is)>;
-
-                    ArrayType iter_wrappers;
-                    const ArrayType& end_iter_wrappers;
-                    std::size_t index;
-
-                    void check_index() {
-                        while (this->index < iter_wrappers.size()
-                                && *this->iter_wrappers[this->index]
-                                    == *this->end_iter_wrappers[this->index]) {
-                            ++this->index;
-                        }
-                    }
-
-
-                public:
-                    Iterator(ArrayType&& iters, ArrayType& ends, std::size_t i)
-                        : iter_wrappers(std::move(iters)),
-                        end_iter_wrappers{ends},
-                        index{i}
-                    {
-                        this->check_index();
-                    }
-
-                    Iterator(const Iterator& other) 
-                        : iter_wrappers{{
-                            // make this not so awful.
-                            std::unique_ptr<ChainIterWrapperBase>{new ChainIterWrapper<std::tuple_element_t<Is, TupleType>>(dynamic_cast<ChainIterWrapper<std::tuple_element_t<Is, TupleType>>&>(*std::get<Is>(other.iter_wrappers)))}...
-                        }},
-                        end_iter_wrappers{other.end_iter_wrappers},
-                        index{other.index}
-                    { }
-
-                    Iterator& operator++() {
-                        ++*this->iter_wrappers[this->index];
-                        this->check_index();
-                        return *this;
-                    }
-
-                    decltype(auto) operator*() {
-                        return **this->iter_wrappers[this->index];
-                    }
-
-                    bool operator!=(const Iterator& other) const {
-                        return this->index != other.index;
-                    }
+        Iterator end() {
+            return {
+                sizeof...(Is),
+                IterTupType{std::end(std::get<Is>(this->tup))...},
+                IterTupType{std::end(std::get<Is>(this->tup))...}
             };
-
-
-            Iterator begin() {
-                ArrayType a{{
-                    std::make_unique<
-                        ChainIterWrapper<std::tuple_element_t<Is, TupleType>>>(
-                                std::begin(std::get<Is>(this->containers))
-                            )...}};
-                return {std::move(a), end_iter_wrappers, 0};
-            }
-
-            Iterator end() {
-                ArrayType a{{std::unique_ptr<
-                    ChainIterWrapper<std::tuple_element_t<Is, TupleType>>>{
-                        nullptr}...}};
-                return {std::move(a), end_iter_wrappers, sizeof...(Is)};
-            }
-    };
+        }
+};
+
+template <typename TupType, std::size_t... Is>
+constexpr std::array<
+    typename Chained<TupType, Is...>::DerefFunc, sizeof...(Is)>
+    Chained<TupType, Is...>::derefers;
+
+template <typename TupType, std::size_t... Is>
+constexpr std::array<
+    typename Chained<TupType, Is...>::IncFunc, sizeof...(Is)>
+    Chained<TupType, Is...>::incrementers;
+
+template <typename TupType, std::size_t... Is>
+constexpr std::array<
+    typename Chained<TupType, Is...>::NeqFunc, sizeof...(Is)>
+    Chained<TupType, Is...>::neq_comparers;
 
     template <typename Container>
     class ChainedFromIterable {

From fbaab61bfeb222cad67b6956a8a35a02a54f2c07 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 12 Nov 2014 21:19:45 -0500
Subject: [PATCH 0546/1866] Makes absorb take universal refs again

Because with just absorb(...) it tries to make copies, which makes
sense.
---
 iterbase.hpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/iterbase.hpp b/iterbase.hpp
index c60713df..d0eade82 100644
--- a/iterbase.hpp
+++ b/iterbase.hpp
@@ -112,7 +112,8 @@ namespace iter {
     // function absorbing all arguments passed to it. used when
     // applying a function to a parameter pack but not passing the evaluated
     // results anywhere
-    void absorb(...) { }
+    template <typename... Ts>
+    void absorb(Ts&&...) { }
 
     namespace detail {
         template <typename Func, typename TupleType, std::size_t... Is>

From b312fa0e4e54d3fa0d333b4f71b72c5f91fa6660 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 12 Nov 2014 21:30:38 -0500
Subject: [PATCH 0547/1866] replaces only .at() with []

---
 chain.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/chain.hpp b/chain.hpp
index f73db8e3..50299693 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -104,7 +104,7 @@ class Chained {
                 bool operator!=(const Iterator& other) const {
                     return this->index != other.index
                         || (this->index != sizeof...(Is)
-                                && neq_comparers.at(this->index)(
+                                && neq_comparers[this->index](
                                     this->iters,other.iters));
                 }
 

From c8b92012a9be224fd80b60bcf0b815ccf2fc9ae4 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 13 Nov 2014 09:11:33 -0500
Subject: [PATCH 0548/1866] adds catch.hpp (under boost license)

---
 catchtest/catch.hpp | 8997 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 8997 insertions(+)
 create mode 100644 catchtest/catch.hpp

diff --git a/catchtest/catch.hpp b/catchtest/catch.hpp
new file mode 100644
index 00000000..6b8dfb5e
--- /dev/null
+++ b/catchtest/catch.hpp
@@ -0,0 +1,8997 @@
+/*
+ *  CATCH v1.0 build 53 (master branch)
+ *  Generated: 2014-08-20 08:08:19.533804
+ *  ----------------------------------------------------------
+ *  This file has been merged from multiple headers. Please don't edit it directly
+ *  Copyright (c) 2012 Two Blue Cubes Ltd. All rights reserved.
+ *
+ *  Distributed under the Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+#ifndef TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
+#define TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
+
+#define TWOBLUECUBES_CATCH_HPP_INCLUDED
+
+// #included from: internal/catch_suppress_warnings.h
+
+#define TWOBLUECUBES_CATCH_SUPPRESS_WARNINGS_H_INCLUDED
+
+#ifdef __clang__
+#pragma clang diagnostic ignored "-Wglobal-constructors"
+#pragma clang diagnostic ignored "-Wvariadic-macros"
+#pragma clang diagnostic ignored "-Wc99-extensions"
+#pragma clang diagnostic ignored "-Wunused-variable"
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#pragma clang diagnostic ignored "-Wc++98-compat"
+#pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
+#elif defined __GNUC__
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wunused-variable"
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wpadded"
+#endif
+
+#ifdef CATCH_CONFIG_MAIN
+#  define CATCH_CONFIG_RUNNER
+#endif
+
+#ifdef CATCH_CONFIG_RUNNER
+#  ifndef CLARA_CONFIG_MAIN
+#    define CLARA_CONFIG_MAIN_NOT_DEFINED
+#    define CLARA_CONFIG_MAIN
+#  endif
+#endif
+
+// #included from: internal/catch_notimplemented_exception.h
+#define TWOBLUECUBES_CATCH_NOTIMPLEMENTED_EXCEPTION_H_INCLUDED
+
+// #included from: catch_common.h
+#define TWOBLUECUBES_CATCH_COMMON_H_INCLUDED
+
+#define INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) name##line
+#define INTERNAL_CATCH_UNIQUE_NAME_LINE( name, line ) INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line )
+#define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __LINE__ )
+
+#define INTERNAL_CATCH_STRINGIFY2( expr ) #expr
+#define INTERNAL_CATCH_STRINGIFY( expr ) INTERNAL_CATCH_STRINGIFY2( expr )
+
+#include <sstream>
+#include <stdexcept>
+#include <algorithm>
+
+// #included from: catch_compiler_capabilities.h
+#define TWOBLUECUBES_CATCH_COMPILER_CAPABILITIES_HPP_INCLUDED
+
+// Much of the following code is based on Boost (1.53)
+
+#ifdef __clang__
+
+#  if __has_feature(cxx_nullptr)
+#    define CATCH_CONFIG_CPP11_NULLPTR
+#  endif
+
+#  if __has_feature(cxx_noexcept)
+#    define CATCH_CONFIG_CPP11_NOEXCEPT
+#  endif
+
+#endif // __clang__
+
+////////////////////////////////////////////////////////////////////////////////
+// Borland
+#ifdef __BORLANDC__
+
+#if (__BORLANDC__ > 0x582 )
+//#define CATCH_CONFIG_SFINAE // Not confirmed
+#endif
+
+#endif // __BORLANDC__
+
+////////////////////////////////////////////////////////////////////////////////
+// EDG
+#ifdef __EDG_VERSION__
+
+#if (__EDG_VERSION__ > 238 )
+//#define CATCH_CONFIG_SFINAE // Not confirmed
+#endif
+
+#endif // __EDG_VERSION__
+
+////////////////////////////////////////////////////////////////////////////////
+// Digital Mars
+#ifdef __DMC__
+
+#if (__DMC__ > 0x840 )
+//#define CATCH_CONFIG_SFINAE // Not confirmed
+#endif
+
+#endif // __DMC__
+
+////////////////////////////////////////////////////////////////////////////////
+// GCC
+#ifdef __GNUC__
+
+#if __GNUC__ < 3
+
+#if (__GNUC_MINOR__ >= 96 )
+//#define CATCH_CONFIG_SFINAE
+#endif
+
+#elif __GNUC__ >= 3
+
+// #define CATCH_CONFIG_SFINAE // Taking this out completely for now
+
+#endif // __GNUC__ < 3
+
+#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6 && defined(__GXX_EXPERIMENTAL_CXX0X__) )
+
+#define CATCH_CONFIG_CPP11_NULLPTR
+#endif
+
+#endif // __GNUC__
+
+////////////////////////////////////////////////////////////////////////////////
+// Visual C++
+#ifdef _MSC_VER
+
+#if (_MSC_VER >= 1310 ) // (VC++ 7.0+)
+//#define CATCH_CONFIG_SFINAE // Not confirmed
+#endif
+
+#endif // _MSC_VER
+
+// Use variadic macros if the compiler supports them
+#if ( defined _MSC_VER && _MSC_VER > 1400 && !defined __EDGE__) || \
+    ( defined __WAVE__ && __WAVE_HAS_VARIADICS ) || \
+    ( defined __GNUC__ && __GNUC__ >= 3 ) || \
+    ( !defined __cplusplus && __STDC_VERSION__ >= 199901L || __cplusplus >= 201103L )
+
+#ifndef CATCH_CONFIG_NO_VARIADIC_MACROS
+#define CATCH_CONFIG_VARIADIC_MACROS
+#endif
+
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// C++ language feature support
+
+// detect language version:
+#if (__cplusplus == 201103L)
+#  define CATCH_CPP11
+#  define CATCH_CPP11_OR_GREATER
+#elif (__cplusplus >= 201103L)
+#  define CATCH_CPP11_OR_GREATER
+#endif
+
+// noexcept support:
+#if defined(CATCH_CONFIG_CPP11_NOEXCEPT) && !defined(CATCH_NOEXCEPT)
+#  define CATCH_NOEXCEPT noexcept
+#  define CATCH_NOEXCEPT_IS(x) noexcept(x)
+#else
+#  define CATCH_NOEXCEPT throw()
+#  define CATCH_NOEXCEPT_IS(x)
+#endif
+
+namespace Catch {
+
+    class NonCopyable {
+        NonCopyable( NonCopyable const& );
+        void operator = ( NonCopyable const& );
+    protected:
+        NonCopyable() {}
+        virtual ~NonCopyable();
+    };
+
+    class SafeBool {
+    public:
+        typedef void (SafeBool::*type)() const;
+
+        static type makeSafe( bool value ) {
+            return value ? &SafeBool::trueValue : 0;
+        }
+    private:
+        void trueValue() const {}
+    };
+
+    template<typename ContainerT>
+    inline void deleteAll( ContainerT& container ) {
+        typename ContainerT::const_iterator it = container.begin();
+        typename ContainerT::const_iterator itEnd = container.end();
+        for(; it != itEnd; ++it )
+            delete *it;
+    }
+    template<typename AssociativeContainerT>
+    inline void deleteAllValues( AssociativeContainerT& container ) {
+        typename AssociativeContainerT::const_iterator it = container.begin();
+        typename AssociativeContainerT::const_iterator itEnd = container.end();
+        for(; it != itEnd; ++it )
+            delete it->second;
+    }
+
+    bool startsWith( std::string const& s, std::string const& prefix );
+    bool endsWith( std::string const& s, std::string const& suffix );
+    bool contains( std::string const& s, std::string const& infix );
+    void toLowerInPlace( std::string& s );
+    std::string toLower( std::string const& s );
+    std::string trim( std::string const& str );
+
+    struct pluralise {
+        pluralise( std::size_t count, std::string const& label );
+
+        friend std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser );
+
+        std::size_t m_count;
+        std::string m_label;
+    };
+
+    struct SourceLineInfo {
+
+        SourceLineInfo();
+        SourceLineInfo( char const* _file, std::size_t _line );
+        SourceLineInfo( SourceLineInfo const& other );
+#  ifdef CATCH_CPP11_OR_GREATER
+        SourceLineInfo( SourceLineInfo && )                  = default;
+        SourceLineInfo& operator = ( SourceLineInfo const& ) = default;
+        SourceLineInfo& operator = ( SourceLineInfo && )     = default;
+#  endif
+        bool empty() const;
+        bool operator == ( SourceLineInfo const& other ) const;
+
+        std::string file;
+        std::size_t line;
+    };
+
+    std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info );
+
+    // This is just here to avoid compiler warnings with macro constants and boolean literals
+    inline bool isTrue( bool value ){ return value; }
+    inline bool alwaysTrue() { return true; }
+    inline bool alwaysFalse() { return false; }
+
+    void throwLogicError( std::string const& message, SourceLineInfo const& locationInfo );
+
+    // Use this in variadic streaming macros to allow
+    //    >> +StreamEndStop
+    // as well as
+    //    >> stuff +StreamEndStop
+    struct StreamEndStop {
+        std::string operator+() {
+            return std::string();
+        }
+    };
+    template<typename T>
+    T const& operator + ( T const& value, StreamEndStop ) {
+        return value;
+    }
+}
+
+#define CATCH_INTERNAL_LINEINFO ::Catch::SourceLineInfo( __FILE__, static_cast<std::size_t>( __LINE__ ) )
+#define CATCH_INTERNAL_ERROR( msg ) ::Catch::throwLogicError( msg, CATCH_INTERNAL_LINEINFO );
+
+#include <ostream>
+
+namespace Catch {
+
+    class NotImplementedException : public std::exception
+    {
+    public:
+        NotImplementedException( SourceLineInfo const& lineInfo );
+        NotImplementedException( NotImplementedException const& ) {}
+
+        virtual ~NotImplementedException() CATCH_NOEXCEPT {}
+
+        virtual const char* what() const CATCH_NOEXCEPT;
+
+    private:
+        std::string m_what;
+        SourceLineInfo m_lineInfo;
+    };
+
+} // end namespace Catch
+
+///////////////////////////////////////////////////////////////////////////////
+#define CATCH_NOT_IMPLEMENTED throw Catch::NotImplementedException( CATCH_INTERNAL_LINEINFO )
+
+// #included from: internal/catch_context.h
+#define TWOBLUECUBES_CATCH_CONTEXT_H_INCLUDED
+
+// #included from: catch_interfaces_generators.h
+#define TWOBLUECUBES_CATCH_INTERFACES_GENERATORS_H_INCLUDED
+
+#include <string>
+
+namespace Catch {
+
+    struct IGeneratorInfo {
+        virtual ~IGeneratorInfo();
+        virtual bool moveNext() = 0;
+        virtual std::size_t getCurrentIndex() const = 0;
+    };
+
+    struct IGeneratorsForTest {
+        virtual ~IGeneratorsForTest();
+
+        virtual IGeneratorInfo& getGeneratorInfo( std::string const& fileInfo, std::size_t size ) = 0;
+        virtual bool moveNext() = 0;
+    };
+
+    IGeneratorsForTest* createGeneratorsForTest();
+
+} // end namespace Catch
+
+// #included from: catch_ptr.hpp
+#define TWOBLUECUBES_CATCH_PTR_HPP_INCLUDED
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+namespace Catch {
+
+    // An intrusive reference counting smart pointer.
+    // T must implement addRef() and release() methods
+    // typically implementing the IShared interface
+    template<typename T>
+    class Ptr {
+    public:
+        Ptr() : m_p( NULL ){}
+        Ptr( T* p ) : m_p( p ){
+            if( m_p )
+                m_p->addRef();
+        }
+        Ptr( Ptr const& other ) : m_p( other.m_p ){
+            if( m_p )
+                m_p->addRef();
+        }
+        ~Ptr(){
+            if( m_p )
+                m_p->release();
+        }
+        void reset() {
+            if( m_p )
+                m_p->release();
+            m_p = NULL;
+        }
+        Ptr& operator = ( T* p ){
+            Ptr temp( p );
+            swap( temp );
+            return *this;
+        }
+        Ptr& operator = ( Ptr const& other ){
+            Ptr temp( other );
+            swap( temp );
+            return *this;
+        }
+        void swap( Ptr& other ) { std::swap( m_p, other.m_p ); }
+        T* get() { return m_p; }
+        const T* get() const{ return m_p; }
+        T& operator*() const { return *m_p; }
+        T* operator->() const { return m_p; }
+        bool operator !() const { return m_p == NULL; }
+        operator SafeBool::type() const { return SafeBool::makeSafe( m_p != NULL ); }
+
+    private:
+        T* m_p;
+    };
+
+    struct IShared : NonCopyable {
+        virtual ~IShared();
+        virtual void addRef() const = 0;
+        virtual void release() const = 0;
+    };
+
+    template<typename T = IShared>
+    struct SharedImpl : T {
+
+        SharedImpl() : m_rc( 0 ){}
+
+        virtual void addRef() const {
+            ++m_rc;
+        }
+        virtual void release() const {
+            if( --m_rc == 0 )
+                delete this;
+        }
+
+        mutable unsigned int m_rc;
+    };
+
+} // end namespace Catch
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+#include <memory>
+#include <vector>
+#include <stdlib.h>
+
+namespace Catch {
+
+    class TestCase;
+    class Stream;
+    struct IResultCapture;
+    struct IRunner;
+    struct IGeneratorsForTest;
+    struct IConfig;
+
+    struct IContext
+    {
+        virtual ~IContext();
+
+        virtual IResultCapture* getResultCapture() = 0;
+        virtual IRunner* getRunner() = 0;
+        virtual size_t getGeneratorIndex( std::string const& fileInfo, size_t totalSize ) = 0;
+        virtual bool advanceGeneratorsForCurrentTest() = 0;
+        virtual Ptr<IConfig const> getConfig() const = 0;
+    };
+
+    struct IMutableContext : IContext
+    {
+        virtual ~IMutableContext();
+        virtual void setResultCapture( IResultCapture* resultCapture ) = 0;
+        virtual void setRunner( IRunner* runner ) = 0;
+        virtual void setConfig( Ptr<IConfig const> const& config ) = 0;
+    };
+
+    IContext& getCurrentContext();
+    IMutableContext& getCurrentMutableContext();
+    void cleanUpContext();
+    Stream createStream( std::string const& streamName );
+
+}
+
+// #included from: internal/catch_test_registry.hpp
+#define TWOBLUECUBES_CATCH_TEST_REGISTRY_HPP_INCLUDED
+
+// #included from: catch_interfaces_testcase.h
+#define TWOBLUECUBES_CATCH_INTERFACES_TESTCASE_H_INCLUDED
+
+#include <vector>
+
+namespace Catch {
+
+    class TestSpec;
+
+    struct ITestCase : IShared {
+        virtual void invoke () const = 0;
+    protected:
+        virtual ~ITestCase();
+    };
+
+    class TestCase;
+    struct IConfig;
+
+    struct ITestCaseRegistry {
+        virtual ~ITestCaseRegistry();
+        virtual std::vector<TestCase> const& getAllTests() const = 0;
+        virtual void getFilteredTests( TestSpec const& testSpec, IConfig const& config, std::vector<TestCase>& matchingTestCases ) const = 0;
+
+    };
+}
+
+namespace Catch {
+
+template<typename C>
+class MethodTestCase : public SharedImpl<ITestCase> {
+
+public:
+    MethodTestCase( void (C::*method)() ) : m_method( method ) {}
+
+    virtual void invoke() const {
+        C obj;
+        (obj.*m_method)();
+    }
+
+private:
+    virtual ~MethodTestCase() {}
+
+    void (C::*m_method)();
+};
+
+typedef void(*TestFunction)();
+
+struct NameAndDesc {
+    NameAndDesc( const char* _name = "", const char* _description= "" )
+    : name( _name ), description( _description )
+    {}
+
+    const char* name;
+    const char* description;
+};
+
+struct AutoReg {
+
+    AutoReg(    TestFunction function,
+                SourceLineInfo const& lineInfo,
+                NameAndDesc const& nameAndDesc );
+
+    template<typename C>
+    AutoReg(    void (C::*method)(),
+                char const* className,
+                NameAndDesc const& nameAndDesc,
+                SourceLineInfo const& lineInfo ) {
+        registerTestCase(   new MethodTestCase<C>( method ),
+                            className,
+                            nameAndDesc,
+                            lineInfo );
+    }
+
+    void registerTestCase(  ITestCase* testCase,
+                            char const* className,
+                            NameAndDesc const& nameAndDesc,
+                            SourceLineInfo const& lineInfo );
+
+    ~AutoReg();
+
+private:
+    AutoReg( AutoReg const& );
+    void operator= ( AutoReg const& );
+};
+
+} // end namespace Catch
+
+#ifdef CATCH_CONFIG_VARIADIC_MACROS
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_TESTCASE( ... ) \
+        static void INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ )(); \
+        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &INTERNAL_CATCH_UNIQUE_NAME(  ____C_A_T_C_H____T_E_S_T____ ), CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( __VA_ARGS__ ) ); }\
+        static void INTERNAL_CATCH_UNIQUE_NAME(  ____C_A_T_C_H____T_E_S_T____ )()
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, ... ) \
+        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &QualifiedMethod, "&" #QualifiedMethod, Catch::NameAndDesc( __VA_ARGS__ ), CATCH_INTERNAL_LINEINFO ); }
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, ... )\
+        namespace{ \
+            struct INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ) : ClassName{ \
+                void test(); \
+            }; \
+            Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( &INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ )::test, #ClassName, Catch::NameAndDesc( __VA_ARGS__ ), CATCH_INTERNAL_LINEINFO ); \
+        } \
+        void INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ )::test()
+
+#else
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_TESTCASE( Name, Desc ) \
+        static void INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ )(); \
+        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &INTERNAL_CATCH_UNIQUE_NAME(  ____C_A_T_C_H____T_E_S_T____ ), CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( Name, Desc ) ); }\
+        static void INTERNAL_CATCH_UNIQUE_NAME(  ____C_A_T_C_H____T_E_S_T____ )()
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, Name, Desc ) \
+        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &QualifiedMethod, "&" #QualifiedMethod, Catch::NameAndDesc( Name, Desc ), CATCH_INTERNAL_LINEINFO ); }
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, TestName, Desc )\
+        namespace{ \
+            struct INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ) : ClassName{ \
+                void test(); \
+            }; \
+            Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( &INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ )::test, #ClassName, Catch::NameAndDesc( TestName, Desc ), CATCH_INTERNAL_LINEINFO ); \
+        } \
+        void INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ )::test()
+
+#endif
+
+// #included from: internal/catch_capture.hpp
+#define TWOBLUECUBES_CATCH_CAPTURE_HPP_INCLUDED
+
+// #included from: catch_result_builder.h
+#define TWOBLUECUBES_CATCH_RESULT_BUILDER_H_INCLUDED
+
+// #included from: catch_result_type.h
+#define TWOBLUECUBES_CATCH_RESULT_TYPE_H_INCLUDED
+
+namespace Catch {
+
+    // ResultWas::OfType enum
+    struct ResultWas { enum OfType {
+        Unknown = -1,
+        Ok = 0,
+        Info = 1,
+        Warning = 2,
+
+        FailureBit = 0x10,
+
+        ExpressionFailed = FailureBit | 1,
+        ExplicitFailure = FailureBit | 2,
+
+        Exception = 0x100 | FailureBit,
+
+        ThrewException = Exception | 1,
+        DidntThrowException = Exception | 2
+
+    }; };
+
+    inline bool isOk( ResultWas::OfType resultType ) {
+        return ( resultType & ResultWas::FailureBit ) == 0;
+    }
+    inline bool isJustInfo( int flags ) {
+        return flags == ResultWas::Info;
+    }
+
+    // ResultDisposition::Flags enum
+    struct ResultDisposition { enum Flags {
+        Normal = 0x00,
+
+        ContinueOnFailure = 0x01,   // Failures fail test, but execution continues
+        FalseTest = 0x02,           // Prefix expression with !
+        SuppressFail = 0x04         // Failures are reported but do not fail the test
+    }; };
+
+    inline ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs ) {
+        return static_cast<ResultDisposition::Flags>( static_cast<int>( lhs ) | static_cast<int>( rhs ) );
+    }
+
+    inline bool shouldContinueOnFailure( int flags )    { return ( flags & ResultDisposition::ContinueOnFailure ) != 0; }
+    inline bool isFalseTest( int flags )                { return ( flags & ResultDisposition::FalseTest ) != 0; }
+    inline bool shouldSuppressFailure( int flags )      { return ( flags & ResultDisposition::SuppressFail ) != 0; }
+
+} // end namespace Catch
+
+// #included from: catch_assertionresult.h
+#define TWOBLUECUBES_CATCH_ASSERTIONRESULT_H_INCLUDED
+
+#include <string>
+
+namespace Catch {
+
+    struct AssertionInfo
+    {
+        AssertionInfo() {}
+        AssertionInfo(  std::string const& _macroName,
+                        SourceLineInfo const& _lineInfo,
+                        std::string const& _capturedExpression,
+                        ResultDisposition::Flags _resultDisposition );
+
+        std::string macroName;
+        SourceLineInfo lineInfo;
+        std::string capturedExpression;
+        ResultDisposition::Flags resultDisposition;
+    };
+
+    struct AssertionResultData
+    {
+        AssertionResultData() : resultType( ResultWas::Unknown ) {}
+
+        std::string reconstructedExpression;
+        std::string message;
+        ResultWas::OfType resultType;
+    };
+
+    class AssertionResult {
+    public:
+        AssertionResult();
+        AssertionResult( AssertionInfo const& info, AssertionResultData const& data );
+        ~AssertionResult();
+#  ifdef CATCH_CPP11_OR_GREATER
+         AssertionResult( AssertionResult const& )              = default;
+         AssertionResult( AssertionResult && )                  = default;
+         AssertionResult& operator = ( AssertionResult const& ) = default;
+         AssertionResult& operator = ( AssertionResult && )     = default;
+#  endif
+
+        bool isOk() const;
+        bool succeeded() const;
+        ResultWas::OfType getResultType() const;
+        bool hasExpression() const;
+        bool hasMessage() const;
+        std::string getExpression() const;
+        std::string getExpressionInMacro() const;
+        bool hasExpandedExpression() const;
+        std::string getExpandedExpression() const;
+        std::string getMessage() const;
+        SourceLineInfo getSourceInfo() const;
+        std::string getTestMacroName() const;
+
+    protected:
+        AssertionInfo m_info;
+        AssertionResultData m_resultData;
+    };
+
+} // end namespace Catch
+
+namespace Catch {
+
+    struct TestFailureException{};
+
+    template<typename T> class ExpressionLhs;
+
+    struct STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison;
+
+    struct CopyableStream {
+        CopyableStream() {}
+        CopyableStream( CopyableStream const& other ) {
+            oss << other.oss.str();
+        }
+        CopyableStream& operator=( CopyableStream const& other ) {
+            oss.str("");
+            oss << other.oss.str();
+            return *this;
+        }
+        std::ostringstream oss;
+    };
+
+    class ResultBuilder {
+    public:
+        ResultBuilder(  char const* macroName,
+                        SourceLineInfo const& lineInfo,
+                        char const* capturedExpression,
+                        ResultDisposition::Flags resultDisposition );
+
+        template<typename T>
+        ExpressionLhs<T const&> operator->* ( T const& operand );
+        ExpressionLhs<bool> operator->* ( bool value );
+
+        template<typename T>
+        ResultBuilder& operator << ( T const& value ) {
+            m_stream.oss << value;
+            return *this;
+        }
+
+        template<typename RhsT> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator && ( RhsT const& );
+        template<typename RhsT> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator || ( RhsT const& );
+
+        ResultBuilder& setResultType( ResultWas::OfType result );
+        ResultBuilder& setResultType( bool result );
+        ResultBuilder& setLhs( std::string const& lhs );
+        ResultBuilder& setRhs( std::string const& rhs );
+        ResultBuilder& setOp( std::string const& op );
+
+        void endExpression();
+
+        std::string reconstructExpression() const;
+        AssertionResult build() const;
+
+        void useActiveException( ResultDisposition::Flags resultDisposition = ResultDisposition::Normal );
+        void captureResult( ResultWas::OfType resultType );
+        void captureExpression();
+        void react();
+        bool shouldDebugBreak() const;
+        bool allowThrows() const;
+
+    private:
+        AssertionInfo m_assertionInfo;
+        AssertionResultData m_data;
+        struct ExprComponents {
+            ExprComponents() : testFalse( false ) {}
+            bool testFalse;
+            std::string lhs, rhs, op;
+        } m_exprComponents;
+        CopyableStream m_stream;
+
+        bool m_shouldDebugBreak;
+        bool m_shouldThrow;
+    };
+
+} // namespace Catch
+
+// Include after due to circular dependency:
+// #included from: catch_expression_lhs.hpp
+#define TWOBLUECUBES_CATCH_EXPRESSION_LHS_HPP_INCLUDED
+
+// #included from: catch_evaluate.hpp
+#define TWOBLUECUBES_CATCH_EVALUATE_HPP_INCLUDED
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4389) // '==' : signed/unsigned mismatch
+#endif
+
+#include <cstddef>
+
+namespace Catch {
+namespace Internal {
+
+    enum Operator {
+        IsEqualTo,
+        IsNotEqualTo,
+        IsLessThan,
+        IsGreaterThan,
+        IsLessThanOrEqualTo,
+        IsGreaterThanOrEqualTo
+    };
+
+    template<Operator Op> struct OperatorTraits             { static const char* getName(){ return "*error*"; } };
+    template<> struct OperatorTraits<IsEqualTo>             { static const char* getName(){ return "=="; } };
+    template<> struct OperatorTraits<IsNotEqualTo>          { static const char* getName(){ return "!="; } };
+    template<> struct OperatorTraits<IsLessThan>            { static const char* getName(){ return "<"; } };
+    template<> struct OperatorTraits<IsGreaterThan>         { static const char* getName(){ return ">"; } };
+    template<> struct OperatorTraits<IsLessThanOrEqualTo>   { static const char* getName(){ return "<="; } };
+    template<> struct OperatorTraits<IsGreaterThanOrEqualTo>{ static const char* getName(){ return ">="; } };
+
+    template<typename T>
+    inline T& opCast(T const& t) { return const_cast<T&>(t); }
+
+// nullptr_t support based on pull request #154 from Konstantin Baumann
+#ifdef CATCH_CONFIG_CPP11_NULLPTR
+    inline std::nullptr_t opCast(std::nullptr_t) { return nullptr; }
+#endif // CATCH_CONFIG_CPP11_NULLPTR
+
+    // So the compare overloads can be operator agnostic we convey the operator as a template
+    // enum, which is used to specialise an Evaluator for doing the comparison.
+    template<typename T1, typename T2, Operator Op>
+    class Evaluator{};
+
+    template<typename T1, typename T2>
+    struct Evaluator<T1, T2, IsEqualTo> {
+        static bool evaluate( T1 const& lhs, T2 const& rhs) {
+            return opCast( lhs ) ==  opCast( rhs );
+        }
+    };
+    template<typename T1, typename T2>
+    struct Evaluator<T1, T2, IsNotEqualTo> {
+        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
+            return opCast( lhs ) != opCast( rhs );
+        }
+    };
+    template<typename T1, typename T2>
+    struct Evaluator<T1, T2, IsLessThan> {
+        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
+            return opCast( lhs ) < opCast( rhs );
+        }
+    };
+    template<typename T1, typename T2>
+    struct Evaluator<T1, T2, IsGreaterThan> {
+        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
+            return opCast( lhs ) > opCast( rhs );
+        }
+    };
+    template<typename T1, typename T2>
+    struct Evaluator<T1, T2, IsGreaterThanOrEqualTo> {
+        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
+            return opCast( lhs ) >= opCast( rhs );
+        }
+    };
+    template<typename T1, typename T2>
+    struct Evaluator<T1, T2, IsLessThanOrEqualTo> {
+        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
+            return opCast( lhs ) <= opCast( rhs );
+        }
+    };
+
+    template<Operator Op, typename T1, typename T2>
+    bool applyEvaluator( T1 const& lhs, T2 const& rhs ) {
+        return Evaluator<T1, T2, Op>::evaluate( lhs, rhs );
+    }
+
+    // This level of indirection allows us to specialise for integer types
+    // to avoid signed/ unsigned warnings
+
+    // "base" overload
+    template<Operator Op, typename T1, typename T2>
+    bool compare( T1 const& lhs, T2 const& rhs ) {
+        return Evaluator<T1, T2, Op>::evaluate( lhs, rhs );
+    }
+
+    // unsigned X to int
+    template<Operator Op> bool compare( unsigned int lhs, int rhs ) {
+        return applyEvaluator<Op>( lhs, static_cast<unsigned int>( rhs ) );
+    }
+    template<Operator Op> bool compare( unsigned long lhs, int rhs ) {
+        return applyEvaluator<Op>( lhs, static_cast<unsigned int>( rhs ) );
+    }
+    template<Operator Op> bool compare( unsigned char lhs, int rhs ) {
+        return applyEvaluator<Op>( lhs, static_cast<unsigned int>( rhs ) );
+    }
+
+    // unsigned X to long
+    template<Operator Op> bool compare( unsigned int lhs, long rhs ) {
+        return applyEvaluator<Op>( lhs, static_cast<unsigned long>( rhs ) );
+    }
+    template<Operator Op> bool compare( unsigned long lhs, long rhs ) {
+        return applyEvaluator<Op>( lhs, static_cast<unsigned long>( rhs ) );
+    }
+    template<Operator Op> bool compare( unsigned char lhs, long rhs ) {
+        return applyEvaluator<Op>( lhs, static_cast<unsigned long>( rhs ) );
+    }
+
+    // int to unsigned X
+    template<Operator Op> bool compare( int lhs, unsigned int rhs ) {
+        return applyEvaluator<Op>( static_cast<unsigned int>( lhs ), rhs );
+    }
+    template<Operator Op> bool compare( int lhs, unsigned long rhs ) {
+        return applyEvaluator<Op>( static_cast<unsigned int>( lhs ), rhs );
+    }
+    template<Operator Op> bool compare( int lhs, unsigned char rhs ) {
+        return applyEvaluator<Op>( static_cast<unsigned int>( lhs ), rhs );
+    }
+
+    // long to unsigned X
+    template<Operator Op> bool compare( long lhs, unsigned int rhs ) {
+        return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
+    }
+    template<Operator Op> bool compare( long lhs, unsigned long rhs ) {
+        return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
+    }
+    template<Operator Op> bool compare( long lhs, unsigned char rhs ) {
+        return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
+    }
+
+    // pointer to long (when comparing against NULL)
+    template<Operator Op, typename T> bool compare( long lhs, T* rhs ) {
+        return Evaluator<T*, T*, Op>::evaluate( reinterpret_cast<T*>( lhs ), rhs );
+    }
+    template<Operator Op, typename T> bool compare( T* lhs, long rhs ) {
+        return Evaluator<T*, T*, Op>::evaluate( lhs, reinterpret_cast<T*>( rhs ) );
+    }
+
+    // pointer to int (when comparing against NULL)
+    template<Operator Op, typename T> bool compare( int lhs, T* rhs ) {
+        return Evaluator<T*, T*, Op>::evaluate( reinterpret_cast<T*>( lhs ), rhs );
+    }
+    template<Operator Op, typename T> bool compare( T* lhs, int rhs ) {
+        return Evaluator<T*, T*, Op>::evaluate( lhs, reinterpret_cast<T*>( rhs ) );
+    }
+
+#ifdef CATCH_CONFIG_CPP11_NULLPTR
+    // pointer to nullptr_t (when comparing against nullptr)
+    template<Operator Op, typename T> bool compare( std::nullptr_t, T* rhs ) {
+        return Evaluator<T*, T*, Op>::evaluate( NULL, rhs );
+    }
+    template<Operator Op, typename T> bool compare( T* lhs, std::nullptr_t ) {
+        return Evaluator<T*, T*, Op>::evaluate( lhs, NULL );
+    }
+#endif // CATCH_CONFIG_CPP11_NULLPTR
+
+} // end of namespace Internal
+} // end of namespace Catch
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+// #included from: catch_tostring.h
+#define TWOBLUECUBES_CATCH_TOSTRING_H_INCLUDED
+
+// #included from: catch_sfinae.hpp
+#define TWOBLUECUBES_CATCH_SFINAE_HPP_INCLUDED
+
+// Try to detect if the current compiler supports SFINAE
+
+namespace Catch {
+
+    struct TrueType {
+        static const bool value = true;
+        typedef void Enable;
+        char sizer[1];
+    };
+    struct FalseType {
+        static const bool value = false;
+        typedef void Disable;
+        char sizer[2];
+    };
+
+#ifdef CATCH_CONFIG_SFINAE
+
+    template<bool> struct NotABooleanExpression;
+
+    template<bool c> struct If : NotABooleanExpression<c> {};
+    template<> struct If<true> : TrueType {};
+    template<> struct If<false> : FalseType {};
+
+    template<int size> struct SizedIf;
+    template<> struct SizedIf<sizeof(TrueType)> : TrueType {};
+    template<> struct SizedIf<sizeof(FalseType)> : FalseType {};
+
+#endif // CATCH_CONFIG_SFINAE
+
+} // end namespace Catch
+
+#include <sstream>
+#include <iomanip>
+#include <limits>
+#include <vector>
+#include <cstddef>
+
+#ifdef __OBJC__
+// #included from: catch_objc_arc.hpp
+#define TWOBLUECUBES_CATCH_OBJC_ARC_HPP_INCLUDED
+
+#import <Foundation/Foundation.h>
+
+#ifdef __has_feature
+#define CATCH_ARC_ENABLED __has_feature(objc_arc)
+#else
+#define CATCH_ARC_ENABLED 0
+#endif
+
+void arcSafeRelease( NSObject* obj );
+id performOptionalSelector( id obj, SEL sel );
+
+#if !CATCH_ARC_ENABLED
+inline void arcSafeRelease( NSObject* obj ) {
+    [obj release];
+}
+inline id performOptionalSelector( id obj, SEL sel ) {
+    if( [obj respondsToSelector: sel] )
+        return [obj performSelector: sel];
+    return nil;
+}
+#define CATCH_UNSAFE_UNRETAINED
+#define CATCH_ARC_STRONG
+#else
+inline void arcSafeRelease( NSObject* ){}
+inline id performOptionalSelector( id obj, SEL sel ) {
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
+#endif
+    if( [obj respondsToSelector: sel] )
+        return [obj performSelector: sel];
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+    return nil;
+}
+#define CATCH_UNSAFE_UNRETAINED __unsafe_unretained
+#define CATCH_ARC_STRONG __strong
+#endif
+
+#endif
+
+namespace Catch {
+namespace Detail {
+
+// SFINAE is currently disabled by default for all compilers.
+// If the non SFINAE version of IsStreamInsertable is ambiguous for you
+// and your compiler supports SFINAE, try #defining CATCH_CONFIG_SFINAE
+#ifdef CATCH_CONFIG_SFINAE
+
+    template<typename T>
+    class IsStreamInsertableHelper {
+        template<int N> struct TrueIfSizeable : TrueType {};
+
+        template<typename T2>
+        static TrueIfSizeable<sizeof((*(std::ostream*)0) << *((T2 const*)0))> dummy(T2*);
+        static FalseType dummy(...);
+
+    public:
+        typedef SizedIf<sizeof(dummy((T*)0))> type;
+    };
+
+    template<typename T>
+    struct IsStreamInsertable : IsStreamInsertableHelper<T>::type {};
+
+#else
+
+    struct BorgType {
+        template<typename T> BorgType( T const& );
+    };
+
+    TrueType& testStreamable( std::ostream& );
+    FalseType testStreamable( FalseType );
+
+    FalseType operator<<( std::ostream const&, BorgType const& );
+
+    template<typename T>
+    struct IsStreamInsertable {
+        static std::ostream &s;
+        static T  const&t;
+        enum { value = sizeof( testStreamable(s << t) ) == sizeof( TrueType ) };
+    };
+
+#endif
+
+    template<bool C>
+    struct StringMakerBase {
+        template<typename T>
+        static std::string convert( T const& ) { return "{?}"; }
+    };
+
+    template<>
+    struct StringMakerBase<true> {
+        template<typename T>
+        static std::string convert( T const& _value ) {
+            std::ostringstream oss;
+            oss << _value;
+            return oss.str();
+        }
+    };
+
+    std::string rawMemoryToString( const void *object, std::size_t size );
+
+    template<typename T>
+    inline std::string rawMemoryToString( const T& object ) {
+      return rawMemoryToString( &object, sizeof(object) );
+    }
+
+} // end namespace Detail
+
+template<typename T>
+std::string toString( T const& value );
+
+template<typename T>
+struct StringMaker :
+    Detail::StringMakerBase<Detail::IsStreamInsertable<T>::value> {};
+
+template<typename T>
+struct StringMaker<T*> {
+    template<typename U>
+    static std::string convert( U* p ) {
+        if( !p )
+            return INTERNAL_CATCH_STRINGIFY( NULL );
+        else
+            return Detail::rawMemoryToString( p );
+    }
+};
+
+template<typename R, typename C>
+struct StringMaker<R C::*> {
+    static std::string convert( R C::* p ) {
+        if( !p )
+            return INTERNAL_CATCH_STRINGIFY( NULL );
+        else
+            return Detail::rawMemoryToString( p );
+    }
+};
+
+namespace Detail {
+    template<typename InputIterator>
+    std::string rangeToString( InputIterator first, InputIterator last );
+}
+
+template<typename T, typename Allocator>
+struct StringMaker<std::vector<T, Allocator> > {
+    static std::string convert( std::vector<T,Allocator> const& v ) {
+        return Detail::rangeToString( v.begin(), v.end() );
+    }
+};
+
+namespace Detail {
+    template<typename T>
+    std::string makeString( T const& value ) {
+        return StringMaker<T>::convert( value );
+    }
+} // end namespace Detail
+
+/// \brief converts any type to a string
+///
+/// The default template forwards on to ostringstream - except when an
+/// ostringstream overload does not exist - in which case it attempts to detect
+/// that and writes {?}.
+/// Overload (not specialise) this template for custom typs that you don't want
+/// to provide an ostream overload for.
+template<typename T>
+std::string toString( T const& value ) {
+    return StringMaker<T>::convert( value );
+}
+
+// Built in overloads
+
+std::string toString( std::string const& value );
+std::string toString( std::wstring const& value );
+std::string toString( const char* const value );
+std::string toString( char* const value );
+std::string toString( const wchar_t* const value );
+std::string toString( wchar_t* const value );
+std::string toString( int value );
+std::string toString( unsigned long value );
+std::string toString( unsigned int value );
+std::string toString( const double value );
+std::string toString( const float value );
+std::string toString( bool value );
+std::string toString( char value );
+std::string toString( signed char value );
+std::string toString( unsigned char value );
+
+#ifdef CATCH_CONFIG_CPP11_NULLPTR
+std::string toString( std::nullptr_t );
+#endif
+
+#ifdef __OBJC__
+    std::string toString( NSString const * const& nsstring );
+    std::string toString( NSString * CATCH_ARC_STRONG const& nsstring );
+    std::string toString( NSObject* const& nsObject );
+#endif
+
+    namespace Detail {
+    template<typename InputIterator>
+    std::string rangeToString( InputIterator first, InputIterator last ) {
+        std::ostringstream oss;
+        oss << "{ ";
+        if( first != last ) {
+            oss << toString( *first );
+            for( ++first ; first != last ; ++first ) {
+                oss << ", " << toString( *first );
+            }
+        }
+        oss << " }";
+        return oss.str();
+    }
+}
+
+} // end namespace Catch
+
+namespace Catch {
+
+// Wraps the LHS of an expression and captures the operator and RHS (if any) -
+// wrapping them all in a ResultBuilder object
+template<typename T>
+class ExpressionLhs {
+    ExpressionLhs& operator = ( ExpressionLhs const& );
+#  ifdef CATCH_CPP11_OR_GREATER
+    ExpressionLhs& operator = ( ExpressionLhs && ) = delete;
+#  endif
+
+public:
+    ExpressionLhs( ResultBuilder& rb, T lhs ) : m_rb( rb ), m_lhs( lhs ) {}
+#  ifdef CATCH_CPP11_OR_GREATER
+    ExpressionLhs( ExpressionLhs const& ) = default;
+    ExpressionLhs( ExpressionLhs && )     = default;
+#  endif
+
+    template<typename RhsT>
+    ResultBuilder& operator == ( RhsT const& rhs ) {
+        return captureExpression<Internal::IsEqualTo>( rhs );
+    }
+
+    template<typename RhsT>
+    ResultBuilder& operator != ( RhsT const& rhs ) {
+        return captureExpression<Internal::IsNotEqualTo>( rhs );
+    }
+
+    template<typename RhsT>
+    ResultBuilder& operator < ( RhsT const& rhs ) {
+        return captureExpression<Internal::IsLessThan>( rhs );
+    }
+
+    template<typename RhsT>
+    ResultBuilder& operator > ( RhsT const& rhs ) {
+        return captureExpression<Internal::IsGreaterThan>( rhs );
+    }
+
+    template<typename RhsT>
+    ResultBuilder& operator <= ( RhsT const& rhs ) {
+        return captureExpression<Internal::IsLessThanOrEqualTo>( rhs );
+    }
+
+    template<typename RhsT>
+    ResultBuilder& operator >= ( RhsT const& rhs ) {
+        return captureExpression<Internal::IsGreaterThanOrEqualTo>( rhs );
+    }
+
+    ResultBuilder& operator == ( bool rhs ) {
+        return captureExpression<Internal::IsEqualTo>( rhs );
+    }
+
+    ResultBuilder& operator != ( bool rhs ) {
+        return captureExpression<Internal::IsNotEqualTo>( rhs );
+    }
+
+    void endExpression() {
+        bool value = m_lhs ? true : false;
+        m_rb
+            .setLhs( Catch::toString( value ) )
+            .setResultType( value )
+            .endExpression();
+    }
+
+    // Only simple binary expressions are allowed on the LHS.
+    // If more complex compositions are required then place the sub expression in parentheses
+    template<typename RhsT> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator + ( RhsT const& );
+    template<typename RhsT> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator - ( RhsT const& );
+    template<typename RhsT> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator / ( RhsT const& );
+    template<typename RhsT> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator * ( RhsT const& );
+    template<typename RhsT> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator && ( RhsT const& );
+    template<typename RhsT> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator || ( RhsT const& );
+
+private:
+    template<Internal::Operator Op, typename RhsT>
+    ResultBuilder& captureExpression( RhsT const& rhs ) {
+        return m_rb
+            .setResultType( Internal::compare<Op>( m_lhs, rhs ) )
+            .setLhs( Catch::toString( m_lhs ) )
+            .setRhs( Catch::toString( rhs ) )
+            .setOp( Internal::OperatorTraits<Op>::getName() );
+    }
+
+private:
+    ResultBuilder& m_rb;
+    T m_lhs;
+};
+
+} // end namespace Catch
+
+
+namespace Catch {
+
+    template<typename T>
+    inline ExpressionLhs<T const&> ResultBuilder::operator->* ( T const& operand ) {
+        return ExpressionLhs<T const&>( *this, operand );
+    }
+
+    inline ExpressionLhs<bool> ResultBuilder::operator->* ( bool value ) {
+        return ExpressionLhs<bool>( *this, value );
+    }
+
+} // namespace Catch
+
+// #included from: catch_message.h
+#define TWOBLUECUBES_CATCH_MESSAGE_H_INCLUDED
+
+#include <string>
+
+namespace Catch {
+
+    struct MessageInfo {
+        MessageInfo(    std::string const& _macroName,
+                        SourceLineInfo const& _lineInfo,
+                        ResultWas::OfType _type );
+
+        std::string macroName;
+        SourceLineInfo lineInfo;
+        ResultWas::OfType type;
+        std::string message;
+        unsigned int sequence;
+
+        bool operator == ( MessageInfo const& other ) const {
+            return sequence == other.sequence;
+        }
+        bool operator < ( MessageInfo const& other ) const {
+            return sequence < other.sequence;
+        }
+    private:
+        static unsigned int globalCount;
+    };
+
+    struct MessageBuilder {
+        MessageBuilder( std::string const& macroName,
+                        SourceLineInfo const& lineInfo,
+                        ResultWas::OfType type )
+        : m_info( macroName, lineInfo, type )
+        {}
+
+        template<typename T>
+        MessageBuilder& operator << ( T const& value ) {
+            m_stream << value;
+            return *this;
+        }
+
+        MessageInfo m_info;
+        std::ostringstream m_stream;
+    };
+
+    class ScopedMessage {
+    public:
+        ScopedMessage( MessageBuilder const& builder );
+        ScopedMessage( ScopedMessage const& other );
+        ~ScopedMessage();
+
+        MessageInfo m_info;
+    };
+
+} // end namespace Catch
+
+// #included from: catch_interfaces_capture.h
+#define TWOBLUECUBES_CATCH_INTERFACES_CAPTURE_H_INCLUDED
+
+#include <string>
+
+namespace Catch {
+
+    class TestCase;
+    class AssertionResult;
+    struct AssertionInfo;
+    struct SectionInfo;
+    struct MessageInfo;
+    class ScopedMessageBuilder;
+    struct Counts;
+
+    struct IResultCapture {
+
+        virtual ~IResultCapture();
+
+        virtual void assertionEnded( AssertionResult const& result ) = 0;
+        virtual bool sectionStarted(    SectionInfo const& sectionInfo,
+                                        Counts& assertions ) = 0;
+        virtual void sectionEnded( SectionInfo const& name, Counts const& assertions, double _durationInSeconds ) = 0;
+        virtual void pushScopedMessage( MessageInfo const& message ) = 0;
+        virtual void popScopedMessage( MessageInfo const& message ) = 0;
+
+        virtual std::string getCurrentTestName() const = 0;
+        virtual const AssertionResult* getLastResult() const = 0;
+    };
+
+    IResultCapture& getResultCapture();
+}
+
+// #included from: catch_debugger.h
+#define TWOBLUECUBES_CATCH_DEBUGGER_H_INCLUDED
+
+// #included from: catch_platform.h
+#define TWOBLUECUBES_CATCH_PLATFORM_H_INCLUDED
+
+#if defined(__MAC_OS_X_VERSION_MIN_REQUIRED)
+#define CATCH_PLATFORM_MAC
+#elif  defined(__IPHONE_OS_VERSION_MIN_REQUIRED)
+#define CATCH_PLATFORM_IPHONE
+#elif defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER)
+#define CATCH_PLATFORM_WINDOWS
+#endif
+
+#include <string>
+
+namespace Catch{
+
+    bool isDebuggerActive();
+    void writeToDebugConsole( std::string const& text );
+}
+
+#ifdef CATCH_PLATFORM_MAC
+
+    // The following code snippet based on:
+    // http://cocoawithlove.com/2008/03/break-into-debugger.html
+    #ifdef DEBUG
+        #if defined(__ppc64__) || defined(__ppc__)
+            #define CATCH_BREAK_INTO_DEBUGGER() \
+                if( Catch::isDebuggerActive() ) { \
+                    __asm__("li r0, 20\nsc\nnop\nli r0, 37\nli r4, 2\nsc\nnop\n" \
+                    : : : "memory","r0","r3","r4" ); \
+                }
+        #else
+            #define CATCH_BREAK_INTO_DEBUGGER() if( Catch::isDebuggerActive() ) {__asm__("int $3\n" : : );}
+        #endif
+    #endif
+
+#elif defined(_MSC_VER)
+    #define CATCH_BREAK_INTO_DEBUGGER() if( Catch::isDebuggerActive() ) { __debugbreak(); }
+#elif defined(__MINGW32__)
+    extern "C" __declspec(dllimport) void __stdcall DebugBreak();
+    #define CATCH_BREAK_INTO_DEBUGGER() if( Catch::isDebuggerActive() ) { DebugBreak(); }
+#endif
+
+#ifndef CATCH_BREAK_INTO_DEBUGGER
+#define CATCH_BREAK_INTO_DEBUGGER() Catch::alwaysTrue();
+#endif
+
+// #included from: catch_interfaces_runner.h
+#define TWOBLUECUBES_CATCH_INTERFACES_RUNNER_H_INCLUDED
+
+namespace Catch {
+    class TestCase;
+
+    struct IRunner {
+        virtual ~IRunner();
+        virtual bool aborting() const = 0;
+    };
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// In the event of a failure works out if the debugger needs to be invoked
+// and/or an exception thrown and takes appropriate action.
+// This needs to be done as a macro so the debugger will stop in the user
+// source code rather than in Catch library code
+#define INTERNAL_CATCH_REACT( resultBuilder ) \
+    if( resultBuilder.shouldDebugBreak() ) CATCH_BREAK_INTO_DEBUGGER(); \
+    resultBuilder.react();
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_TEST( expr, resultDisposition, macroName ) \
+    do { \
+        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #expr, resultDisposition ); \
+        try { \
+            ( __catchResult->*expr ).endExpression(); \
+        } \
+        catch( ... ) { \
+            __catchResult.useActiveException( Catch::ResultDisposition::Normal ); \
+        } \
+        INTERNAL_CATCH_REACT( __catchResult ) \
+    } while( Catch::isTrue( false && (expr) ) ) // expr here is never evaluated at runtime but it forces the compiler to give it a look
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_IF( expr, resultDisposition, macroName ) \
+    INTERNAL_CATCH_TEST( expr, resultDisposition, macroName ); \
+    if( Catch::getResultCapture().getLastResult()->succeeded() )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_ELSE( expr, resultDisposition, macroName ) \
+    INTERNAL_CATCH_TEST( expr, resultDisposition, macroName ); \
+    if( !Catch::getResultCapture().getLastResult()->succeeded() )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_NO_THROW( expr, resultDisposition, macroName ) \
+    do { \
+        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #expr, resultDisposition ); \
+        try { \
+            expr; \
+            __catchResult.captureResult( Catch::ResultWas::Ok ); \
+        } \
+        catch( ... ) { \
+            __catchResult.useActiveException( resultDisposition ); \
+        } \
+        INTERNAL_CATCH_REACT( __catchResult ) \
+    } while( Catch::alwaysFalse() )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_THROWS( expr, resultDisposition, macroName ) \
+    do { \
+        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #expr, resultDisposition ); \
+        if( __catchResult.allowThrows() ) \
+            try { \
+                expr; \
+                __catchResult.captureResult( Catch::ResultWas::DidntThrowException ); \
+            } \
+            catch( ... ) { \
+                __catchResult.captureResult( Catch::ResultWas::Ok ); \
+            } \
+        else \
+            __catchResult.captureResult( Catch::ResultWas::Ok ); \
+        INTERNAL_CATCH_REACT( __catchResult ) \
+    } while( Catch::alwaysFalse() )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_THROWS_AS( expr, exceptionType, resultDisposition, macroName ) \
+    do { \
+        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #expr, resultDisposition ); \
+        if( __catchResult.allowThrows() ) \
+            try { \
+                expr; \
+                __catchResult.captureResult( Catch::ResultWas::DidntThrowException ); \
+            } \
+            catch( exceptionType ) { \
+                __catchResult.captureResult( Catch::ResultWas::Ok ); \
+            } \
+            catch( ... ) { \
+                __catchResult.useActiveException( resultDisposition ); \
+            } \
+        else \
+            __catchResult.captureResult( Catch::ResultWas::Ok ); \
+        INTERNAL_CATCH_REACT( __catchResult ) \
+    } while( Catch::alwaysFalse() )
+
+///////////////////////////////////////////////////////////////////////////////
+#ifdef CATCH_CONFIG_VARIADIC_MACROS
+    #define INTERNAL_CATCH_MSG( messageType, resultDisposition, macroName, ... ) \
+        do { \
+            Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, "", resultDisposition ); \
+            __catchResult << __VA_ARGS__ + ::Catch::StreamEndStop(); \
+            __catchResult.captureResult( messageType ); \
+            INTERNAL_CATCH_REACT( __catchResult ) \
+        } while( Catch::alwaysFalse() )
+#else
+    #define INTERNAL_CATCH_MSG( messageType, resultDisposition, macroName, log ) \
+        do { \
+            Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, "", resultDisposition ); \
+            __catchResult << log + ::Catch::StreamEndStop(); \
+            __catchResult.captureResult( messageType ); \
+            INTERNAL_CATCH_REACT( __catchResult ) \
+        } while( Catch::alwaysFalse() )
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_INFO( log, macroName ) \
+    Catch::ScopedMessage INTERNAL_CATCH_UNIQUE_NAME( scopedMessage ) = Catch::MessageBuilder( macroName, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log;
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CHECK_THAT( arg, matcher, resultDisposition, macroName ) \
+    do { \
+        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #arg " " #matcher, resultDisposition ); \
+        try { \
+            std::string matcherAsString = ::Catch::Matchers::matcher.toString(); \
+            __catchResult \
+                .setLhs( Catch::toString( arg ) ) \
+                .setRhs( matcherAsString == "{?}" ? #matcher : matcherAsString ) \
+                .setOp( "matches" ) \
+                .setResultType( ::Catch::Matchers::matcher.match( arg ) ); \
+            __catchResult.captureExpression(); \
+        } catch( ... ) { \
+            __catchResult.useActiveException( resultDisposition | Catch::ResultDisposition::ContinueOnFailure ); \
+        } \
+        INTERNAL_CATCH_REACT( __catchResult ) \
+    } while( Catch::alwaysFalse() )
+
+// #included from: internal/catch_section.h
+#define TWOBLUECUBES_CATCH_SECTION_H_INCLUDED
+
+// #included from: catch_section_info.h
+#define TWOBLUECUBES_CATCH_SECTION_INFO_H_INCLUDED
+
+namespace Catch {
+
+    struct SectionInfo {
+        SectionInfo
+            (   SourceLineInfo const& _lineInfo,
+                std::string const& _name,
+                std::string const& _description = std::string() );
+
+        std::string name;
+        std::string description;
+        SourceLineInfo lineInfo;
+    };
+
+} // end namespace Catch
+
+// #included from: catch_totals.hpp
+#define TWOBLUECUBES_CATCH_TOTALS_HPP_INCLUDED
+
+#include <cstddef>
+
+namespace Catch {
+
+    struct Counts {
+        Counts() : passed( 0 ), failed( 0 ), failedButOk( 0 ) {}
+
+        Counts operator - ( Counts const& other ) const {
+            Counts diff;
+            diff.passed = passed - other.passed;
+            diff.failed = failed - other.failed;
+            diff.failedButOk = failedButOk - other.failedButOk;
+            return diff;
+        }
+        Counts& operator += ( Counts const& other ) {
+            passed += other.passed;
+            failed += other.failed;
+            failedButOk += other.failedButOk;
+            return *this;
+        }
+
+        std::size_t total() const {
+            return passed + failed + failedButOk;
+        }
+        bool allPassed() const {
+            return failed == 0 && failedButOk == 0;
+        }
+
+        std::size_t passed;
+        std::size_t failed;
+        std::size_t failedButOk;
+    };
+
+    struct Totals {
+
+        Totals operator - ( Totals const& other ) const {
+            Totals diff;
+            diff.assertions = assertions - other.assertions;
+            diff.testCases = testCases - other.testCases;
+            return diff;
+        }
+
+        Totals delta( Totals const& prevTotals ) const {
+            Totals diff = *this - prevTotals;
+            if( diff.assertions.failed > 0 )
+                ++diff.testCases.failed;
+            else if( diff.assertions.failedButOk > 0 )
+                ++diff.testCases.failedButOk;
+            else
+                ++diff.testCases.passed;
+            return diff;
+        }
+
+        Totals& operator += ( Totals const& other ) {
+            assertions += other.assertions;
+            testCases += other.testCases;
+            return *this;
+        }
+
+        Counts assertions;
+        Counts testCases;
+    };
+}
+
+// #included from: catch_timer.h
+#define TWOBLUECUBES_CATCH_TIMER_H_INCLUDED
+
+#ifdef CATCH_PLATFORM_WINDOWS
+typedef unsigned long long uint64_t;
+#else
+#include <stdint.h>
+#endif
+
+namespace Catch {
+
+    class Timer {
+    public:
+        Timer() : m_ticks( 0 ) {}
+        void start();
+        unsigned int getElapsedNanoseconds() const;
+        unsigned int getElapsedMilliseconds() const;
+        double getElapsedSeconds() const;
+
+    private:
+        uint64_t m_ticks;
+    };
+
+} // namespace Catch
+
+#include <string>
+
+namespace Catch {
+
+    class Section {
+    public:
+        Section( SectionInfo const& info );
+        ~Section();
+
+        // This indicates whether the section should be executed or not
+        operator bool() const;
+
+    private:
+#ifdef CATCH_CPP11_OR_GREATER
+        Section( Section const& )              = delete;
+        Section( Section && )                  = delete;
+        Section& operator = ( Section const& ) = delete;
+        Section& operator = ( Section && )     = delete;
+#else
+        Section( Section const& info );
+        Section& operator = ( Section const& );
+#endif
+        SectionInfo m_info;
+
+        std::string m_name;
+        Counts m_assertions;
+        bool m_sectionIncluded;
+        Timer m_timer;
+    };
+
+} // end namespace Catch
+
+#ifdef CATCH_CONFIG_VARIADIC_MACROS
+    #define INTERNAL_CATCH_SECTION( ... ) \
+        if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, __VA_ARGS__ ) )
+#else
+    #define INTERNAL_CATCH_SECTION( name, desc ) \
+        if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, name, desc ) )
+#endif
+
+// #included from: internal/catch_generators.hpp
+#define TWOBLUECUBES_CATCH_GENERATORS_HPP_INCLUDED
+
+#include <iterator>
+#include <vector>
+#include <string>
+#include <stdlib.h>
+
+namespace Catch {
+
+template<typename T>
+struct IGenerator {
+    virtual ~IGenerator() {}
+    virtual T getValue( std::size_t index ) const = 0;
+    virtual std::size_t size () const = 0;
+};
+
+template<typename T>
+class BetweenGenerator : public IGenerator<T> {
+public:
+    BetweenGenerator( T from, T to ) : m_from( from ), m_to( to ){}
+
+    virtual T getValue( std::size_t index ) const {
+        return m_from+static_cast<int>( index );
+    }
+
+    virtual std::size_t size() const {
+        return static_cast<std::size_t>( 1+m_to-m_from );
+    }
+
+private:
+
+    T m_from;
+    T m_to;
+};
+
+template<typename T>
+class ValuesGenerator : public IGenerator<T> {
+public:
+    ValuesGenerator(){}
+
+    void add( T value ) {
+        m_values.push_back( value );
+    }
+
+    virtual T getValue( std::size_t index ) const {
+        return m_values[index];
+    }
+
+    virtual std::size_t size() const {
+        return m_values.size();
+    }
+
+private:
+    std::vector<T> m_values;
+};
+
+template<typename T>
+class CompositeGenerator {
+public:
+    CompositeGenerator() : m_totalSize( 0 ) {}
+
+    // *** Move semantics, similar to auto_ptr ***
+    CompositeGenerator( CompositeGenerator& other )
+    :   m_fileInfo( other.m_fileInfo ),
+        m_totalSize( 0 )
+    {
+        move( other );
+    }
+
+    CompositeGenerator& setFileInfo( const char* fileInfo ) {
+        m_fileInfo = fileInfo;
+        return *this;
+    }
+
+    ~CompositeGenerator() {
+        deleteAll( m_composed );
+    }
+
+    operator T () const {
+        size_t overallIndex = getCurrentContext().getGeneratorIndex( m_fileInfo, m_totalSize );
+
+        typename std::vector<const IGenerator<T>*>::const_iterator it = m_composed.begin();
+        typename std::vector<const IGenerator<T>*>::const_iterator itEnd = m_composed.end();
+        for( size_t index = 0; it != itEnd; ++it )
+        {
+            const IGenerator<T>* generator = *it;
+            if( overallIndex >= index && overallIndex < index + generator->size() )
+            {
+                return generator->getValue( overallIndex-index );
+            }
+            index += generator->size();
+        }
+        CATCH_INTERNAL_ERROR( "Indexed past end of generated range" );
+        return T(); // Suppress spurious "not all control paths return a value" warning in Visual Studio - if you know how to fix this please do so
+    }
+
+    void add( const IGenerator<T>* generator ) {
+        m_totalSize += generator->size();
+        m_composed.push_back( generator );
+    }
+
+    CompositeGenerator& then( CompositeGenerator& other ) {
+        move( other );
+        return *this;
+    }
+
+    CompositeGenerator& then( T value ) {
+        ValuesGenerator<T>* valuesGen = new ValuesGenerator<T>();
+        valuesGen->add( value );
+        add( valuesGen );
+        return *this;
+    }
+
+private:
+
+    void move( CompositeGenerator& other ) {
+        std::copy( other.m_composed.begin(), other.m_composed.end(), std::back_inserter( m_composed ) );
+        m_totalSize += other.m_totalSize;
+        other.m_composed.clear();
+    }
+
+    std::vector<const IGenerator<T>*> m_composed;
+    std::string m_fileInfo;
+    size_t m_totalSize;
+};
+
+namespace Generators
+{
+    template<typename T>
+    CompositeGenerator<T> between( T from, T to ) {
+        CompositeGenerator<T> generators;
+        generators.add( new BetweenGenerator<T>( from, to ) );
+        return generators;
+    }
+
+    template<typename T>
+    CompositeGenerator<T> values( T val1, T val2 ) {
+        CompositeGenerator<T> generators;
+        ValuesGenerator<T>* valuesGen = new ValuesGenerator<T>();
+        valuesGen->add( val1 );
+        valuesGen->add( val2 );
+        generators.add( valuesGen );
+        return generators;
+    }
+
+    template<typename T>
+    CompositeGenerator<T> values( T val1, T val2, T val3 ){
+        CompositeGenerator<T> generators;
+        ValuesGenerator<T>* valuesGen = new ValuesGenerator<T>();
+        valuesGen->add( val1 );
+        valuesGen->add( val2 );
+        valuesGen->add( val3 );
+        generators.add( valuesGen );
+        return generators;
+    }
+
+    template<typename T>
+    CompositeGenerator<T> values( T val1, T val2, T val3, T val4 ) {
+        CompositeGenerator<T> generators;
+        ValuesGenerator<T>* valuesGen = new ValuesGenerator<T>();
+        valuesGen->add( val1 );
+        valuesGen->add( val2 );
+        valuesGen->add( val3 );
+        valuesGen->add( val4 );
+        generators.add( valuesGen );
+        return generators;
+    }
+
+} // end namespace Generators
+
+using namespace Generators;
+
+} // end namespace Catch
+
+#define INTERNAL_CATCH_LINESTR2( line ) #line
+#define INTERNAL_CATCH_LINESTR( line ) INTERNAL_CATCH_LINESTR2( line )
+
+#define INTERNAL_CATCH_GENERATE( expr ) expr.setFileInfo( __FILE__ "(" INTERNAL_CATCH_LINESTR( __LINE__ ) ")" )
+
+// #included from: internal/catch_interfaces_exception.h
+#define TWOBLUECUBES_CATCH_INTERFACES_EXCEPTION_H_INCLUDED
+
+#include <string>
+// #included from: catch_interfaces_registry_hub.h
+#define TWOBLUECUBES_CATCH_INTERFACES_REGISTRY_HUB_H_INCLUDED
+
+#include <string>
+
+namespace Catch {
+
+    class TestCase;
+    struct ITestCaseRegistry;
+    struct IExceptionTranslatorRegistry;
+    struct IExceptionTranslator;
+    struct IReporterRegistry;
+    struct IReporterFactory;
+
+    struct IRegistryHub {
+        virtual ~IRegistryHub();
+
+        virtual IReporterRegistry const& getReporterRegistry() const = 0;
+        virtual ITestCaseRegistry const& getTestCaseRegistry() const = 0;
+        virtual IExceptionTranslatorRegistry& getExceptionTranslatorRegistry() = 0;
+    };
+
+    struct IMutableRegistryHub {
+        virtual ~IMutableRegistryHub();
+        virtual void registerReporter( std::string const& name, IReporterFactory* factory ) = 0;
+        virtual void registerTest( TestCase const& testInfo ) = 0;
+        virtual void registerTranslator( const IExceptionTranslator* translator ) = 0;
+    };
+
+    IRegistryHub& getRegistryHub();
+    IMutableRegistryHub& getMutableRegistryHub();
+    void cleanUp();
+    std::string translateActiveException();
+
+}
+
+
+namespace Catch {
+
+    typedef std::string(*exceptionTranslateFunction)();
+
+    struct IExceptionTranslator {
+        virtual ~IExceptionTranslator();
+        virtual std::string translate() const = 0;
+    };
+
+    struct IExceptionTranslatorRegistry {
+        virtual ~IExceptionTranslatorRegistry();
+
+        virtual std::string translateActiveException() const = 0;
+    };
+
+    class ExceptionTranslatorRegistrar {
+        template<typename T>
+        class ExceptionTranslator : public IExceptionTranslator {
+        public:
+
+            ExceptionTranslator( std::string(*translateFunction)( T& ) )
+            : m_translateFunction( translateFunction )
+            {}
+
+            virtual std::string translate() const {
+                try {
+                    throw;
+                }
+                catch( T& ex ) {
+                    return m_translateFunction( ex );
+                }
+            }
+
+        protected:
+            std::string(*m_translateFunction)( T& );
+        };
+
+    public:
+        template<typename T>
+        ExceptionTranslatorRegistrar( std::string(*translateFunction)( T& ) ) {
+            getMutableRegistryHub().registerTranslator
+                ( new ExceptionTranslator<T>( translateFunction ) );
+        }
+    };
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature ) \
+    static std::string INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator )( signature ); \
+    namespace{ Catch::ExceptionTranslatorRegistrar INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionRegistrar )( &INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ) ); }\
+    static std::string INTERNAL_CATCH_UNIQUE_NAME(  catch_internal_ExceptionTranslator )( signature )
+
+// #included from: internal/catch_approx.hpp
+#define TWOBLUECUBES_CATCH_APPROX_HPP_INCLUDED
+
+#include <cmath>
+#include <limits>
+
+namespace Catch {
+namespace Detail {
+
+    class Approx {
+    public:
+        explicit Approx ( double value )
+        :   m_epsilon( std::numeric_limits<float>::epsilon()*100 ),
+            m_scale( 1.0 ),
+            m_value( value )
+        {}
+
+        Approx( Approx const& other )
+        :   m_epsilon( other.m_epsilon ),
+            m_scale( other.m_scale ),
+            m_value( other.m_value )
+        {}
+
+        static Approx custom() {
+            return Approx( 0 );
+        }
+
+        Approx operator()( double value ) {
+            Approx approx( value );
+            approx.epsilon( m_epsilon );
+            approx.scale( m_scale );
+            return approx;
+        }
+
+        friend bool operator == ( double lhs, Approx const& rhs ) {
+            // Thanks to Richard Harris for his help refining this formula
+            return fabs( lhs - rhs.m_value ) < rhs.m_epsilon * (rhs.m_scale + (std::max)( fabs(lhs), fabs(rhs.m_value) ) );
+        }
+
+        friend bool operator == ( Approx const& lhs, double rhs ) {
+            return operator==( rhs, lhs );
+        }
+
+        friend bool operator != ( double lhs, Approx const& rhs ) {
+            return !operator==( lhs, rhs );
+        }
+
+        friend bool operator != ( Approx const& lhs, double rhs ) {
+            return !operator==( rhs, lhs );
+        }
+
+        Approx& epsilon( double newEpsilon ) {
+            m_epsilon = newEpsilon;
+            return *this;
+        }
+
+        Approx& scale( double newScale ) {
+            m_scale = newScale;
+            return *this;
+        }
+
+        std::string toString() const {
+            std::ostringstream oss;
+            oss << "Approx( " << Catch::toString( m_value ) << " )";
+            return oss.str();
+        }
+
+    private:
+        double m_epsilon;
+        double m_scale;
+        double m_value;
+    };
+}
+
+template<>
+inline std::string toString<Detail::Approx>( Detail::Approx const& value ) {
+    return value.toString();
+}
+
+} // end namespace Catch
+
+// #included from: internal/catch_matchers.hpp
+#define TWOBLUECUBES_CATCH_MATCHERS_HPP_INCLUDED
+
+namespace Catch {
+namespace Matchers {
+    namespace Impl {
+
+    template<typename ExpressionT>
+    struct Matcher : SharedImpl<IShared>
+    {
+        typedef ExpressionT ExpressionType;
+
+        virtual ~Matcher() {}
+        virtual Ptr<Matcher> clone() const = 0;
+        virtual bool match( ExpressionT const& expr ) const = 0;
+        virtual std::string toString() const = 0;
+    };
+
+    template<typename DerivedT, typename ExpressionT>
+    struct MatcherImpl : Matcher<ExpressionT> {
+
+        virtual Ptr<Matcher<ExpressionT> > clone() const {
+            return Ptr<Matcher<ExpressionT> >( new DerivedT( static_cast<DerivedT const&>( *this ) ) );
+        }
+    };
+
+    namespace Generic {
+
+        template<typename ExpressionT>
+        class AllOf : public MatcherImpl<AllOf<ExpressionT>, ExpressionT> {
+        public:
+
+            AllOf() {}
+            AllOf( AllOf const& other ) : m_matchers( other.m_matchers ) {}
+
+            AllOf& add( Matcher<ExpressionT> const& matcher ) {
+                m_matchers.push_back( matcher.clone() );
+                return *this;
+            }
+            virtual bool match( ExpressionT const& expr ) const
+            {
+                for( std::size_t i = 0; i < m_matchers.size(); ++i )
+                    if( !m_matchers[i]->match( expr ) )
+                        return false;
+                return true;
+            }
+            virtual std::string toString() const {
+                std::ostringstream oss;
+                oss << "( ";
+                for( std::size_t i = 0; i < m_matchers.size(); ++i ) {
+                    if( i != 0 )
+                        oss << " and ";
+                    oss << m_matchers[i]->toString();
+                }
+                oss << " )";
+                return oss.str();
+            }
+
+        private:
+            std::vector<Ptr<Matcher<ExpressionT> > > m_matchers;
+        };
+
+        template<typename ExpressionT>
+        class AnyOf : public MatcherImpl<AnyOf<ExpressionT>, ExpressionT> {
+        public:
+
+            AnyOf() {}
+            AnyOf( AnyOf const& other ) : m_matchers( other.m_matchers ) {}
+
+            AnyOf& add( Matcher<ExpressionT> const& matcher ) {
+                m_matchers.push_back( matcher.clone() );
+                return *this;
+            }
+            virtual bool match( ExpressionT const& expr ) const
+            {
+                for( std::size_t i = 0; i < m_matchers.size(); ++i )
+                    if( m_matchers[i]->match( expr ) )
+                        return true;
+                return false;
+            }
+            virtual std::string toString() const {
+                std::ostringstream oss;
+                oss << "( ";
+                for( std::size_t i = 0; i < m_matchers.size(); ++i ) {
+                    if( i != 0 )
+                        oss << " or ";
+                    oss << m_matchers[i]->toString();
+                }
+                oss << " )";
+                return oss.str();
+            }
+
+        private:
+            std::vector<Ptr<Matcher<ExpressionT> > > m_matchers;
+        };
+
+    }
+
+    namespace StdString {
+
+        inline std::string makeString( std::string const& str ) { return str; }
+        inline std::string makeString( const char* str ) { return str ? std::string( str ) : std::string(); }
+
+        struct Equals : MatcherImpl<Equals, std::string> {
+            Equals( std::string const& str ) : m_str( str ){}
+            Equals( Equals const& other ) : m_str( other.m_str ){}
+
+            virtual ~Equals();
+
+            virtual bool match( std::string const& expr ) const {
+                return m_str == expr;
+            }
+            virtual std::string toString() const {
+                return "equals: \"" + m_str + "\"";
+            }
+
+            std::string m_str;
+        };
+
+        struct Contains : MatcherImpl<Contains, std::string> {
+            Contains( std::string const& substr ) : m_substr( substr ){}
+            Contains( Contains const& other ) : m_substr( other.m_substr ){}
+
+            virtual ~Contains();
+
+            virtual bool match( std::string const& expr ) const {
+                return expr.find( m_substr ) != std::string::npos;
+            }
+            virtual std::string toString() const {
+                return "contains: \"" + m_substr + "\"";
+            }
+
+            std::string m_substr;
+        };
+
+        struct StartsWith : MatcherImpl<StartsWith, std::string> {
+            StartsWith( std::string const& substr ) : m_substr( substr ){}
+            StartsWith( StartsWith const& other ) : m_substr( other.m_substr ){}
+
+            virtual ~StartsWith();
+
+            virtual bool match( std::string const& expr ) const {
+                return expr.find( m_substr ) == 0;
+            }
+            virtual std::string toString() const {
+                return "starts with: \"" + m_substr + "\"";
+            }
+
+            std::string m_substr;
+        };
+
+        struct EndsWith : MatcherImpl<EndsWith, std::string> {
+            EndsWith( std::string const& substr ) : m_substr( substr ){}
+            EndsWith( EndsWith const& other ) : m_substr( other.m_substr ){}
+
+            virtual ~EndsWith();
+
+            virtual bool match( std::string const& expr ) const {
+                return expr.find( m_substr ) == expr.size() - m_substr.size();
+            }
+            virtual std::string toString() const {
+                return "ends with: \"" + m_substr + "\"";
+            }
+
+            std::string m_substr;
+        };
+    } // namespace StdString
+    } // namespace Impl
+
+    // The following functions create the actual matcher objects.
+    // This allows the types to be inferred
+    template<typename ExpressionT>
+    inline Impl::Generic::AllOf<ExpressionT> AllOf( Impl::Matcher<ExpressionT> const& m1,
+                                                    Impl::Matcher<ExpressionT> const& m2 ) {
+        return Impl::Generic::AllOf<ExpressionT>().add( m1 ).add( m2 );
+    }
+    template<typename ExpressionT>
+    inline Impl::Generic::AllOf<ExpressionT> AllOf( Impl::Matcher<ExpressionT> const& m1,
+                                                    Impl::Matcher<ExpressionT> const& m2,
+                                                    Impl::Matcher<ExpressionT> const& m3 ) {
+        return Impl::Generic::AllOf<ExpressionT>().add( m1 ).add( m2 ).add( m3 );
+    }
+    template<typename ExpressionT>
+    inline Impl::Generic::AnyOf<ExpressionT> AnyOf( Impl::Matcher<ExpressionT> const& m1,
+                                                    Impl::Matcher<ExpressionT> const& m2 ) {
+        return Impl::Generic::AnyOf<ExpressionT>().add( m1 ).add( m2 );
+    }
+    template<typename ExpressionT>
+    inline Impl::Generic::AnyOf<ExpressionT> AnyOf( Impl::Matcher<ExpressionT> const& m1,
+                                                    Impl::Matcher<ExpressionT> const& m2,
+                                                    Impl::Matcher<ExpressionT> const& m3 ) {
+        return Impl::Generic::AnyOf<ExpressionT>().add( m1 ).add( m2 ).add( m3 );
+    }
+
+    inline Impl::StdString::Equals      Equals( std::string const& str ) {
+        return Impl::StdString::Equals( str );
+    }
+    inline Impl::StdString::Equals      Equals( const char* str ) {
+        return Impl::StdString::Equals( Impl::StdString::makeString( str ) );
+    }
+    inline Impl::StdString::Contains    Contains( std::string const& substr ) {
+        return Impl::StdString::Contains( substr );
+    }
+    inline Impl::StdString::Contains    Contains( const char* substr ) {
+        return Impl::StdString::Contains( Impl::StdString::makeString( substr ) );
+    }
+    inline Impl::StdString::StartsWith  StartsWith( std::string const& substr ) {
+        return Impl::StdString::StartsWith( substr );
+    }
+    inline Impl::StdString::StartsWith  StartsWith( const char* substr ) {
+        return Impl::StdString::StartsWith( Impl::StdString::makeString( substr ) );
+    }
+    inline Impl::StdString::EndsWith    EndsWith( std::string const& substr ) {
+        return Impl::StdString::EndsWith( substr );
+    }
+    inline Impl::StdString::EndsWith    EndsWith( const char* substr ) {
+        return Impl::StdString::EndsWith( Impl::StdString::makeString( substr ) );
+    }
+
+} // namespace Matchers
+
+using namespace Matchers;
+
+} // namespace Catch
+
+// #included from: internal/catch_interfaces_tag_alias_registry.h
+#define TWOBLUECUBES_CATCH_INTERFACES_TAG_ALIAS_REGISTRY_H_INCLUDED
+
+// #included from: catch_tag_alias.h
+#define TWOBLUECUBES_CATCH_TAG_ALIAS_H_INCLUDED
+
+#include <string>
+
+namespace Catch {
+
+    struct TagAlias {
+        TagAlias( std::string _tag, SourceLineInfo _lineInfo ) : tag( _tag ), lineInfo( _lineInfo ) {}
+
+        std::string tag;
+        SourceLineInfo lineInfo;
+    };
+
+    struct RegistrarForTagAliases {
+        RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo );
+    };
+
+} // end namespace Catch
+
+#define CATCH_REGISTER_TAG_ALIAS( alias, spec ) namespace{ Catch::RegistrarForTagAliases INTERNAL_CATCH_UNIQUE_NAME( AutoRegisterTagAlias )( alias, spec, CATCH_INTERNAL_LINEINFO ); }
+// #included from: catch_option.hpp
+#define TWOBLUECUBES_CATCH_OPTION_HPP_INCLUDED
+
+namespace Catch {
+
+    // An optional type
+    template<typename T>
+    class Option {
+    public:
+        Option() : nullableValue( NULL ) {}
+        Option( T const& _value )
+        : nullableValue( new( storage ) T( _value ) )
+        {}
+        Option( Option const& _other )
+        : nullableValue( _other ? new( storage ) T( *_other ) : NULL )
+        {}
+
+        ~Option() {
+            reset();
+        }
+
+        Option& operator= ( Option const& _other ) {
+            if( &_other != this ) {
+                reset();
+                if( _other )
+                    nullableValue = new( storage ) T( *_other );
+            }
+            return *this;
+        }
+        Option& operator = ( T const& _value ) {
+            reset();
+            nullableValue = new( storage ) T( _value );
+            return *this;
+        }
+
+        void reset() {
+            if( nullableValue )
+                nullableValue->~T();
+            nullableValue = NULL;
+        }
+
+        T& operator*() { return *nullableValue; }
+        T const& operator*() const { return *nullableValue; }
+        T* operator->() { return nullableValue; }
+        const T* operator->() const { return nullableValue; }
+
+        T valueOr( T const& defaultValue ) const {
+            return nullableValue ? *nullableValue : defaultValue;
+        }
+
+        bool some() const { return nullableValue != NULL; }
+        bool none() const { return nullableValue == NULL; }
+
+        bool operator !() const { return nullableValue == NULL; }
+        operator SafeBool::type() const {
+            return SafeBool::makeSafe( some() );
+        }
+
+    private:
+        T* nullableValue;
+        char storage[sizeof(T)];
+    };
+
+} // end namespace Catch
+
+namespace Catch {
+
+    struct ITagAliasRegistry {
+        virtual ~ITagAliasRegistry();
+        virtual Option<TagAlias> find( std::string const& alias ) const = 0;
+        virtual std::string expandAliases( std::string const& unexpandedTestSpec ) const = 0;
+
+        static ITagAliasRegistry const& get();
+    };
+
+} // end namespace Catch
+
+// These files are included here so the single_include script doesn't put them
+// in the conditionally compiled sections
+// #included from: internal/catch_test_case_info.h
+#define TWOBLUECUBES_CATCH_TEST_CASE_INFO_H_INCLUDED
+
+#include <string>
+#include <set>
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+namespace Catch {
+
+    struct ITestCase;
+
+    struct TestCaseInfo {
+        enum SpecialProperties{
+            None = 0,
+            IsHidden = 1 << 1,
+            ShouldFail = 1 << 2,
+            MayFail = 1 << 3,
+            Throws = 1 << 4
+        };
+
+        TestCaseInfo(   std::string const& _name,
+                        std::string const& _className,
+                        std::string const& _description,
+                        std::set<std::string> const& _tags,
+                        SourceLineInfo const& _lineInfo );
+
+        TestCaseInfo( TestCaseInfo const& other );
+
+        bool isHidden() const;
+        bool throws() const;
+        bool okToFail() const;
+        bool expectedToFail() const;
+
+        std::string name;
+        std::string className;
+        std::string description;
+        std::set<std::string> tags;
+        std::set<std::string> lcaseTags;
+        std::string tagsAsString;
+        SourceLineInfo lineInfo;
+        SpecialProperties properties;
+    };
+
+    class TestCase : public TestCaseInfo {
+    public:
+
+        TestCase( ITestCase* testCase, TestCaseInfo const& info );
+        TestCase( TestCase const& other );
+
+        TestCase withName( std::string const& _newName ) const;
+
+        void invoke() const;
+
+        TestCaseInfo const& getTestCaseInfo() const;
+
+        void swap( TestCase& other );
+        bool operator == ( TestCase const& other ) const;
+        bool operator < ( TestCase const& other ) const;
+        TestCase& operator = ( TestCase const& other );
+
+    private:
+        Ptr<ITestCase> test;
+    };
+
+    TestCase makeTestCase(  ITestCase* testCase,
+                            std::string const& className,
+                            std::string const& name,
+                            std::string const& description,
+                            SourceLineInfo const& lineInfo );
+}
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+
+#ifdef __OBJC__
+// #included from: internal/catch_objc.hpp
+#define TWOBLUECUBES_CATCH_OBJC_HPP_INCLUDED
+
+#import <objc/runtime.h>
+
+#include <string>
+
+// NB. Any general catch headers included here must be included
+// in catch.hpp first to make sure they are included by the single
+// header for non obj-usage
+
+///////////////////////////////////////////////////////////////////////////////
+// This protocol is really only here for (self) documenting purposes, since
+// all its methods are optional.
+@protocol OcFixture
+
+@optional
+
+-(void) setUp;
+-(void) tearDown;
+
+@end
+
+namespace Catch {
+
+    class OcMethod : public SharedImpl<ITestCase> {
+
+    public:
+        OcMethod( Class cls, SEL sel ) : m_cls( cls ), m_sel( sel ) {}
+
+        virtual void invoke() const {
+            id obj = [[m_cls alloc] init];
+
+            performOptionalSelector( obj, @selector(setUp)  );
+            performOptionalSelector( obj, m_sel );
+            performOptionalSelector( obj, @selector(tearDown)  );
+
+            arcSafeRelease( obj );
+        }
+    private:
+        virtual ~OcMethod() {}
+
+        Class m_cls;
+        SEL m_sel;
+    };
+
+    namespace Detail{
+
+        inline std::string getAnnotation(   Class cls,
+                                            std::string const& annotationName,
+                                            std::string const& testCaseName ) {
+            NSString* selStr = [[NSString alloc] initWithFormat:@"Catch_%s_%s", annotationName.c_str(), testCaseName.c_str()];
+            SEL sel = NSSelectorFromString( selStr );
+            arcSafeRelease( selStr );
+            id value = performOptionalSelector( cls, sel );
+            if( value )
+                return [(NSString*)value UTF8String];
+            return "";
+        }
+    }
+
+    inline size_t registerTestMethods() {
+        size_t noTestMethods = 0;
+        int noClasses = objc_getClassList( NULL, 0 );
+
+        Class* classes = (CATCH_UNSAFE_UNRETAINED Class *)malloc( sizeof(Class) * noClasses);
+        objc_getClassList( classes, noClasses );
+
+        for( int c = 0; c < noClasses; c++ ) {
+            Class cls = classes[c];
+            {
+                u_int count;
+                Method* methods = class_copyMethodList( cls, &count );
+                for( u_int m = 0; m < count ; m++ ) {
+                    SEL selector = method_getName(methods[m]);
+                    std::string methodName = sel_getName(selector);
+                    if( startsWith( methodName, "Catch_TestCase_" ) ) {
+                        std::string testCaseName = methodName.substr( 15 );
+                        std::string name = Detail::getAnnotation( cls, "Name", testCaseName );
+                        std::string desc = Detail::getAnnotation( cls, "Description", testCaseName );
+                        const char* className = class_getName( cls );
+
+                        getMutableRegistryHub().registerTest( makeTestCase( new OcMethod( cls, selector ), className, name.c_str(), desc.c_str(), SourceLineInfo() ) );
+                        noTestMethods++;
+                    }
+                }
+                free(methods);
+            }
+        }
+        return noTestMethods;
+    }
+
+    namespace Matchers {
+        namespace Impl {
+        namespace NSStringMatchers {
+
+            template<typename MatcherT>
+            struct StringHolder : MatcherImpl<MatcherT, NSString*>{
+                StringHolder( NSString* substr ) : m_substr( [substr copy] ){}
+                StringHolder( StringHolder const& other ) : m_substr( [other.m_substr copy] ){}
+                StringHolder() {
+                    arcSafeRelease( m_substr );
+                }
+
+                NSString* m_substr;
+            };
+
+            struct Equals : StringHolder<Equals> {
+                Equals( NSString* substr ) : StringHolder( substr ){}
+
+                virtual bool match( ExpressionType const& str ) const {
+                    return  (str != nil || m_substr == nil ) &&
+                            [str isEqualToString:m_substr];
+                }
+
+                virtual std::string toString() const {
+                    return "equals string: " + Catch::toString( m_substr );
+                }
+            };
+
+            struct Contains : StringHolder<Contains> {
+                Contains( NSString* substr ) : StringHolder( substr ){}
+
+                virtual bool match( ExpressionType const& str ) const {
+                    return  (str != nil || m_substr == nil ) &&
+                            [str rangeOfString:m_substr].location != NSNotFound;
+                }
+
+                virtual std::string toString() const {
+                    return "contains string: " + Catch::toString( m_substr );
+                }
+            };
+
+            struct StartsWith : StringHolder<StartsWith> {
+                StartsWith( NSString* substr ) : StringHolder( substr ){}
+
+                virtual bool match( ExpressionType const& str ) const {
+                    return  (str != nil || m_substr == nil ) &&
+                            [str rangeOfString:m_substr].location == 0;
+                }
+
+                virtual std::string toString() const {
+                    return "starts with: " + Catch::toString( m_substr );
+                }
+            };
+            struct EndsWith : StringHolder<EndsWith> {
+                EndsWith( NSString* substr ) : StringHolder( substr ){}
+
+                virtual bool match( ExpressionType const& str ) const {
+                    return  (str != nil || m_substr == nil ) &&
+                            [str rangeOfString:m_substr].location == [str length] - [m_substr length];
+                }
+
+                virtual std::string toString() const {
+                    return "ends with: " + Catch::toString( m_substr );
+                }
+            };
+
+        } // namespace NSStringMatchers
+        } // namespace Impl
+
+        inline Impl::NSStringMatchers::Equals
+            Equals( NSString* substr ){ return Impl::NSStringMatchers::Equals( substr ); }
+
+        inline Impl::NSStringMatchers::Contains
+            Contains( NSString* substr ){ return Impl::NSStringMatchers::Contains( substr ); }
+
+        inline Impl::NSStringMatchers::StartsWith
+            StartsWith( NSString* substr ){ return Impl::NSStringMatchers::StartsWith( substr ); }
+
+        inline Impl::NSStringMatchers::EndsWith
+            EndsWith( NSString* substr ){ return Impl::NSStringMatchers::EndsWith( substr ); }
+
+    } // namespace Matchers
+
+    using namespace Matchers;
+
+} // namespace Catch
+
+///////////////////////////////////////////////////////////////////////////////
+#define OC_TEST_CASE( name, desc )\
++(NSString*) INTERNAL_CATCH_UNIQUE_NAME( Catch_Name_test ) \
+{\
+return @ name; \
+}\
++(NSString*) INTERNAL_CATCH_UNIQUE_NAME( Catch_Description_test ) \
+{ \
+return @ desc; \
+} \
+-(void) INTERNAL_CATCH_UNIQUE_NAME( Catch_TestCase_test )
+
+#endif
+
+#ifdef CATCH_CONFIG_RUNNER
+// #included from: internal/catch_impl.hpp
+#define TWOBLUECUBES_CATCH_IMPL_HPP_INCLUDED
+
+// Collect all the implementation files together here
+// These are the equivalent of what would usually be cpp files
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wweak-vtables"
+#endif
+
+// #included from: catch_runner.hpp
+#define TWOBLUECUBES_CATCH_RUNNER_HPP_INCLUDED
+
+// #included from: internal/catch_commandline.hpp
+#define TWOBLUECUBES_CATCH_COMMANDLINE_HPP_INCLUDED
+
+// #included from: catch_config.hpp
+#define TWOBLUECUBES_CATCH_CONFIG_HPP_INCLUDED
+
+// #included from: catch_test_spec_parser.hpp
+#define TWOBLUECUBES_CATCH_TEST_SPEC_PARSER_HPP_INCLUDED
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+// #included from: catch_test_spec.hpp
+#define TWOBLUECUBES_CATCH_TEST_SPEC_HPP_INCLUDED
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+#include <string>
+#include <vector>
+
+namespace Catch {
+
+    class TestSpec {
+        struct Pattern : SharedImpl<> {
+            virtual ~Pattern();
+            virtual bool matches( TestCaseInfo const& testCase ) const = 0;
+        };
+        class NamePattern : public Pattern {
+            enum WildcardPosition {
+                NoWildcard = 0,
+                WildcardAtStart = 1,
+                WildcardAtEnd = 2,
+                WildcardAtBothEnds = WildcardAtStart | WildcardAtEnd
+            };
+
+        public:
+            NamePattern( std::string const& name ) : m_name( toLower( name ) ), m_wildcard( NoWildcard ) {
+                if( startsWith( m_name, "*" ) ) {
+                    m_name = m_name.substr( 1 );
+                    m_wildcard = WildcardAtStart;
+                }
+                if( endsWith( m_name, "*" ) ) {
+                    m_name = m_name.substr( 0, m_name.size()-1 );
+                    m_wildcard = static_cast<WildcardPosition>( m_wildcard | WildcardAtEnd );
+                }
+            }
+            virtual ~NamePattern();
+            virtual bool matches( TestCaseInfo const& testCase ) const {
+                switch( m_wildcard ) {
+                    case NoWildcard:
+                        return m_name == toLower( testCase.name );
+                    case WildcardAtStart:
+                        return endsWith( toLower( testCase.name ), m_name );
+                    case WildcardAtEnd:
+                        return startsWith( toLower( testCase.name ), m_name );
+                    case WildcardAtBothEnds:
+                        return contains( toLower( testCase.name ), m_name );
+                }
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunreachable-code"
+#endif
+                throw std::logic_error( "Unknown enum" );
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+            }
+        private:
+            std::string m_name;
+            WildcardPosition m_wildcard;
+        };
+        class TagPattern : public Pattern {
+        public:
+            TagPattern( std::string const& tag ) : m_tag( toLower( tag ) ) {}
+            virtual ~TagPattern();
+            virtual bool matches( TestCaseInfo const& testCase ) const {
+                return testCase.lcaseTags.find( m_tag ) != testCase.lcaseTags.end();
+            }
+        private:
+            std::string m_tag;
+        };
+        class ExcludedPattern : public Pattern {
+        public:
+            ExcludedPattern( Ptr<Pattern> const& underlyingPattern ) : m_underlyingPattern( underlyingPattern ) {}
+            virtual ~ExcludedPattern();
+            virtual bool matches( TestCaseInfo const& testCase ) const { return !m_underlyingPattern->matches( testCase ); }
+        private:
+            Ptr<Pattern> m_underlyingPattern;
+        };
+
+        struct Filter {
+            std::vector<Ptr<Pattern> > m_patterns;
+
+            bool matches( TestCaseInfo const& testCase ) const {
+                // All patterns in a filter must match for the filter to be a match
+                for( std::vector<Ptr<Pattern> >::const_iterator it = m_patterns.begin(), itEnd = m_patterns.end(); it != itEnd; ++it )
+                    if( !(*it)->matches( testCase ) )
+                        return false;
+                    return true;
+            }
+        };
+
+    public:
+        bool hasFilters() const {
+            return !m_filters.empty();
+        }
+        bool matches( TestCaseInfo const& testCase ) const {
+            // A TestSpec matches if any filter matches
+            for( std::vector<Filter>::const_iterator it = m_filters.begin(), itEnd = m_filters.end(); it != itEnd; ++it )
+                if( it->matches( testCase ) )
+                    return true;
+            return false;
+        }
+
+    private:
+        std::vector<Filter> m_filters;
+
+        friend class TestSpecParser;
+    };
+}
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+namespace Catch {
+
+    class TestSpecParser {
+        enum Mode{ None, Name, QuotedName, Tag };
+        Mode m_mode;
+        bool m_exclusion;
+        std::size_t m_start, m_pos;
+        std::string m_arg;
+        TestSpec::Filter m_currentFilter;
+        TestSpec m_testSpec;
+        ITagAliasRegistry const* m_tagAliases;
+
+    public:
+        TestSpecParser( ITagAliasRegistry const& tagAliases ) : m_tagAliases( &tagAliases ) {}
+
+        TestSpecParser& parse( std::string const& arg ) {
+            m_mode = None;
+            m_exclusion = false;
+            m_start = std::string::npos;
+            m_arg = m_tagAliases->expandAliases( arg );
+            for( m_pos = 0; m_pos < m_arg.size(); ++m_pos )
+                visitChar( m_arg[m_pos] );
+            if( m_mode == Name )
+                addPattern<TestSpec::NamePattern>();
+            return *this;
+        }
+        TestSpec testSpec() {
+            addFilter();
+            return m_testSpec;
+        }
+    private:
+        void visitChar( char c ) {
+            if( m_mode == None ) {
+                switch( c ) {
+                case ' ': return;
+                case '~': m_exclusion = true; return;
+                case '[': return startNewMode( Tag, ++m_pos );
+                case '"': return startNewMode( QuotedName, ++m_pos );
+                default: startNewMode( Name, m_pos ); break;
+                }
+            }
+            if( m_mode == Name ) {
+                if( c == ',' ) {
+                    addPattern<TestSpec::NamePattern>();
+                    addFilter();
+                }
+                else if( c == '[' ) {
+                    if( subString() == "exclude:" )
+                        m_exclusion = true;
+                    else
+                        addPattern<TestSpec::NamePattern>();
+                    startNewMode( Tag, ++m_pos );
+                }
+            }
+            else if( m_mode == QuotedName && c == '"' )
+                addPattern<TestSpec::NamePattern>();
+            else if( m_mode == Tag && c == ']' )
+                addPattern<TestSpec::TagPattern>();
+        }
+        void startNewMode( Mode mode, std::size_t start ) {
+            m_mode = mode;
+            m_start = start;
+        }
+        std::string subString() const { return m_arg.substr( m_start, m_pos - m_start ); }
+        template<typename T>
+        void addPattern() {
+            std::string token = subString();
+            if( startsWith( token, "exclude:" ) ) {
+                m_exclusion = true;
+                token = token.substr( 8 );
+            }
+            if( !token.empty() ) {
+                Ptr<TestSpec::Pattern> pattern = new T( token );
+                if( m_exclusion )
+                    pattern = new TestSpec::ExcludedPattern( pattern );
+                m_currentFilter.m_patterns.push_back( pattern );
+            }
+            m_exclusion = false;
+            m_mode = None;
+        }
+        void addFilter() {
+            if( !m_currentFilter.m_patterns.empty() ) {
+                m_testSpec.m_filters.push_back( m_currentFilter );
+                m_currentFilter = TestSpec::Filter();
+            }
+        }
+    };
+    inline TestSpec parseTestSpec( std::string const& arg ) {
+        return TestSpecParser( ITagAliasRegistry::get() ).parse( arg ).testSpec();
+    }
+
+} // namespace Catch
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+// #included from: catch_interfaces_config.h
+#define TWOBLUECUBES_CATCH_INTERFACES_CONFIG_H_INCLUDED
+
+#include <iostream>
+#include <string>
+#include <vector>
+
+namespace Catch {
+
+    struct Verbosity { enum Level {
+        NoOutput = 0,
+        Quiet,
+        Normal
+    }; };
+
+    struct WarnAbout { enum What {
+        Nothing = 0x00,
+        NoAssertions = 0x01
+    }; };
+
+    struct ShowDurations { enum OrNot {
+        DefaultForReporter,
+        Always,
+        Never
+    }; };
+
+    class TestSpec;
+
+    struct IConfig : IShared {
+
+        virtual ~IConfig();
+
+        virtual bool allowThrows() const = 0;
+        virtual std::ostream& stream() const = 0;
+        virtual std::string name() const = 0;
+        virtual bool includeSuccessfulResults() const = 0;
+        virtual bool shouldDebugBreak() const = 0;
+        virtual bool warnAboutMissingAssertions() const = 0;
+        virtual int abortAfter() const = 0;
+        virtual bool showInvisibles() const = 0;
+        virtual ShowDurations::OrNot showDurations() const = 0;
+        virtual TestSpec const& testSpec() const = 0;
+    };
+}
+
+// #included from: catch_stream.h
+#define TWOBLUECUBES_CATCH_STREAM_H_INCLUDED
+
+#include <streambuf>
+
+#ifdef __clang__
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+namespace Catch {
+
+    class Stream {
+    public:
+        Stream();
+        Stream( std::streambuf* _streamBuf, bool _isOwned );
+        void release();
+
+        std::streambuf* streamBuf;
+
+    private:
+        bool isOwned;
+    };
+}
+
+#include <memory>
+#include <vector>
+#include <string>
+#include <iostream>
+
+#ifndef CATCH_CONFIG_CONSOLE_WIDTH
+#define CATCH_CONFIG_CONSOLE_WIDTH 80
+#endif
+
+namespace Catch {
+
+    struct ConfigData {
+
+        ConfigData()
+        :   listTests( false ),
+            listTags( false ),
+            listReporters( false ),
+            listTestNamesOnly( false ),
+            showSuccessfulTests( false ),
+            shouldDebugBreak( false ),
+            noThrow( false ),
+            showHelp( false ),
+            showInvisibles( false ),
+            abortAfter( -1 ),
+            verbosity( Verbosity::Normal ),
+            warnings( WarnAbout::Nothing ),
+            showDurations( ShowDurations::DefaultForReporter )
+        {}
+
+        bool listTests;
+        bool listTags;
+        bool listReporters;
+        bool listTestNamesOnly;
+
+        bool showSuccessfulTests;
+        bool shouldDebugBreak;
+        bool noThrow;
+        bool showHelp;
+        bool showInvisibles;
+
+        int abortAfter;
+
+        Verbosity::Level verbosity;
+        WarnAbout::What warnings;
+        ShowDurations::OrNot showDurations;
+
+        std::string reporterName;
+        std::string outputFilename;
+        std::string name;
+        std::string processName;
+
+        std::vector<std::string> testsOrTags;
+    };
+
+    class Config : public SharedImpl<IConfig> {
+    private:
+        Config( Config const& other );
+        Config& operator = ( Config const& other );
+        virtual void dummy();
+    public:
+
+        Config()
+        :   m_os( std::cout.rdbuf() )
+        {}
+
+        Config( ConfigData const& data )
+        :   m_data( data ),
+            m_os( std::cout.rdbuf() )
+        {
+            if( !data.testsOrTags.empty() ) {
+                TestSpecParser parser( ITagAliasRegistry::get() );
+                for( std::size_t i = 0; i < data.testsOrTags.size(); ++i )
+                    parser.parse( data.testsOrTags[i] );
+                m_testSpec = parser.testSpec();
+            }
+        }
+
+        virtual ~Config() {
+            m_os.rdbuf( std::cout.rdbuf() );
+            m_stream.release();
+        }
+
+        void setFilename( std::string const& filename ) {
+            m_data.outputFilename = filename;
+        }
+
+        std::string const& getFilename() const {
+            return m_data.outputFilename ;
+        }
+
+        bool listTests() const { return m_data.listTests; }
+        bool listTestNamesOnly() const { return m_data.listTestNamesOnly; }
+        bool listTags() const { return m_data.listTags; }
+        bool listReporters() const { return m_data.listReporters; }
+
+        std::string getProcessName() const { return m_data.processName; }
+
+        bool shouldDebugBreak() const { return m_data.shouldDebugBreak; }
+
+        void setStreamBuf( std::streambuf* buf ) {
+            m_os.rdbuf( buf ? buf : std::cout.rdbuf() );
+        }
+
+        void useStream( std::string const& streamName ) {
+            Stream stream = createStream( streamName );
+            setStreamBuf( stream.streamBuf );
+            m_stream.release();
+            m_stream = stream;
+        }
+
+        std::string getReporterName() const { return m_data.reporterName; }
+
+        int abortAfter() const { return m_data.abortAfter; }
+
+        TestSpec const& testSpec() const { return m_testSpec; }
+
+        bool showHelp() const { return m_data.showHelp; }
+        bool showInvisibles() const { return m_data.showInvisibles; }
+
+        // IConfig interface
+        virtual bool allowThrows() const        { return !m_data.noThrow; }
+        virtual std::ostream& stream() const    { return m_os; }
+        virtual std::string name() const        { return m_data.name.empty() ? m_data.processName : m_data.name; }
+        virtual bool includeSuccessfulResults() const   { return m_data.showSuccessfulTests; }
+        virtual bool warnAboutMissingAssertions() const { return m_data.warnings & WarnAbout::NoAssertions; }
+        virtual ShowDurations::OrNot showDurations() const { return m_data.showDurations; }
+
+    private:
+        ConfigData m_data;
+
+        Stream m_stream;
+        mutable std::ostream m_os;
+        TestSpec m_testSpec;
+    };
+
+} // end namespace Catch
+
+// #included from: catch_clara.h
+#define TWOBLUECUBES_CATCH_CLARA_H_INCLUDED
+
+// Use Catch's value for console width (store Clara's off to the side, if present)
+#ifdef CLARA_CONFIG_CONSOLE_WIDTH
+#define CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH CLARA_CONFIG_CONSOLE_WIDTH
+#undef CLARA_CONFIG_CONSOLE_WIDTH
+#endif
+#define CLARA_CONFIG_CONSOLE_WIDTH CATCH_CONFIG_CONSOLE_WIDTH
+
+// Declare Clara inside the Catch namespace
+#define STITCH_CLARA_OPEN_NAMESPACE namespace Catch {
+// #included from: ../external/clara.h
+
+// Only use header guard if we are not using an outer namespace
+#if !defined(TWOBLUECUBES_CLARA_H_INCLUDED) || defined(STITCH_CLARA_OPEN_NAMESPACE)
+
+#ifndef STITCH_CLARA_OPEN_NAMESPACE
+#define TWOBLUECUBES_CLARA_H_INCLUDED
+#define STITCH_CLARA_OPEN_NAMESPACE
+#define STITCH_CLARA_CLOSE_NAMESPACE
+#else
+#define STITCH_CLARA_CLOSE_NAMESPACE }
+#endif
+
+#define STITCH_TBC_TEXT_FORMAT_OPEN_NAMESPACE STITCH_CLARA_OPEN_NAMESPACE
+
+// ----------- #included from tbc_text_format.h -----------
+
+// Only use header guard if we are not using an outer namespace
+#if !defined(TBC_TEXT_FORMAT_H_INCLUDED) || defined(STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE)
+#ifndef STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE
+#define TBC_TEXT_FORMAT_H_INCLUDED
+#endif
+
+#include <string>
+#include <vector>
+#include <sstream>
+
+// Use optional outer namespace
+#ifdef STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE
+namespace STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE {
+#endif
+
+namespace Tbc {
+
+#ifdef TBC_TEXT_FORMAT_CONSOLE_WIDTH
+    const unsigned int consoleWidth = TBC_TEXT_FORMAT_CONSOLE_WIDTH;
+#else
+    const unsigned int consoleWidth = 80;
+#endif
+
+    struct TextAttributes {
+        TextAttributes()
+        :   initialIndent( std::string::npos ),
+            indent( 0 ),
+            width( consoleWidth-1 ),
+            tabChar( '\t' )
+        {}
+
+        TextAttributes& setInitialIndent( std::size_t _value )  { initialIndent = _value; return *this; }
+        TextAttributes& setIndent( std::size_t _value )         { indent = _value; return *this; }
+        TextAttributes& setWidth( std::size_t _value )          { width = _value; return *this; }
+        TextAttributes& setTabChar( char _value )               { tabChar = _value; return *this; }
+
+        std::size_t initialIndent;  // indent of first line, or npos
+        std::size_t indent;         // indent of subsequent lines, or all if initialIndent is npos
+        std::size_t width;          // maximum width of text, including indent. Longer text will wrap
+        char tabChar;               // If this char is seen the indent is changed to current pos
+    };
+
+    class Text {
+    public:
+        Text( std::string const& _str, TextAttributes const& _attr = TextAttributes() )
+        : attr( _attr )
+        {
+            std::string wrappableChars = " [({.,/|\\-";
+            std::size_t indent = _attr.initialIndent != std::string::npos
+                ? _attr.initialIndent
+                : _attr.indent;
+            std::string remainder = _str;
+
+            while( !remainder.empty() ) {
+                if( lines.size() >= 1000 ) {
+                    lines.push_back( "... message truncated due to excessive size" );
+                    return;
+                }
+                std::size_t tabPos = std::string::npos;
+                std::size_t width = (std::min)( remainder.size(), _attr.width - indent );
+                std::size_t pos = remainder.find_first_of( '\n' );
+                if( pos <= width ) {
+                    width = pos;
+                }
+                pos = remainder.find_last_of( _attr.tabChar, width );
+                if( pos != std::string::npos ) {
+                    tabPos = pos;
+                    if( remainder[width] == '\n' )
+                        width--;
+                    remainder = remainder.substr( 0, tabPos ) + remainder.substr( tabPos+1 );
+                }
+
+                if( width == remainder.size() ) {
+                    spliceLine( indent, remainder, width );
+                }
+                else if( remainder[width] == '\n' ) {
+                    spliceLine( indent, remainder, width );
+                    if( width <= 1 || remainder.size() != 1 )
+                        remainder = remainder.substr( 1 );
+                    indent = _attr.indent;
+                }
+                else {
+                    pos = remainder.find_last_of( wrappableChars, width );
+                    if( pos != std::string::npos && pos > 0 ) {
+                        spliceLine( indent, remainder, pos );
+                        if( remainder[0] == ' ' )
+                            remainder = remainder.substr( 1 );
+                    }
+                    else {
+                        spliceLine( indent, remainder, width-1 );
+                        lines.back() += "-";
+                    }
+                    if( lines.size() == 1 )
+                        indent = _attr.indent;
+                    if( tabPos != std::string::npos )
+                        indent += tabPos;
+                }
+            }
+        }
+
+        void spliceLine( std::size_t _indent, std::string& _remainder, std::size_t _pos ) {
+            lines.push_back( std::string( _indent, ' ' ) + _remainder.substr( 0, _pos ) );
+            _remainder = _remainder.substr( _pos );
+        }
+
+        typedef std::vector<std::string>::const_iterator const_iterator;
+
+        const_iterator begin() const { return lines.begin(); }
+        const_iterator end() const { return lines.end(); }
+        std::string const& last() const { return lines.back(); }
+        std::size_t size() const { return lines.size(); }
+        std::string const& operator[]( std::size_t _index ) const { return lines[_index]; }
+        std::string toString() const {
+            std::ostringstream oss;
+            oss << *this;
+            return oss.str();
+        }
+
+        inline friend std::ostream& operator << ( std::ostream& _stream, Text const& _text ) {
+            for( Text::const_iterator it = _text.begin(), itEnd = _text.end();
+                it != itEnd; ++it ) {
+                if( it != _text.begin() )
+                    _stream << "\n";
+                _stream << *it;
+            }
+            return _stream;
+        }
+
+    private:
+        std::string str;
+        TextAttributes attr;
+        std::vector<std::string> lines;
+    };
+
+} // end namespace Tbc
+
+#ifdef STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE
+} // end outer namespace
+#endif
+
+#endif // TBC_TEXT_FORMAT_H_INCLUDED
+
+// ----------- end of #include from tbc_text_format.h -----------
+// ........... back in /Users/philnash/Dev/OSS/Clara/srcs/clara.h
+
+#undef STITCH_TBC_TEXT_FORMAT_OPEN_NAMESPACE
+
+#include <map>
+#include <algorithm>
+#include <stdexcept>
+#include <memory>
+
+// Use optional outer namespace
+#ifdef STITCH_CLARA_OPEN_NAMESPACE
+STITCH_CLARA_OPEN_NAMESPACE
+#endif
+
+namespace Clara {
+
+    struct UnpositionalTag {};
+
+    extern UnpositionalTag _;
+
+#ifdef CLARA_CONFIG_MAIN
+    UnpositionalTag _;
+#endif
+
+    namespace Detail {
+
+#ifdef CLARA_CONSOLE_WIDTH
+    const unsigned int consoleWidth = CLARA_CONFIG_CONSOLE_WIDTH;
+#else
+    const unsigned int consoleWidth = 80;
+#endif
+
+        using namespace Tbc;
+
+        inline bool startsWith( std::string const& str, std::string const& prefix ) {
+            return str.size() >= prefix.size() && str.substr( 0, prefix.size() ) == prefix;
+        }
+
+        template<typename T> struct RemoveConstRef{ typedef T type; };
+        template<typename T> struct RemoveConstRef<T&>{ typedef T type; };
+        template<typename T> struct RemoveConstRef<T const&>{ typedef T type; };
+        template<typename T> struct RemoveConstRef<T const>{ typedef T type; };
+
+        template<typename T>    struct IsBool       { static const bool value = false; };
+        template<>              struct IsBool<bool> { static const bool value = true; };
+
+        template<typename T>
+        void convertInto( std::string const& _source, T& _dest ) {
+            std::stringstream ss;
+            ss << _source;
+            ss >> _dest;
+            if( ss.fail() )
+                throw std::runtime_error( "Unable to convert " + _source + " to destination type" );
+        }
+        inline void convertInto( std::string const& _source, std::string& _dest ) {
+            _dest = _source;
+        }
+        inline void convertInto( std::string const& _source, bool& _dest ) {
+            std::string sourceLC = _source;
+            std::transform( sourceLC.begin(), sourceLC.end(), sourceLC.begin(), ::tolower );
+            if( sourceLC == "y" || sourceLC == "1" || sourceLC == "true" || sourceLC == "yes" || sourceLC == "on" )
+                _dest = true;
+            else if( sourceLC == "n" || sourceLC == "0" || sourceLC == "false" || sourceLC == "no" || sourceLC == "off" )
+                _dest = false;
+            else
+                throw std::runtime_error( "Expected a boolean value but did not recognise:\n  '" + _source + "'" );
+        }
+        inline void convertInto( bool _source, bool& _dest ) {
+            _dest = _source;
+        }
+        template<typename T>
+        inline void convertInto( bool, T& ) {
+            throw std::runtime_error( "Invalid conversion" );
+        }
+
+        template<typename ConfigT>
+        struct IArgFunction {
+            virtual ~IArgFunction() {}
+#  ifdef CATCH_CPP11_OR_GREATER
+            IArgFunction()                      = default;
+            IArgFunction( IArgFunction const& ) = default;
+#  endif
+            virtual void set( ConfigT& config, std::string const& value ) const = 0;
+            virtual void setFlag( ConfigT& config ) const = 0;
+            virtual bool takesArg() const = 0;
+            virtual IArgFunction* clone() const = 0;
+        };
+
+        template<typename ConfigT>
+        class BoundArgFunction {
+        public:
+            BoundArgFunction() : functionObj( NULL ) {}
+            BoundArgFunction( IArgFunction<ConfigT>* _functionObj ) : functionObj( _functionObj ) {}
+            BoundArgFunction( BoundArgFunction const& other ) : functionObj( other.functionObj ? other.functionObj->clone() : NULL ) {}
+            BoundArgFunction& operator = ( BoundArgFunction const& other ) {
+                IArgFunction<ConfigT>* newFunctionObj = other.functionObj ? other.functionObj->clone() : NULL;
+                delete functionObj;
+                functionObj = newFunctionObj;
+                return *this;
+            }
+            ~BoundArgFunction() { delete functionObj; }
+
+            void set( ConfigT& config, std::string const& value ) const {
+                functionObj->set( config, value );
+            }
+            void setFlag( ConfigT& config ) const {
+                functionObj->setFlag( config );
+            }
+            bool takesArg() const { return functionObj->takesArg(); }
+
+            bool isSet() const {
+                return functionObj != NULL;
+            }
+        private:
+            IArgFunction<ConfigT>* functionObj;
+        };
+
+        template<typename C>
+        struct NullBinder : IArgFunction<C>{
+            virtual void set( C&, std::string const& ) const {}
+            virtual void setFlag( C& ) const {}
+            virtual bool takesArg() const { return true; }
+            virtual IArgFunction<C>* clone() const { return new NullBinder( *this ); }
+        };
+
+        template<typename C, typename M>
+        struct BoundDataMember : IArgFunction<C>{
+            BoundDataMember( M C::* _member ) : member( _member ) {}
+            virtual void set( C& p, std::string const& stringValue ) const {
+                convertInto( stringValue, p.*member );
+            }
+            virtual void setFlag( C& p ) const {
+                convertInto( true, p.*member );
+            }
+            virtual bool takesArg() const { return !IsBool<M>::value; }
+            virtual IArgFunction<C>* clone() const { return new BoundDataMember( *this ); }
+            M C::* member;
+        };
+        template<typename C, typename M>
+        struct BoundUnaryMethod : IArgFunction<C>{
+            BoundUnaryMethod( void (C::*_member)( M ) ) : member( _member ) {}
+            virtual void set( C& p, std::string const& stringValue ) const {
+                typename RemoveConstRef<M>::type value;
+                convertInto( stringValue, value );
+                (p.*member)( value );
+            }
+            virtual void setFlag( C& p ) const {
+                typename RemoveConstRef<M>::type value;
+                convertInto( true, value );
+                (p.*member)( value );
+            }
+            virtual bool takesArg() const { return !IsBool<M>::value; }
+            virtual IArgFunction<C>* clone() const { return new BoundUnaryMethod( *this ); }
+            void (C::*member)( M );
+        };
+        template<typename C>
+        struct BoundNullaryMethod : IArgFunction<C>{
+            BoundNullaryMethod( void (C::*_member)() ) : member( _member ) {}
+            virtual void set( C& p, std::string const& stringValue ) const {
+                bool value;
+                convertInto( stringValue, value );
+                if( value )
+                    (p.*member)();
+            }
+            virtual void setFlag( C& p ) const {
+                (p.*member)();
+            }
+            virtual bool takesArg() const { return false; }
+            virtual IArgFunction<C>* clone() const { return new BoundNullaryMethod( *this ); }
+            void (C::*member)();
+        };
+
+        template<typename C>
+        struct BoundUnaryFunction : IArgFunction<C>{
+            BoundUnaryFunction( void (*_function)( C& ) ) : function( _function ) {}
+            virtual void set( C& obj, std::string const& stringValue ) const {
+                bool value;
+                convertInto( stringValue, value );
+                if( value )
+                    function( obj );
+            }
+            virtual void setFlag( C& p ) const {
+                function( p );
+            }
+            virtual bool takesArg() const { return false; }
+            virtual IArgFunction<C>* clone() const { return new BoundUnaryFunction( *this ); }
+            void (*function)( C& );
+        };
+
+        template<typename C, typename T>
+        struct BoundBinaryFunction : IArgFunction<C>{
+            BoundBinaryFunction( void (*_function)( C&, T ) ) : function( _function ) {}
+            virtual void set( C& obj, std::string const& stringValue ) const {
+                typename RemoveConstRef<T>::type value;
+                convertInto( stringValue, value );
+                function( obj, value );
+            }
+            virtual void setFlag( C& obj ) const {
+                typename RemoveConstRef<T>::type value;
+                convertInto( true, value );
+                function( obj, value );
+            }
+            virtual bool takesArg() const { return !IsBool<T>::value; }
+            virtual IArgFunction<C>* clone() const { return new BoundBinaryFunction( *this ); }
+            void (*function)( C&, T );
+        };
+
+    } // namespace Detail
+
+    struct Parser {
+        Parser() : separators( " \t=:" ) {}
+
+        struct Token {
+            enum Type { Positional, ShortOpt, LongOpt };
+            Token( Type _type, std::string const& _data ) : type( _type ), data( _data ) {}
+            Type type;
+            std::string data;
+        };
+
+        void parseIntoTokens( int argc, char const * const * argv, std::vector<Parser::Token>& tokens ) const {
+            const std::string doubleDash = "--";
+            for( int i = 1; i < argc && argv[i] != doubleDash; ++i )
+                parseIntoTokens( argv[i] , tokens);
+        }
+        void parseIntoTokens( std::string arg, std::vector<Parser::Token>& tokens ) const {
+            while( !arg.empty() ) {
+                Parser::Token token( Parser::Token::Positional, arg );
+                arg = "";
+                if( token.data[0] == '-' ) {
+                    if( token.data.size() > 1 && token.data[1] == '-' ) {
+                        token = Parser::Token( Parser::Token::LongOpt, token.data.substr( 2 ) );
+                    }
+                    else {
+                        token = Parser::Token( Parser::Token::ShortOpt, token.data.substr( 1 ) );
+                        if( token.data.size() > 1 && separators.find( token.data[1] ) == std::string::npos ) {
+                            arg = "-" + token.data.substr( 1 );
+                            token.data = token.data.substr( 0, 1 );
+                        }
+                    }
+                }
+                if( token.type != Parser::Token::Positional ) {
+                    std::size_t pos = token.data.find_first_of( separators );
+                    if( pos != std::string::npos ) {
+                        arg = token.data.substr( pos+1 );
+                        token.data = token.data.substr( 0, pos );
+                    }
+                }
+                tokens.push_back( token );
+            }
+        }
+        std::string separators;
+    };
+
+    template<typename ConfigT>
+    struct CommonArgProperties {
+        CommonArgProperties() {}
+        CommonArgProperties( Detail::BoundArgFunction<ConfigT> const& _boundField ) : boundField( _boundField ) {}
+
+        Detail::BoundArgFunction<ConfigT> boundField;
+        std::string description;
+        std::string detail;
+        std::string placeholder; // Only value if boundField takes an arg
+
+        bool takesArg() const {
+            return !placeholder.empty();
+        }
+        void validate() const {
+            if( !boundField.isSet() )
+                throw std::logic_error( "option not bound" );
+        }
+    };
+    struct OptionArgProperties {
+        std::vector<std::string> shortNames;
+        std::string longName;
+
+        bool hasShortName( std::string const& shortName ) const {
+            return std::find( shortNames.begin(), shortNames.end(), shortName ) != shortNames.end();
+        }
+        bool hasLongName( std::string const& _longName ) const {
+            return _longName == longName;
+        }
+    };
+    struct PositionalArgProperties {
+        PositionalArgProperties() : position( -1 ) {}
+        int position; // -1 means non-positional (floating)
+
+        bool isFixedPositional() const {
+            return position != -1;
+        }
+    };
+
+    template<typename ConfigT>
+    class CommandLine {
+
+        struct Arg : CommonArgProperties<ConfigT>, OptionArgProperties, PositionalArgProperties {
+            Arg() {}
+            Arg( Detail::BoundArgFunction<ConfigT> const& _boundField ) : CommonArgProperties<ConfigT>( _boundField ) {}
+
+            using CommonArgProperties<ConfigT>::placeholder; // !TBD
+
+            std::string dbgName() const {
+                if( !longName.empty() )
+                    return "--" + longName;
+                if( !shortNames.empty() )
+                    return "-" + shortNames[0];
+                return "positional args";
+            }
+            std::string commands() const {
+                std::ostringstream oss;
+                bool first = true;
+                std::vector<std::string>::const_iterator it = shortNames.begin(), itEnd = shortNames.end();
+                for(; it != itEnd; ++it ) {
+                    if( first )
+                        first = false;
+                    else
+                        oss << ", ";
+                    oss << "-" << *it;
+                }
+                if( !longName.empty() ) {
+                    if( !first )
+                        oss << ", ";
+                    oss << "--" << longName;
+                }
+                if( !placeholder.empty() )
+                    oss << " <" << placeholder << ">";
+                return oss.str();
+            }
+        };
+
+        // NOTE: std::auto_ptr is deprecated in c++11/c++0x
+#if defined(__cplusplus) && __cplusplus > 199711L
+        typedef std::unique_ptr<Arg> ArgAutoPtr;
+#else
+        typedef std::auto_ptr<Arg> ArgAutoPtr;
+#endif
+
+        friend void addOptName( Arg& arg, std::string const& optName )
+        {
+            if( optName.empty() )
+                return;
+            if( Detail::startsWith( optName, "--" ) ) {
+                if( !arg.longName.empty() )
+                    throw std::logic_error( "Only one long opt may be specified. '"
+                        + arg.longName
+                        + "' already specified, now attempting to add '"
+                        + optName + "'" );
+                arg.longName = optName.substr( 2 );
+            }
+            else if( Detail::startsWith( optName, "-" ) )
+                arg.shortNames.push_back( optName.substr( 1 ) );
+            else
+                throw std::logic_error( "option must begin with - or --. Option was: '" + optName + "'" );
+        }
+        friend void setPositionalArg( Arg& arg, int position )
+        {
+            arg.position = position;
+        }
+
+        class ArgBuilder {
+        public:
+            ArgBuilder( Arg* arg ) : m_arg( arg ) {}
+
+            // Bind a non-boolean data member (requires placeholder string)
+            template<typename C, typename M>
+            void bind( M C::* field, std::string const& placeholder ) {
+                m_arg->boundField = new Detail::BoundDataMember<C,M>( field );
+                m_arg->placeholder = placeholder;
+            }
+            // Bind a boolean data member (no placeholder required)
+            template<typename C>
+            void bind( bool C::* field ) {
+                m_arg->boundField = new Detail::BoundDataMember<C,bool>( field );
+            }
+
+            // Bind a method taking a single, non-boolean argument (requires a placeholder string)
+            template<typename C, typename M>
+            void bind( void (C::* unaryMethod)( M ), std::string const& placeholder ) {
+                m_arg->boundField = new Detail::BoundUnaryMethod<C,M>( unaryMethod );
+                m_arg->placeholder = placeholder;
+            }
+
+            // Bind a method taking a single, boolean argument (no placeholder string required)
+            template<typename C>
+            void bind( void (C::* unaryMethod)( bool ) ) {
+                m_arg->boundField = new Detail::BoundUnaryMethod<C,bool>( unaryMethod );
+            }
+
+            // Bind a method that takes no arguments (will be called if opt is present)
+            template<typename C>
+            void bind( void (C::* nullaryMethod)() ) {
+                m_arg->boundField = new Detail::BoundNullaryMethod<C>( nullaryMethod );
+            }
+
+            // Bind a free function taking a single argument - the object to operate on (no placeholder string required)
+            template<typename C>
+            void bind( void (* unaryFunction)( C& ) ) {
+                m_arg->boundField = new Detail::BoundUnaryFunction<C>( unaryFunction );
+            }
+
+            // Bind a free function taking a single argument - the object to operate on (requires a placeholder string)
+            template<typename C, typename T>
+            void bind( void (* binaryFunction)( C&, T ), std::string const& placeholder ) {
+                m_arg->boundField = new Detail::BoundBinaryFunction<C, T>( binaryFunction );
+                m_arg->placeholder = placeholder;
+            }
+
+            ArgBuilder& describe( std::string const& description ) {
+                m_arg->description = description;
+                return *this;
+            }
+            ArgBuilder& detail( std::string const& detail ) {
+                m_arg->detail = detail;
+                return *this;
+            }
+
+        protected:
+            Arg* m_arg;
+        };
+
+        class OptBuilder : public ArgBuilder {
+        public:
+            OptBuilder( Arg* arg ) : ArgBuilder( arg ) {}
+            OptBuilder( OptBuilder& other ) : ArgBuilder( other ) {}
+
+            OptBuilder& operator[]( std::string const& optName ) {
+                addOptName( *ArgBuilder::m_arg, optName );
+                return *this;
+            }
+        };
+
+    public:
+
+        CommandLine()
+        :   m_boundProcessName( new Detail::NullBinder<ConfigT>() ),
+            m_highestSpecifiedArgPosition( 0 ),
+            m_throwOnUnrecognisedTokens( false )
+        {}
+        CommandLine( CommandLine const& other )
+        :   m_boundProcessName( other.m_boundProcessName ),
+            m_options ( other.m_options ),
+            m_positionalArgs( other.m_positionalArgs ),
+            m_highestSpecifiedArgPosition( other.m_highestSpecifiedArgPosition ),
+            m_throwOnUnrecognisedTokens( other.m_throwOnUnrecognisedTokens )
+        {
+            if( other.m_floatingArg.get() )
+                m_floatingArg = ArgAutoPtr( new Arg( *other.m_floatingArg ) );
+        }
+
+        CommandLine& setThrowOnUnrecognisedTokens( bool shouldThrow = true ) {
+            m_throwOnUnrecognisedTokens = shouldThrow;
+            return *this;
+        }
+
+        OptBuilder operator[]( std::string const& optName ) {
+            m_options.push_back( Arg() );
+            addOptName( m_options.back(), optName );
+            OptBuilder builder( &m_options.back() );
+            return builder;
+        }
+
+        ArgBuilder operator[]( int position ) {
+            m_positionalArgs.insert( std::make_pair( position, Arg() ) );
+            if( position > m_highestSpecifiedArgPosition )
+                m_highestSpecifiedArgPosition = position;
+            setPositionalArg( m_positionalArgs[position], position );
+            ArgBuilder builder( &m_positionalArgs[position] );
+            return builder;
+        }
+
+        // Invoke this with the _ instance
+        ArgBuilder operator[]( UnpositionalTag ) {
+            if( m_floatingArg.get() )
+                throw std::logic_error( "Only one unpositional argument can be added" );
+            m_floatingArg = ArgAutoPtr( new Arg() );
+            ArgBuilder builder( m_floatingArg.get() );
+            return builder;
+        }
+
+        template<typename C, typename M>
+        void bindProcessName( M C::* field ) {
+            m_boundProcessName = new Detail::BoundDataMember<C,M>( field );
+        }
+        template<typename C, typename M>
+        void bindProcessName( void (C::*_unaryMethod)( M ) ) {
+            m_boundProcessName = new Detail::BoundUnaryMethod<C,M>( _unaryMethod );
+        }
+
+        void optUsage( std::ostream& os, std::size_t indent = 0, std::size_t width = Detail::consoleWidth ) const {
+            typename std::vector<Arg>::const_iterator itBegin = m_options.begin(), itEnd = m_options.end(), it;
+            std::size_t maxWidth = 0;
+            for( it = itBegin; it != itEnd; ++it )
+                maxWidth = (std::max)( maxWidth, it->commands().size() );
+
+            for( it = itBegin; it != itEnd; ++it ) {
+                Detail::Text usage( it->commands(), Detail::TextAttributes()
+                                                        .setWidth( maxWidth+indent )
+                                                        .setIndent( indent ) );
+                Detail::Text desc( it->description, Detail::TextAttributes()
+                                                        .setWidth( width - maxWidth - 3 ) );
+
+                for( std::size_t i = 0; i < (std::max)( usage.size(), desc.size() ); ++i ) {
+                    std::string usageCol = i < usage.size() ? usage[i] : "";
+                    os << usageCol;
+
+                    if( i < desc.size() && !desc[i].empty() )
+                        os  << std::string( indent + 2 + maxWidth - usageCol.size(), ' ' )
+                            << desc[i];
+                    os << "\n";
+                }
+            }
+        }
+        std::string optUsage() const {
+            std::ostringstream oss;
+            optUsage( oss );
+            return oss.str();
+        }
+
+        void argSynopsis( std::ostream& os ) const {
+            for( int i = 1; i <= m_highestSpecifiedArgPosition; ++i ) {
+                if( i > 1 )
+                    os << " ";
+                typename std::map<int, Arg>::const_iterator it = m_positionalArgs.find( i );
+                if( it != m_positionalArgs.end() )
+                    os << "<" << it->second.placeholder << ">";
+                else if( m_floatingArg.get() )
+                    os << "<" << m_floatingArg->placeholder << ">";
+                else
+                    throw std::logic_error( "non consecutive positional arguments with no floating args" );
+            }
+            // !TBD No indication of mandatory args
+            if( m_floatingArg.get() ) {
+                if( m_highestSpecifiedArgPosition > 1 )
+                    os << " ";
+                os << "[<" << m_floatingArg->placeholder << "> ...]";
+            }
+        }
+        std::string argSynopsis() const {
+            std::ostringstream oss;
+            argSynopsis( oss );
+            return oss.str();
+        }
+
+        void usage( std::ostream& os, std::string const& procName ) const {
+            validate();
+            os << "usage:\n  " << procName << " ";
+            argSynopsis( os );
+            if( !m_options.empty() ) {
+                os << " [options]\n\nwhere options are: \n";
+                optUsage( os, 2 );
+            }
+            os << "\n";
+        }
+        std::string usage( std::string const& procName ) const {
+            std::ostringstream oss;
+            usage( oss, procName );
+            return oss.str();
+        }
+
+        ConfigT parse( int argc, char const * const * argv ) const {
+            ConfigT config;
+            parseInto( argc, argv, config );
+            return config;
+        }
+
+        std::vector<Parser::Token> parseInto( int argc, char const * const * argv, ConfigT& config ) const {
+            std::string processName = argv[0];
+            std::size_t lastSlash = processName.find_last_of( "/\\" );
+            if( lastSlash != std::string::npos )
+                processName = processName.substr( lastSlash+1 );
+            m_boundProcessName.set( config, processName );
+            std::vector<Parser::Token> tokens;
+            Parser parser;
+            parser.parseIntoTokens( argc, argv, tokens );
+            return populate( tokens, config );
+        }
+
+        std::vector<Parser::Token> populate( std::vector<Parser::Token> const& tokens, ConfigT& config ) const {
+            validate();
+            std::vector<Parser::Token> unusedTokens = populateOptions( tokens, config );
+            unusedTokens = populateFixedArgs( unusedTokens, config );
+            unusedTokens = populateFloatingArgs( unusedTokens, config );
+            return unusedTokens;
+        }
+
+        std::vector<Parser::Token> populateOptions( std::vector<Parser::Token> const& tokens, ConfigT& config ) const {
+            std::vector<Parser::Token> unusedTokens;
+            std::vector<std::string> errors;
+            for( std::size_t i = 0; i < tokens.size(); ++i ) {
+                Parser::Token const& token = tokens[i];
+                typename std::vector<Arg>::const_iterator it = m_options.begin(), itEnd = m_options.end();
+                for(; it != itEnd; ++it ) {
+                    Arg const& arg = *it;
+
+                    try {
+                        if( ( token.type == Parser::Token::ShortOpt && arg.hasShortName( token.data ) ) ||
+                            ( token.type == Parser::Token::LongOpt && arg.hasLongName( token.data ) ) ) {
+                            if( arg.takesArg() ) {
+                                if( i == tokens.size()-1 || tokens[i+1].type != Parser::Token::Positional )
+                                    errors.push_back( "Expected argument to option: " + token.data );
+                                else
+                                    arg.boundField.set( config, tokens[++i].data );
+                            }
+                            else {
+                                arg.boundField.setFlag( config );
+                            }
+                            break;
+                        }
+                    }
+                    catch( std::exception& ex ) {
+                        errors.push_back( std::string( ex.what() ) + "\n- while parsing: (" + arg.commands() + ")" );
+                    }
+                }
+                if( it == itEnd ) {
+                    if( token.type == Parser::Token::Positional || !m_throwOnUnrecognisedTokens )
+                        unusedTokens.push_back( token );
+                    else if( m_throwOnUnrecognisedTokens )
+                        errors.push_back( "unrecognised option: " + token.data );
+                }
+            }
+            if( !errors.empty() ) {
+                std::ostringstream oss;
+                for( std::vector<std::string>::const_iterator it = errors.begin(), itEnd = errors.end();
+                        it != itEnd;
+                        ++it ) {
+                    if( it != errors.begin() )
+                        oss << "\n";
+                    oss << *it;
+                }
+                throw std::runtime_error( oss.str() );
+            }
+            return unusedTokens;
+        }
+        std::vector<Parser::Token> populateFixedArgs( std::vector<Parser::Token> const& tokens, ConfigT& config ) const {
+            std::vector<Parser::Token> unusedTokens;
+            int position = 1;
+            for( std::size_t i = 0; i < tokens.size(); ++i ) {
+                Parser::Token const& token = tokens[i];
+                typename std::map<int, Arg>::const_iterator it = m_positionalArgs.find( position );
+                if( it != m_positionalArgs.end() )
+                    it->second.boundField.set( config, token.data );
+                else
+                    unusedTokens.push_back( token );
+                if( token.type == Parser::Token::Positional )
+                    position++;
+            }
+            return unusedTokens;
+        }
+        std::vector<Parser::Token> populateFloatingArgs( std::vector<Parser::Token> const& tokens, ConfigT& config ) const {
+            if( !m_floatingArg.get() )
+                return tokens;
+            std::vector<Parser::Token> unusedTokens;
+            for( std::size_t i = 0; i < tokens.size(); ++i ) {
+                Parser::Token const& token = tokens[i];
+                if( token.type == Parser::Token::Positional )
+                    m_floatingArg->boundField.set( config, token.data );
+                else
+                    unusedTokens.push_back( token );
+            }
+            return unusedTokens;
+        }
+
+        void validate() const
+        {
+            if( m_options.empty() && m_positionalArgs.empty() && !m_floatingArg.get() )
+                throw std::logic_error( "No options or arguments specified" );
+
+            for( typename std::vector<Arg>::const_iterator  it = m_options.begin(),
+                                                            itEnd = m_options.end();
+                    it != itEnd; ++it )
+                it->validate();
+        }
+
+    private:
+        Detail::BoundArgFunction<ConfigT> m_boundProcessName;
+        std::vector<Arg> m_options;
+        std::map<int, Arg> m_positionalArgs;
+        ArgAutoPtr m_floatingArg;
+        int m_highestSpecifiedArgPosition;
+        bool m_throwOnUnrecognisedTokens;
+    };
+
+} // end namespace Clara
+
+STITCH_CLARA_CLOSE_NAMESPACE
+#undef STITCH_CLARA_OPEN_NAMESPACE
+#undef STITCH_CLARA_CLOSE_NAMESPACE
+
+#endif // TWOBLUECUBES_CLARA_H_INCLUDED
+#undef STITCH_CLARA_OPEN_NAMESPACE
+
+// Restore Clara's value for console width, if present
+#ifdef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
+#define CLARA_CONFIG_CONSOLE_WIDTH CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
+#undef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
+#endif
+
+#include <fstream>
+
+namespace Catch {
+
+    inline void abortAfterFirst( ConfigData& config ) { config.abortAfter = 1; }
+    inline void abortAfterX( ConfigData& config, int x ) {
+        if( x < 1 )
+            throw std::runtime_error( "Value after -x or --abortAfter must be greater than zero" );
+        config.abortAfter = x;
+    }
+    inline void addTestOrTags( ConfigData& config, std::string const& _testSpec ) { config.testsOrTags.push_back( _testSpec ); }
+
+    inline void addWarning( ConfigData& config, std::string const& _warning ) {
+        if( _warning == "NoAssertions" )
+            config.warnings = static_cast<WarnAbout::What>( config.warnings | WarnAbout::NoAssertions );
+        else
+            throw std::runtime_error( "Unrecognised warning: '" + _warning + "'" );
+
+    }
+    inline void setVerbosity( ConfigData& config, int level ) {
+        // !TBD: accept strings?
+        config.verbosity = static_cast<Verbosity::Level>( level );
+    }
+    inline void setShowDurations( ConfigData& config, bool _showDurations ) {
+        config.showDurations = _showDurations
+            ? ShowDurations::Always
+            : ShowDurations::Never;
+    }
+    inline void loadTestNamesFromFile( ConfigData& config, std::string const& _filename ) {
+        std::ifstream f( _filename.c_str() );
+        if( !f.is_open() )
+            throw std::domain_error( "Unable to load input file: " + _filename );
+
+        std::string line;
+        while( std::getline( f, line ) ) {
+            line = trim(line);
+            if( !line.empty() && !startsWith( line, "#" ) )
+                addTestOrTags( config, "\"" + line + "\"," );
+        }
+    }
+
+    inline Clara::CommandLine<ConfigData> makeCommandLineParser() {
+
+        using namespace Clara;
+        CommandLine<ConfigData> cli;
+
+        cli.bindProcessName( &ConfigData::processName );
+
+        cli["-?"]["-h"]["--help"]
+            .describe( "display usage information" )
+            .bind( &ConfigData::showHelp );
+
+        cli["-l"]["--list-tests"]
+            .describe( "list all/matching test cases" )
+            .bind( &ConfigData::listTests );
+
+        cli["-t"]["--list-tags"]
+            .describe( "list all/matching tags" )
+            .bind( &ConfigData::listTags );
+
+        cli["-s"]["--success"]
+            .describe( "include successful tests in output" )
+            .bind( &ConfigData::showSuccessfulTests );
+
+        cli["-b"]["--break"]
+            .describe( "break into debugger on failure" )
+            .bind( &ConfigData::shouldDebugBreak );
+
+        cli["-e"]["--nothrow"]
+            .describe( "skip exception tests" )
+            .bind( &ConfigData::noThrow );
+
+        cli["-i"]["--invisibles"]
+            .describe( "show invisibles (tabs, newlines)" )
+            .bind( &ConfigData::showInvisibles );
+
+        cli["-o"]["--out"]
+            .describe( "output filename" )
+            .bind( &ConfigData::outputFilename, "filename" );
+
+        cli["-r"]["--reporter"]
+//            .placeholder( "name[:filename]" )
+            .describe( "reporter to use (defaults to console)" )
+            .bind( &ConfigData::reporterName, "name" );
+
+        cli["-n"]["--name"]
+            .describe( "suite name" )
+            .bind( &ConfigData::name, "name" );
+
+        cli["-a"]["--abort"]
+            .describe( "abort at first failure" )
+            .bind( &abortAfterFirst );
+
+        cli["-x"]["--abortx"]
+            .describe( "abort after x failures" )
+            .bind( &abortAfterX, "no. failures" );
+
+        cli["-w"]["--warn"]
+            .describe( "enable warnings" )
+            .bind( &addWarning, "warning name" );
+
+// - needs updating if reinstated
+//        cli.into( &setVerbosity )
+//            .describe( "level of verbosity (0=no output)" )
+//            .shortOpt( "v")
+//            .longOpt( "verbosity" )
+//            .placeholder( "level" );
+
+        cli[_]
+            .describe( "which test or tests to use" )
+            .bind( &addTestOrTags, "test name, pattern or tags" );
+
+        cli["-d"]["--durations"]
+            .describe( "show test durations" )
+            .bind( &setShowDurations, "yes/no" );
+
+        cli["-f"]["--input-file"]
+            .describe( "load test names to run from a file" )
+            .bind( &loadTestNamesFromFile, "filename" );
+
+        // Less common commands which don't have a short form
+        cli["--list-test-names-only"]
+            .describe( "list all/matching test cases names only" )
+            .bind( &ConfigData::listTestNamesOnly );
+
+        cli["--list-reporters"]
+            .describe( "list all reporters" )
+            .bind( &ConfigData::listReporters );
+
+        return cli;
+    }
+
+} // end namespace Catch
+
+// #included from: internal/catch_list.hpp
+#define TWOBLUECUBES_CATCH_LIST_HPP_INCLUDED
+
+// #included from: catch_text.h
+#define TWOBLUECUBES_CATCH_TEXT_H_INCLUDED
+
+#define TBC_TEXT_FORMAT_CONSOLE_WIDTH CATCH_CONFIG_CONSOLE_WIDTH
+
+#define CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE Catch
+// #included from: ../external/tbc_text_format.h
+// Only use header guard if we are not using an outer namespace
+#ifndef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE
+# ifdef TWOBLUECUBES_TEXT_FORMAT_H_INCLUDED
+#  ifndef TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED
+#   define TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED
+#  endif
+# else
+#  define TWOBLUECUBES_TEXT_FORMAT_H_INCLUDED
+# endif
+#endif
+#ifndef TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED
+#include <string>
+#include <vector>
+#include <sstream>
+
+// Use optional outer namespace
+#ifdef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE
+namespace CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE {
+#endif
+
+namespace Tbc {
+
+#ifdef TBC_TEXT_FORMAT_CONSOLE_WIDTH
+    const unsigned int consoleWidth = TBC_TEXT_FORMAT_CONSOLE_WIDTH;
+#else
+    const unsigned int consoleWidth = 80;
+#endif
+
+    struct TextAttributes {
+        TextAttributes()
+        :   initialIndent( std::string::npos ),
+            indent( 0 ),
+            width( consoleWidth-1 ),
+            tabChar( '\t' )
+        {}
+
+        TextAttributes& setInitialIndent( std::size_t _value )  { initialIndent = _value; return *this; }
+        TextAttributes& setIndent( std::size_t _value )         { indent = _value; return *this; }
+        TextAttributes& setWidth( std::size_t _value )          { width = _value; return *this; }
+        TextAttributes& setTabChar( char _value )               { tabChar = _value; return *this; }
+
+        std::size_t initialIndent;  // indent of first line, or npos
+        std::size_t indent;         // indent of subsequent lines, or all if initialIndent is npos
+        std::size_t width;          // maximum width of text, including indent. Longer text will wrap
+        char tabChar;               // If this char is seen the indent is changed to current pos
+    };
+
+    class Text {
+    public:
+        Text( std::string const& _str, TextAttributes const& _attr = TextAttributes() )
+        : attr( _attr )
+        {
+            std::string wrappableChars = " [({.,/|\\-";
+            std::size_t indent = _attr.initialIndent != std::string::npos
+                ? _attr.initialIndent
+                : _attr.indent;
+            std::string remainder = _str;
+
+            while( !remainder.empty() ) {
+                if( lines.size() >= 1000 ) {
+                    lines.push_back( "... message truncated due to excessive size" );
+                    return;
+                }
+                std::size_t tabPos = std::string::npos;
+                std::size_t width = (std::min)( remainder.size(), _attr.width - indent );
+                std::size_t pos = remainder.find_first_of( '\n' );
+                if( pos <= width ) {
+                    width = pos;
+                }
+                pos = remainder.find_last_of( _attr.tabChar, width );
+                if( pos != std::string::npos ) {
+                    tabPos = pos;
+                    if( remainder[width] == '\n' )
+                        width--;
+                    remainder = remainder.substr( 0, tabPos ) + remainder.substr( tabPos+1 );
+                }
+
+                if( width == remainder.size() ) {
+                    spliceLine( indent, remainder, width );
+                }
+                else if( remainder[width] == '\n' ) {
+                    spliceLine( indent, remainder, width );
+                    if( width <= 1 || remainder.size() != 1 )
+                        remainder = remainder.substr( 1 );
+                    indent = _attr.indent;
+                }
+                else {
+                    pos = remainder.find_last_of( wrappableChars, width );
+                    if( pos != std::string::npos && pos > 0 ) {
+                        spliceLine( indent, remainder, pos );
+                        if( remainder[0] == ' ' )
+                            remainder = remainder.substr( 1 );
+                    }
+                    else {
+                        spliceLine( indent, remainder, width-1 );
+                        lines.back() += "-";
+                    }
+                    if( lines.size() == 1 )
+                        indent = _attr.indent;
+                    if( tabPos != std::string::npos )
+                        indent += tabPos;
+                }
+            }
+        }
+
+        void spliceLine( std::size_t _indent, std::string& _remainder, std::size_t _pos ) {
+            lines.push_back( std::string( _indent, ' ' ) + _remainder.substr( 0, _pos ) );
+            _remainder = _remainder.substr( _pos );
+        }
+
+        typedef std::vector<std::string>::const_iterator const_iterator;
+
+        const_iterator begin() const { return lines.begin(); }
+        const_iterator end() const { return lines.end(); }
+        std::string const& last() const { return lines.back(); }
+        std::size_t size() const { return lines.size(); }
+        std::string const& operator[]( std::size_t _index ) const { return lines[_index]; }
+        std::string toString() const {
+            std::ostringstream oss;
+            oss << *this;
+            return oss.str();
+        }
+
+        inline friend std::ostream& operator << ( std::ostream& _stream, Text const& _text ) {
+            for( Text::const_iterator it = _text.begin(), itEnd = _text.end();
+                it != itEnd; ++it ) {
+                if( it != _text.begin() )
+                    _stream << "\n";
+                _stream << *it;
+            }
+            return _stream;
+        }
+
+    private:
+        std::string str;
+        TextAttributes attr;
+        std::vector<std::string> lines;
+    };
+
+} // end namespace Tbc
+
+#ifdef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE
+} // end outer namespace
+#endif
+
+#endif // TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED
+#undef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE
+
+namespace Catch {
+    using Tbc::Text;
+    using Tbc::TextAttributes;
+}
+
+// #included from: catch_console_colour.hpp
+#define TWOBLUECUBES_CATCH_CONSOLE_COLOUR_HPP_INCLUDED
+
+namespace Catch {
+
+    namespace Detail {
+        struct IColourImpl;
+    }
+
+    struct Colour {
+        enum Code {
+            None = 0,
+
+            White,
+            Red,
+            Green,
+            Blue,
+            Cyan,
+            Yellow,
+            Grey,
+
+            Bright = 0x10,
+
+            BrightRed = Bright | Red,
+            BrightGreen = Bright | Green,
+            LightGrey = Bright | Grey,
+            BrightWhite = Bright | White,
+
+            // By intention
+            FileName = LightGrey,
+            Warning = Yellow,
+            ResultError = BrightRed,
+            ResultSuccess = BrightGreen,
+            ResultExpectedFailure = Warning,
+
+            Error = BrightRed,
+            Success = Green,
+
+            OriginalExpression = Cyan,
+            ReconstructedExpression = Yellow,
+
+            SecondaryText = LightGrey,
+            Headers = White
+        };
+
+        // Use constructed object for RAII guard
+        Colour( Code _colourCode );
+        Colour( Colour const& other );
+        ~Colour();
+
+        // Use static method for one-shot changes
+        static void use( Code _colourCode );
+
+    private:
+        static Detail::IColourImpl* impl();
+        bool m_moved;
+    };
+
+    inline std::ostream& operator << ( std::ostream& os, Colour const& ) { return os; }
+
+} // end namespace Catch
+
+// #included from: catch_interfaces_reporter.h
+#define TWOBLUECUBES_CATCH_INTERFACES_REPORTER_H_INCLUDED
+
+#include <string>
+#include <ostream>
+#include <map>
+#include <assert.h>
+
+namespace Catch
+{
+    struct ReporterConfig {
+        explicit ReporterConfig( Ptr<IConfig> const& _fullConfig )
+        :   m_stream( &_fullConfig->stream() ), m_fullConfig( _fullConfig ) {}
+
+        ReporterConfig( Ptr<IConfig> const& _fullConfig, std::ostream& _stream )
+        :   m_stream( &_stream ), m_fullConfig( _fullConfig ) {}
+
+        std::ostream& stream() const    { return *m_stream; }
+        Ptr<IConfig> fullConfig() const { return m_fullConfig; }
+
+    private:
+        std::ostream* m_stream;
+        Ptr<IConfig> m_fullConfig;
+    };
+
+    struct ReporterPreferences {
+        ReporterPreferences()
+        : shouldRedirectStdOut( false )
+        {}
+
+        bool shouldRedirectStdOut;
+    };
+
+    template<typename T>
+    struct LazyStat : Option<T> {
+        LazyStat() : used( false ) {}
+        LazyStat& operator=( T const& _value ) {
+            Option<T>::operator=( _value );
+            used = false;
+            return *this;
+        }
+        void reset() {
+            Option<T>::reset();
+            used = false;
+        }
+        bool used;
+    };
+
+    struct TestRunInfo {
+        TestRunInfo( std::string const& _name ) : name( _name ) {}
+        std::string name;
+    };
+    struct GroupInfo {
+        GroupInfo(  std::string const& _name,
+                    std::size_t _groupIndex,
+                    std::size_t _groupsCount )
+        :   name( _name ),
+            groupIndex( _groupIndex ),
+            groupsCounts( _groupsCount )
+        {}
+
+        std::string name;
+        std::size_t groupIndex;
+        std::size_t groupsCounts;
+    };
+
+    struct AssertionStats {
+        AssertionStats( AssertionResult const& _assertionResult,
+                        std::vector<MessageInfo> const& _infoMessages,
+                        Totals const& _totals )
+        :   assertionResult( _assertionResult ),
+            infoMessages( _infoMessages ),
+            totals( _totals )
+        {
+            if( assertionResult.hasMessage() ) {
+                // Copy message into messages list.
+                // !TBD This should have been done earlier, somewhere
+                MessageBuilder builder( assertionResult.getTestMacroName(), assertionResult.getSourceInfo(), assertionResult.getResultType() );
+                builder << assertionResult.getMessage();
+                builder.m_info.message = builder.m_stream.str();
+
+                infoMessages.push_back( builder.m_info );
+            }
+        }
+        virtual ~AssertionStats();
+
+#  ifdef CATCH_CPP11_OR_GREATER
+        AssertionStats( AssertionStats const& )              = default;
+        AssertionStats( AssertionStats && )                  = default;
+        AssertionStats& operator = ( AssertionStats const& ) = default;
+        AssertionStats& operator = ( AssertionStats && )     = default;
+#  endif
+
+        AssertionResult assertionResult;
+        std::vector<MessageInfo> infoMessages;
+        Totals totals;
+    };
+
+    struct SectionStats {
+        SectionStats(   SectionInfo const& _sectionInfo,
+                        Counts const& _assertions,
+                        double _durationInSeconds,
+                        bool _missingAssertions )
+        :   sectionInfo( _sectionInfo ),
+            assertions( _assertions ),
+            durationInSeconds( _durationInSeconds ),
+            missingAssertions( _missingAssertions )
+        {}
+        virtual ~SectionStats();
+#  ifdef CATCH_CPP11_OR_GREATER
+        SectionStats( SectionStats const& )              = default;
+        SectionStats( SectionStats && )                  = default;
+        SectionStats& operator = ( SectionStats const& ) = default;
+        SectionStats& operator = ( SectionStats && )     = default;
+#  endif
+
+        SectionInfo sectionInfo;
+        Counts assertions;
+        double durationInSeconds;
+        bool missingAssertions;
+    };
+
+    struct TestCaseStats {
+        TestCaseStats(  TestCaseInfo const& _testInfo,
+                        Totals const& _totals,
+                        std::string const& _stdOut,
+                        std::string const& _stdErr,
+                        bool _aborting )
+        : testInfo( _testInfo ),
+            totals( _totals ),
+            stdOut( _stdOut ),
+            stdErr( _stdErr ),
+            aborting( _aborting )
+        {}
+        virtual ~TestCaseStats();
+
+#  ifdef CATCH_CPP11_OR_GREATER
+        TestCaseStats( TestCaseStats const& )              = default;
+        TestCaseStats( TestCaseStats && )                  = default;
+        TestCaseStats& operator = ( TestCaseStats const& ) = default;
+        TestCaseStats& operator = ( TestCaseStats && )     = default;
+#  endif
+
+        TestCaseInfo testInfo;
+        Totals totals;
+        std::string stdOut;
+        std::string stdErr;
+        bool aborting;
+    };
+
+    struct TestGroupStats {
+        TestGroupStats( GroupInfo const& _groupInfo,
+                        Totals const& _totals,
+                        bool _aborting )
+        :   groupInfo( _groupInfo ),
+            totals( _totals ),
+            aborting( _aborting )
+        {}
+        TestGroupStats( GroupInfo const& _groupInfo )
+        :   groupInfo( _groupInfo ),
+            aborting( false )
+        {}
+        virtual ~TestGroupStats();
+
+#  ifdef CATCH_CPP11_OR_GREATER
+        TestGroupStats( TestGroupStats const& )              = default;
+        TestGroupStats( TestGroupStats && )                  = default;
+        TestGroupStats& operator = ( TestGroupStats const& ) = default;
+        TestGroupStats& operator = ( TestGroupStats && )     = default;
+#  endif
+
+        GroupInfo groupInfo;
+        Totals totals;
+        bool aborting;
+    };
+
+    struct TestRunStats {
+        TestRunStats(   TestRunInfo const& _runInfo,
+                        Totals const& _totals,
+                        bool _aborting )
+        :   runInfo( _runInfo ),
+            totals( _totals ),
+            aborting( _aborting )
+        {}
+        virtual ~TestRunStats();
+
+#  ifndef CATCH_CPP11_OR_GREATER
+        TestRunStats( TestRunStats const& _other )
+        :   runInfo( _other.runInfo ),
+            totals( _other.totals ),
+            aborting( _other.aborting )
+        {}
+#  else
+        TestRunStats( TestRunStats const& )              = default;
+        TestRunStats( TestRunStats && )                  = default;
+        TestRunStats& operator = ( TestRunStats const& ) = default;
+        TestRunStats& operator = ( TestRunStats && )     = default;
+#  endif
+
+        TestRunInfo runInfo;
+        Totals totals;
+        bool aborting;
+    };
+
+    struct IStreamingReporter : IShared {
+        virtual ~IStreamingReporter();
+
+        // Implementing class must also provide the following static method:
+        // static std::string getDescription();
+
+        virtual ReporterPreferences getPreferences() const = 0;
+
+        virtual void noMatchingTestCases( std::string const& spec ) = 0;
+
+        virtual void testRunStarting( TestRunInfo const& testRunInfo ) = 0;
+        virtual void testGroupStarting( GroupInfo const& groupInfo ) = 0;
+
+        virtual void testCaseStarting( TestCaseInfo const& testInfo ) = 0;
+        virtual void sectionStarting( SectionInfo const& sectionInfo ) = 0;
+
+        virtual void assertionStarting( AssertionInfo const& assertionInfo ) = 0;
+
+        virtual bool assertionEnded( AssertionStats const& assertionStats ) = 0;
+        virtual void sectionEnded( SectionStats const& sectionStats ) = 0;
+        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) = 0;
+        virtual void testGroupEnded( TestGroupStats const& testGroupStats ) = 0;
+        virtual void testRunEnded( TestRunStats const& testRunStats ) = 0;
+    };
+
+    struct IReporterFactory {
+        virtual ~IReporterFactory();
+        virtual IStreamingReporter* create( ReporterConfig const& config ) const = 0;
+        virtual std::string getDescription() const = 0;
+    };
+
+    struct IReporterRegistry {
+        typedef std::map<std::string, IReporterFactory*> FactoryMap;
+
+        virtual ~IReporterRegistry();
+        virtual IStreamingReporter* create( std::string const& name, Ptr<IConfig> const& config ) const = 0;
+        virtual FactoryMap const& getFactories() const = 0;
+    };
+
+}
+
+#include <limits>
+#include <algorithm>
+
+namespace Catch {
+
+    inline std::size_t listTests( Config const& config ) {
+
+        TestSpec testSpec = config.testSpec();
+        if( config.testSpec().hasFilters() )
+            std::cout << "Matching test cases:\n";
+        else {
+            std::cout << "All available test cases:\n";
+            testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "*" ).testSpec();
+        }
+
+        std::size_t matchedTests = 0;
+        TextAttributes nameAttr, tagsAttr;
+        nameAttr.setInitialIndent( 2 ).setIndent( 4 );
+        tagsAttr.setIndent( 6 );
+
+        std::vector<TestCase> matchedTestCases;
+        getRegistryHub().getTestCaseRegistry().getFilteredTests( testSpec, config, matchedTestCases );
+        for( std::vector<TestCase>::const_iterator it = matchedTestCases.begin(), itEnd = matchedTestCases.end();
+                it != itEnd;
+                ++it ) {
+            matchedTests++;
+            TestCaseInfo const& testCaseInfo = it->getTestCaseInfo();
+            Colour::Code colour = testCaseInfo.isHidden()
+                ? Colour::SecondaryText
+                : Colour::None;
+            Colour colourGuard( colour );
+
+            std::cout << Text( testCaseInfo.name, nameAttr ) << std::endl;
+            if( !testCaseInfo.tags.empty() )
+                std::cout << Text( testCaseInfo.tagsAsString, tagsAttr ) << std::endl;
+        }
+
+        if( !config.testSpec().hasFilters() )
+            std::cout << pluralise( matchedTests, "test case" ) << "\n" << std::endl;
+        else
+            std::cout << pluralise( matchedTests, "matching test case" ) << "\n" << std::endl;
+        return matchedTests;
+    }
+
+    inline std::size_t listTestsNamesOnly( Config const& config ) {
+        TestSpec testSpec = config.testSpec();
+        if( !config.testSpec().hasFilters() )
+            testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "*" ).testSpec();
+        std::size_t matchedTests = 0;
+        std::vector<TestCase> matchedTestCases;
+        getRegistryHub().getTestCaseRegistry().getFilteredTests( testSpec, config, matchedTestCases );
+        for( std::vector<TestCase>::const_iterator it = matchedTestCases.begin(), itEnd = matchedTestCases.end();
+                it != itEnd;
+                ++it ) {
+            matchedTests++;
+            TestCaseInfo const& testCaseInfo = it->getTestCaseInfo();
+            std::cout << testCaseInfo.name << std::endl;
+        }
+        return matchedTests;
+    }
+
+    struct TagInfo {
+        TagInfo() : count ( 0 ) {}
+        void add( std::string const& spelling ) {
+            ++count;
+            spellings.insert( spelling );
+        }
+        std::string all() const {
+            std::string out;
+            for( std::set<std::string>::const_iterator it = spellings.begin(), itEnd = spellings.end();
+                        it != itEnd;
+                        ++it )
+                out += "[" + *it + "]";
+            return out;
+        }
+        std::set<std::string> spellings;
+        std::size_t count;
+    };
+
+    inline std::size_t listTags( Config const& config ) {
+        TestSpec testSpec = config.testSpec();
+        if( config.testSpec().hasFilters() )
+            std::cout << "Tags for matching test cases:\n";
+        else {
+            std::cout << "All available tags:\n";
+            testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "*" ).testSpec();
+        }
+
+        std::map<std::string, TagInfo> tagCounts;
+
+        std::vector<TestCase> matchedTestCases;
+        getRegistryHub().getTestCaseRegistry().getFilteredTests( testSpec, config, matchedTestCases );
+        for( std::vector<TestCase>::const_iterator it = matchedTestCases.begin(), itEnd = matchedTestCases.end();
+                it != itEnd;
+                ++it ) {
+            for( std::set<std::string>::const_iterator  tagIt = it->getTestCaseInfo().tags.begin(),
+                                                        tagItEnd = it->getTestCaseInfo().tags.end();
+                    tagIt != tagItEnd;
+                    ++tagIt ) {
+                std::string tagName = *tagIt;
+                std::string lcaseTagName = toLower( tagName );
+                std::map<std::string, TagInfo>::iterator countIt = tagCounts.find( lcaseTagName );
+                if( countIt == tagCounts.end() )
+                    countIt = tagCounts.insert( std::make_pair( lcaseTagName, TagInfo() ) ).first;
+                countIt->second.add( tagName );
+            }
+        }
+
+        for( std::map<std::string, TagInfo>::const_iterator countIt = tagCounts.begin(),
+                                                            countItEnd = tagCounts.end();
+                countIt != countItEnd;
+                ++countIt ) {
+            std::ostringstream oss;
+            oss << "  " << std::setw(2) << countIt->second.count << "  ";
+            Text wrapper( countIt->second.all(), TextAttributes()
+                                                    .setInitialIndent( 0 )
+                                                    .setIndent( oss.str().size() )
+                                                    .setWidth( CATCH_CONFIG_CONSOLE_WIDTH-10 ) );
+            std::cout << oss.str() << wrapper << "\n";
+        }
+        std::cout << pluralise( tagCounts.size(), "tag" ) << "\n" << std::endl;
+        return tagCounts.size();
+    }
+
+    inline std::size_t listReporters( Config const& /*config*/ ) {
+        std::cout << "Available reports:\n";
+        IReporterRegistry::FactoryMap const& factories = getRegistryHub().getReporterRegistry().getFactories();
+        IReporterRegistry::FactoryMap::const_iterator itBegin = factories.begin(), itEnd = factories.end(), it;
+        std::size_t maxNameLen = 0;
+        for(it = itBegin; it != itEnd; ++it )
+            maxNameLen = (std::max)( maxNameLen, it->first.size() );
+
+        for(it = itBegin; it != itEnd; ++it ) {
+            Text wrapper( it->second->getDescription(), TextAttributes()
+                                                        .setInitialIndent( 0 )
+                                                        .setIndent( 7+maxNameLen )
+                                                        .setWidth( CATCH_CONFIG_CONSOLE_WIDTH - maxNameLen-8 ) );
+            std::cout << "  "
+                    << it->first
+                    << ":"
+                    << std::string( maxNameLen - it->first.size() + 2, ' ' )
+                    << wrapper << "\n";
+        }
+        std::cout << std::endl;
+        return factories.size();
+    }
+
+    inline Option<std::size_t> list( Config const& config ) {
+        Option<std::size_t> listedCount;
+        if( config.listTests() )
+            listedCount = listedCount.valueOr(0) + listTests( config );
+        if( config.listTestNamesOnly() )
+            listedCount = listedCount.valueOr(0) + listTestsNamesOnly( config );
+        if( config.listTags() )
+            listedCount = listedCount.valueOr(0) + listTags( config );
+        if( config.listReporters() )
+            listedCount = listedCount.valueOr(0) + listReporters( config );
+        return listedCount;
+    }
+
+} // end namespace Catch
+
+// #included from: internal/catch_runner_impl.hpp
+#define TWOBLUECUBES_CATCH_RUNNER_IMPL_HPP_INCLUDED
+
+// #included from: catch_test_case_tracker.hpp
+#define TWOBLUECUBES_CATCH_TEST_CASE_TRACKER_HPP_INCLUDED
+
+#include <map>
+#include <string>
+#include <assert.h>
+
+namespace Catch {
+namespace SectionTracking {
+
+    class TrackedSection {
+
+        typedef std::map<std::string, TrackedSection> TrackedSections;
+
+    public:
+        enum RunState {
+            NotStarted,
+            Executing,
+            ExecutingChildren,
+            Completed
+        };
+
+        TrackedSection( std::string const& name, TrackedSection* parent )
+        :   m_name( name ), m_runState( NotStarted ), m_parent( parent )
+        {}
+
+        RunState runState() const { return m_runState; }
+
+        TrackedSection* findChild( std::string const& childName ) {
+            TrackedSections::iterator it = m_children.find( childName );
+            return it != m_children.end()
+                ? &it->second
+                : NULL;
+        }
+        TrackedSection* acquireChild( std::string const& childName ) {
+            if( TrackedSection* child = findChild( childName ) )
+                return child;
+            m_children.insert( std::make_pair( childName, TrackedSection( childName, this ) ) );
+            return findChild( childName );
+        }
+        void enter() {
+            if( m_runState == NotStarted )
+                m_runState = Executing;
+        }
+        void leave() {
+            for( TrackedSections::const_iterator it = m_children.begin(), itEnd = m_children.end();
+                    it != itEnd;
+                    ++it )
+                if( it->second.runState() != Completed ) {
+                    m_runState = ExecutingChildren;
+                    return;
+                }
+            m_runState = Completed;
+        }
+        TrackedSection* getParent() {
+            return m_parent;
+        }
+        bool hasChildren() const {
+            return !m_children.empty();
+        }
+
+    private:
+        std::string m_name;
+        RunState m_runState;
+        TrackedSections m_children;
+        TrackedSection* m_parent;
+
+    };
+
+    class TestCaseTracker {
+    public:
+        TestCaseTracker( std::string const& testCaseName )
+        :   m_testCase( testCaseName, NULL ),
+            m_currentSection( &m_testCase ),
+            m_completedASectionThisRun( false )
+        {}
+
+        bool enterSection( std::string const& name ) {
+            TrackedSection* child = m_currentSection->acquireChild( name );
+            if( m_completedASectionThisRun || child->runState() == TrackedSection::Completed )
+                return false;
+
+            m_currentSection = child;
+            m_currentSection->enter();
+            return true;
+        }
+        void leaveSection() {
+            m_currentSection->leave();
+            m_currentSection = m_currentSection->getParent();
+            assert( m_currentSection != NULL );
+            m_completedASectionThisRun = true;
+        }
+
+        bool currentSectionHasChildren() const {
+            return m_currentSection->hasChildren();
+        }
+        bool isCompleted() const {
+            return m_testCase.runState() == TrackedSection::Completed;
+        }
+
+        class Guard {
+        public:
+            Guard( TestCaseTracker& tracker ) : m_tracker( tracker ) {
+                m_tracker.enterTestCase();
+            }
+            ~Guard() {
+                m_tracker.leaveTestCase();
+            }
+        private:
+            Guard( Guard const& );
+            void operator = ( Guard const& );
+            TestCaseTracker& m_tracker;
+        };
+
+    private:
+        void enterTestCase() {
+            m_currentSection = &m_testCase;
+            m_completedASectionThisRun = false;
+            m_testCase.enter();
+        }
+        void leaveTestCase() {
+            m_testCase.leave();
+        }
+
+        TrackedSection m_testCase;
+        TrackedSection* m_currentSection;
+        bool m_completedASectionThisRun;
+    };
+
+} // namespace SectionTracking
+
+using SectionTracking::TestCaseTracker;
+
+} // namespace Catch
+
+#include <set>
+#include <string>
+
+namespace Catch {
+
+    class StreamRedirect {
+
+    public:
+        StreamRedirect( std::ostream& stream, std::string& targetString )
+        :   m_stream( stream ),
+            m_prevBuf( stream.rdbuf() ),
+            m_targetString( targetString )
+        {
+            stream.rdbuf( m_oss.rdbuf() );
+        }
+
+        ~StreamRedirect() {
+            m_targetString += m_oss.str();
+            m_stream.rdbuf( m_prevBuf );
+        }
+
+    private:
+        std::ostream& m_stream;
+        std::streambuf* m_prevBuf;
+        std::ostringstream m_oss;
+        std::string& m_targetString;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    class RunContext : public IResultCapture, public IRunner {
+
+        RunContext( RunContext const& );
+        void operator =( RunContext const& );
+
+    public:
+
+        explicit RunContext( Ptr<IConfig const> const& config, Ptr<IStreamingReporter> const& reporter )
+        :   m_runInfo( config->name() ),
+            m_context( getCurrentMutableContext() ),
+            m_activeTestCase( NULL ),
+            m_config( config ),
+            m_reporter( reporter ),
+            m_prevRunner( m_context.getRunner() ),
+            m_prevResultCapture( m_context.getResultCapture() ),
+            m_prevConfig( m_context.getConfig() )
+        {
+            m_context.setRunner( this );
+            m_context.setConfig( m_config );
+            m_context.setResultCapture( this );
+            m_reporter->testRunStarting( m_runInfo );
+        }
+
+        virtual ~RunContext() {
+            m_reporter->testRunEnded( TestRunStats( m_runInfo, m_totals, aborting() ) );
+            m_context.setRunner( m_prevRunner );
+            m_context.setConfig( NULL );
+            m_context.setResultCapture( m_prevResultCapture );
+            m_context.setConfig( m_prevConfig );
+        }
+
+        void testGroupStarting( std::string const& testSpec, std::size_t groupIndex, std::size_t groupsCount ) {
+            m_reporter->testGroupStarting( GroupInfo( testSpec, groupIndex, groupsCount ) );
+        }
+        void testGroupEnded( std::string const& testSpec, Totals const& totals, std::size_t groupIndex, std::size_t groupsCount ) {
+            m_reporter->testGroupEnded( TestGroupStats( GroupInfo( testSpec, groupIndex, groupsCount ), totals, aborting() ) );
+        }
+
+        Totals runTest( TestCase const& testCase ) {
+            Totals prevTotals = m_totals;
+
+            std::string redirectedCout;
+            std::string redirectedCerr;
+
+            TestCaseInfo testInfo = testCase.getTestCaseInfo();
+
+            m_reporter->testCaseStarting( testInfo );
+
+            m_activeTestCase = &testCase;
+            m_testCaseTracker = TestCaseTracker( testInfo.name );
+
+            do {
+                do {
+                    runCurrentTest( redirectedCout, redirectedCerr );
+                }
+                while( !m_testCaseTracker->isCompleted() && !aborting() );
+            }
+            while( getCurrentContext().advanceGeneratorsForCurrentTest() && !aborting() );
+
+            Totals deltaTotals = m_totals.delta( prevTotals );
+            m_totals.testCases += deltaTotals.testCases;
+            m_reporter->testCaseEnded( TestCaseStats(   testInfo,
+                                                        deltaTotals,
+                                                        redirectedCout,
+                                                        redirectedCerr,
+                                                        aborting() ) );
+
+            m_activeTestCase = NULL;
+            m_testCaseTracker.reset();
+
+            return deltaTotals;
+        }
+
+        Ptr<IConfig const> config() const {
+            return m_config;
+        }
+
+    private: // IResultCapture
+
+        virtual void assertionEnded( AssertionResult const& result ) {
+            if( result.getResultType() == ResultWas::Ok ) {
+                m_totals.assertions.passed++;
+            }
+            else if( !result.isOk() ) {
+                m_totals.assertions.failed++;
+            }
+
+            if( m_reporter->assertionEnded( AssertionStats( result, m_messages, m_totals ) ) )
+                m_messages.clear();
+
+            // Reset working state
+            m_lastAssertionInfo = AssertionInfo( "", m_lastAssertionInfo.lineInfo, "{Unknown expression after the reported line}" , m_lastAssertionInfo.resultDisposition );
+            m_lastResult = result;
+        }
+
+        virtual bool sectionStarted (
+            SectionInfo const& sectionInfo,
+            Counts& assertions
+        )
+        {
+            std::ostringstream oss;
+            oss << sectionInfo.name << "@" << sectionInfo.lineInfo;
+
+            if( !m_testCaseTracker->enterSection( oss.str() ) )
+                return false;
+
+            m_lastAssertionInfo.lineInfo = sectionInfo.lineInfo;
+
+            m_reporter->sectionStarting( sectionInfo );
+
+            assertions = m_totals.assertions;
+
+            return true;
+        }
+        bool testForMissingAssertions( Counts& assertions ) {
+            if( assertions.total() != 0 ||
+                    !m_config->warnAboutMissingAssertions() ||
+                    m_testCaseTracker->currentSectionHasChildren() )
+                return false;
+            m_totals.assertions.failed++;
+            assertions.failed++;
+            return true;
+        }
+
+        virtual void sectionEnded( SectionInfo const& info, Counts const& prevAssertions, double _durationInSeconds ) {
+            if( std::uncaught_exception() ) {
+                m_unfinishedSections.push_back( UnfinishedSections( info, prevAssertions, _durationInSeconds ) );
+                return;
+            }
+
+            Counts assertions = m_totals.assertions - prevAssertions;
+            bool missingAssertions = testForMissingAssertions( assertions );
+
+            m_testCaseTracker->leaveSection();
+
+            m_reporter->sectionEnded( SectionStats( info, assertions, _durationInSeconds, missingAssertions ) );
+            m_messages.clear();
+        }
+
+        virtual void pushScopedMessage( MessageInfo const& message ) {
+            m_messages.push_back( message );
+        }
+
+        virtual void popScopedMessage( MessageInfo const& message ) {
+            m_messages.erase( std::remove( m_messages.begin(), m_messages.end(), message ), m_messages.end() );
+        }
+
+        virtual std::string getCurrentTestName() const {
+            return m_activeTestCase
+                ? m_activeTestCase->getTestCaseInfo().name
+                : "";
+        }
+
+        virtual const AssertionResult* getLastResult() const {
+            return &m_lastResult;
+        }
+
+    public:
+        // !TBD We need to do this another way!
+        bool aborting() const {
+            return m_totals.assertions.failed == static_cast<std::size_t>( m_config->abortAfter() );
+        }
+
+    private:
+
+        void runCurrentTest( std::string& redirectedCout, std::string& redirectedCerr ) {
+            TestCaseInfo const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
+            SectionInfo testCaseSection( testCaseInfo.lineInfo, testCaseInfo.name, testCaseInfo.description );
+            m_reporter->sectionStarting( testCaseSection );
+            Counts prevAssertions = m_totals.assertions;
+            double duration = 0;
+            try {
+                m_lastAssertionInfo = AssertionInfo( "TEST_CASE", testCaseInfo.lineInfo, "", ResultDisposition::Normal );
+                TestCaseTracker::Guard guard( *m_testCaseTracker );
+
+                Timer timer;
+                timer.start();
+                if( m_reporter->getPreferences().shouldRedirectStdOut ) {
+                    StreamRedirect coutRedir( std::cout, redirectedCout );
+                    StreamRedirect cerrRedir( std::cerr, redirectedCerr );
+                    m_activeTestCase->invoke();
+                }
+                else {
+                    m_activeTestCase->invoke();
+                }
+                duration = timer.getElapsedSeconds();
+            }
+            catch( TestFailureException& ) {
+                // This just means the test was aborted due to failure
+            }
+            catch(...) {
+                ResultBuilder exResult( m_lastAssertionInfo.macroName.c_str(),
+                                        m_lastAssertionInfo.lineInfo,
+                                        m_lastAssertionInfo.capturedExpression.c_str(),
+                                        m_lastAssertionInfo.resultDisposition );
+                exResult.useActiveException();
+            }
+            // If sections ended prematurely due to an exception we stored their
+            // infos here so we can tear them down outside the unwind process.
+            for( std::vector<UnfinishedSections>::const_reverse_iterator it = m_unfinishedSections.rbegin(),
+                        itEnd = m_unfinishedSections.rend();
+                    it != itEnd;
+                    ++it )
+                sectionEnded( it->info, it->prevAssertions, it->durationInSeconds );
+            m_unfinishedSections.clear();
+            m_messages.clear();
+
+            Counts assertions = m_totals.assertions - prevAssertions;
+            bool missingAssertions = testForMissingAssertions( assertions );
+
+            if( testCaseInfo.okToFail() ) {
+                std::swap( assertions.failedButOk, assertions.failed );
+                m_totals.assertions.failed -= assertions.failedButOk;
+                m_totals.assertions.failedButOk += assertions.failedButOk;
+            }
+
+            SectionStats testCaseSectionStats( testCaseSection, assertions, duration, missingAssertions );
+            m_reporter->sectionEnded( testCaseSectionStats );
+        }
+
+    private:
+        struct UnfinishedSections {
+            UnfinishedSections( SectionInfo const& _info, Counts const& _prevAssertions, double _durationInSeconds )
+            : info( _info ), prevAssertions( _prevAssertions ), durationInSeconds( _durationInSeconds )
+            {}
+
+            SectionInfo info;
+            Counts prevAssertions;
+            double durationInSeconds;
+        };
+
+        TestRunInfo m_runInfo;
+        IMutableContext& m_context;
+        TestCase const* m_activeTestCase;
+        Option<TestCaseTracker> m_testCaseTracker;
+        AssertionResult m_lastResult;
+
+        Ptr<IConfig const> m_config;
+        Totals m_totals;
+        Ptr<IStreamingReporter> m_reporter;
+        std::vector<MessageInfo> m_messages;
+        IRunner* m_prevRunner;
+        IResultCapture* m_prevResultCapture;
+        Ptr<IConfig const> m_prevConfig;
+        AssertionInfo m_lastAssertionInfo;
+        std::vector<UnfinishedSections> m_unfinishedSections;
+    };
+
+    IResultCapture& getResultCapture() {
+        if( IResultCapture* capture = getCurrentContext().getResultCapture() )
+            return *capture;
+        else
+            throw std::logic_error( "No result capture instance" );
+    }
+
+} // end namespace Catch
+
+// #included from: internal/catch_version.h
+#define TWOBLUECUBES_CATCH_VERSION_H_INCLUDED
+
+namespace Catch {
+
+    // Versioning information
+    struct Version {
+        Version(    unsigned int _majorVersion,
+                    unsigned int _minorVersion,
+                    unsigned int _buildNumber,
+                    char const* const _branchName )
+        :   majorVersion( _majorVersion ),
+            minorVersion( _minorVersion ),
+            buildNumber( _buildNumber ),
+            branchName( _branchName )
+        {}
+
+        unsigned int const majorVersion;
+        unsigned int const minorVersion;
+        unsigned int const buildNumber;
+        char const* const branchName;
+
+    private:
+        void operator=( Version const& );
+    };
+
+    extern Version libraryVersion;
+}
+
+#include <fstream>
+#include <stdlib.h>
+#include <limits>
+
+namespace Catch {
+
+    class Runner {
+
+    public:
+        Runner( Ptr<Config> const& config )
+        :   m_config( config )
+        {
+            openStream();
+            makeReporter();
+        }
+
+        Totals runTests() {
+
+            RunContext context( m_config.get(), m_reporter );
+
+            Totals totals;
+
+            context.testGroupStarting( "", 1, 1 ); // deprecated?
+
+            TestSpec testSpec = m_config->testSpec();
+            if( !testSpec.hasFilters() )
+                testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "~[.]" ).testSpec(); // All not hidden tests
+
+            std::vector<TestCase> testCases;
+            getRegistryHub().getTestCaseRegistry().getFilteredTests( testSpec, *m_config, testCases );
+
+            int testsRunForGroup = 0;
+            for( std::vector<TestCase>::const_iterator it = testCases.begin(), itEnd = testCases.end();
+                    it != itEnd;
+                    ++it ) {
+                testsRunForGroup++;
+                if( m_testsAlreadyRun.find( *it ) == m_testsAlreadyRun.end() ) {
+
+                    if( context.aborting() )
+                        break;
+
+                    totals += context.runTest( *it );
+                    m_testsAlreadyRun.insert( *it );
+                }
+            }
+            context.testGroupEnded( "", totals, 1, 1 );
+            return totals;
+        }
+
+    private:
+        void openStream() {
+            // Open output file, if specified
+            if( !m_config->getFilename().empty() ) {
+                m_ofs.open( m_config->getFilename().c_str() );
+                if( m_ofs.fail() ) {
+                    std::ostringstream oss;
+                    oss << "Unable to open file: '" << m_config->getFilename() << "'";
+                    throw std::domain_error( oss.str() );
+                }
+                m_config->setStreamBuf( m_ofs.rdbuf() );
+            }
+        }
+        void makeReporter() {
+            std::string reporterName = m_config->getReporterName().empty()
+                ? "console"
+                : m_config->getReporterName();
+
+            m_reporter = getRegistryHub().getReporterRegistry().create( reporterName, m_config.get() );
+            if( !m_reporter ) {
+                std::ostringstream oss;
+                oss << "No reporter registered with name: '" << reporterName << "'";
+                throw std::domain_error( oss.str() );
+            }
+        }
+
+    private:
+        Ptr<Config> m_config;
+        std::ofstream m_ofs;
+        Ptr<IStreamingReporter> m_reporter;
+        std::set<TestCase> m_testsAlreadyRun;
+    };
+
+    class Session {
+        static bool alreadyInstantiated;
+
+    public:
+
+        struct OnUnusedOptions { enum DoWhat { Ignore, Fail }; };
+
+        Session()
+        : m_cli( makeCommandLineParser() ) {
+            if( alreadyInstantiated ) {
+                std::string msg = "Only one instance of Catch::Session can ever be used";
+                std::cerr << msg << std::endl;
+                throw std::logic_error( msg );
+            }
+            alreadyInstantiated = true;
+        }
+        ~Session() {
+            Catch::cleanUp();
+        }
+
+        void showHelp( std::string const& processName ) {
+            std::cout << "\nCatch v"    << libraryVersion.majorVersion << "."
+                                        << libraryVersion.minorVersion << " build "
+                                        << libraryVersion.buildNumber;
+            if( libraryVersion.branchName != std::string( "master" ) )
+                std::cout << " (" << libraryVersion.branchName << " branch)";
+            std::cout << "\n";
+
+            m_cli.usage( std::cout, processName );
+            std::cout << "For more detail usage please see the project docs\n" << std::endl;
+        }
+
+        int applyCommandLine( int argc, char* const argv[], OnUnusedOptions::DoWhat unusedOptionBehaviour = OnUnusedOptions::Fail ) {
+            try {
+                m_cli.setThrowOnUnrecognisedTokens( unusedOptionBehaviour == OnUnusedOptions::Fail );
+                m_unusedTokens = m_cli.parseInto( argc, argv, m_configData );
+                if( m_configData.showHelp )
+                    showHelp( m_configData.processName );
+                m_config.reset();
+            }
+            catch( std::exception& ex ) {
+                {
+                    Colour colourGuard( Colour::Red );
+                    std::cerr   << "\nError(s) in input:\n"
+                                << Text( ex.what(), TextAttributes().setIndent(2) )
+                                << "\n\n";
+                }
+                m_cli.usage( std::cout, m_configData.processName );
+                return (std::numeric_limits<int>::max)();
+            }
+            return 0;
+        }
+
+        void useConfigData( ConfigData const& _configData ) {
+            m_configData = _configData;
+            m_config.reset();
+        }
+
+        int run( int argc, char* const argv[] ) {
+
+            int returnCode = applyCommandLine( argc, argv );
+            if( returnCode == 0 )
+                returnCode = run();
+            return returnCode;
+        }
+
+        int run() {
+            if( m_configData.showHelp )
+                return 0;
+
+            try
+            {
+                config(); // Force config to be constructed
+                Runner runner( m_config );
+
+                // Handle list request
+                if( Option<std::size_t> listed = list( config() ) )
+                    return static_cast<int>( *listed );
+
+                return static_cast<int>( runner.runTests().assertions.failed );
+            }
+            catch( std::exception& ex ) {
+                std::cerr << ex.what() << std::endl;
+                return (std::numeric_limits<int>::max)();
+            }
+        }
+
+        Clara::CommandLine<ConfigData> const& cli() const {
+            return m_cli;
+        }
+        std::vector<Clara::Parser::Token> const& unusedTokens() const {
+            return m_unusedTokens;
+        }
+        ConfigData& configData() {
+            return m_configData;
+        }
+        Config& config() {
+            if( !m_config )
+                m_config = new Config( m_configData );
+            return *m_config;
+        }
+
+    private:
+        Clara::CommandLine<ConfigData> m_cli;
+        std::vector<Clara::Parser::Token> m_unusedTokens;
+        ConfigData m_configData;
+        Ptr<Config> m_config;
+    };
+
+    bool Session::alreadyInstantiated = false;
+
+} // end namespace Catch
+
+// #included from: catch_registry_hub.hpp
+#define TWOBLUECUBES_CATCH_REGISTRY_HUB_HPP_INCLUDED
+
+// #included from: catch_test_case_registry_impl.hpp
+#define TWOBLUECUBES_CATCH_TEST_CASE_REGISTRY_IMPL_HPP_INCLUDED
+
+#include <vector>
+#include <set>
+#include <sstream>
+#include <iostream>
+
+namespace Catch {
+
+    class TestRegistry : public ITestCaseRegistry {
+    public:
+        TestRegistry() : m_unnamedCount( 0 ) {}
+        virtual ~TestRegistry();
+
+        virtual void registerTest( TestCase const& testCase ) {
+            std::string name = testCase.getTestCaseInfo().name;
+            if( name == "" ) {
+                std::ostringstream oss;
+                oss << "Anonymous test case " << ++m_unnamedCount;
+                return registerTest( testCase.withName( oss.str() ) );
+            }
+
+            if( m_functions.find( testCase ) == m_functions.end() ) {
+                m_functions.insert( testCase );
+                m_functionsInOrder.push_back( testCase );
+                if( !testCase.isHidden() )
+                    m_nonHiddenFunctions.push_back( testCase );
+            }
+            else {
+                TestCase const& prev = *m_functions.find( testCase );
+                {
+                    Colour colourGuard( Colour::Red );
+                    std::cerr   << "error: TEST_CASE( \"" << name << "\" ) already defined.\n"
+                                << "\tFirst seen at " << prev.getTestCaseInfo().lineInfo << "\n"
+                                << "\tRedefined at " << testCase.getTestCaseInfo().lineInfo << std::endl;
+                }
+                exit(1);
+            }
+        }
+
+        virtual std::vector<TestCase> const& getAllTests() const {
+            return m_functionsInOrder;
+        }
+
+        virtual std::vector<TestCase> const& getAllNonHiddenTests() const {
+            return m_nonHiddenFunctions;
+        }
+
+        virtual void getFilteredTests( TestSpec const& testSpec, IConfig const& config, std::vector<TestCase>& matchingTestCases ) const {
+            for( std::vector<TestCase>::const_iterator  it = m_functionsInOrder.begin(),
+                                                        itEnd = m_functionsInOrder.end();
+                    it != itEnd;
+                    ++it ) {
+                if( testSpec.matches( *it ) && ( config.allowThrows() || !it->throws() ) )
+                    matchingTestCases.push_back( *it );
+            }
+        }
+
+    private:
+
+        std::set<TestCase> m_functions;
+        std::vector<TestCase> m_functionsInOrder;
+        std::vector<TestCase> m_nonHiddenFunctions;
+        size_t m_unnamedCount;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    class FreeFunctionTestCase : public SharedImpl<ITestCase> {
+    public:
+
+        FreeFunctionTestCase( TestFunction fun ) : m_fun( fun ) {}
+
+        virtual void invoke() const {
+            m_fun();
+        }
+
+    private:
+        virtual ~FreeFunctionTestCase();
+
+        TestFunction m_fun;
+    };
+
+    inline std::string extractClassName( std::string const& classOrQualifiedMethodName ) {
+        std::string className = classOrQualifiedMethodName;
+        if( startsWith( className, "&" ) )
+        {
+            std::size_t lastColons = className.rfind( "::" );
+            std::size_t penultimateColons = className.rfind( "::", lastColons-1 );
+            if( penultimateColons == std::string::npos )
+                penultimateColons = 1;
+            className = className.substr( penultimateColons, lastColons-penultimateColons );
+        }
+        return className;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    AutoReg::AutoReg(   TestFunction function,
+                        SourceLineInfo const& lineInfo,
+                        NameAndDesc const& nameAndDesc ) {
+        registerTestCase( new FreeFunctionTestCase( function ), "", nameAndDesc, lineInfo );
+    }
+
+    AutoReg::~AutoReg() {}
+
+    void AutoReg::registerTestCase( ITestCase* testCase,
+                                    char const* classOrQualifiedMethodName,
+                                    NameAndDesc const& nameAndDesc,
+                                    SourceLineInfo const& lineInfo ) {
+
+        getMutableRegistryHub().registerTest
+            ( makeTestCase( testCase,
+                            extractClassName( classOrQualifiedMethodName ),
+                            nameAndDesc.name,
+                            nameAndDesc.description,
+                            lineInfo ) );
+    }
+
+} // end namespace Catch
+
+// #included from: catch_reporter_registry.hpp
+#define TWOBLUECUBES_CATCH_REPORTER_REGISTRY_HPP_INCLUDED
+
+#include <map>
+
+namespace Catch {
+
+    class ReporterRegistry : public IReporterRegistry {
+
+    public:
+
+        virtual ~ReporterRegistry() {
+            deleteAllValues( m_factories );
+        }
+
+        virtual IStreamingReporter* create( std::string const& name, Ptr<IConfig> const& config ) const {
+            FactoryMap::const_iterator it =  m_factories.find( name );
+            if( it == m_factories.end() )
+                return NULL;
+            return it->second->create( ReporterConfig( config ) );
+        }
+
+        void registerReporter( std::string const& name, IReporterFactory* factory ) {
+            m_factories.insert( std::make_pair( name, factory ) );
+        }
+
+        FactoryMap const& getFactories() const {
+            return m_factories;
+        }
+
+    private:
+        FactoryMap m_factories;
+    };
+}
+
+// #included from: catch_exception_translator_registry.hpp
+#define TWOBLUECUBES_CATCH_EXCEPTION_TRANSLATOR_REGISTRY_HPP_INCLUDED
+
+#ifdef __OBJC__
+#import "Foundation/Foundation.h"
+#endif
+
+namespace Catch {
+
+    class ExceptionTranslatorRegistry : public IExceptionTranslatorRegistry {
+    public:
+        ~ExceptionTranslatorRegistry() {
+            deleteAll( m_translators );
+        }
+
+        virtual void registerTranslator( const IExceptionTranslator* translator ) {
+            m_translators.push_back( translator );
+        }
+
+        virtual std::string translateActiveException() const {
+            try {
+#ifdef __OBJC__
+                // In Objective-C try objective-c exceptions first
+                @try {
+                    throw;
+                }
+                @catch (NSException *exception) {
+                    return toString( [exception description] );
+                }
+#else
+                throw;
+#endif
+            }
+            catch( TestFailureException& ) {
+                throw;
+            }
+            catch( std::exception& ex ) {
+                return ex.what();
+            }
+            catch( std::string& msg ) {
+                return msg;
+            }
+            catch( const char* msg ) {
+                return msg;
+            }
+            catch(...) {
+                return tryTranslators( m_translators.begin() );
+            }
+        }
+
+        std::string tryTranslators( std::vector<const IExceptionTranslator*>::const_iterator it ) const {
+            if( it == m_translators.end() )
+                return "Unknown exception";
+
+            try {
+                return (*it)->translate();
+            }
+            catch(...) {
+                return tryTranslators( it+1 );
+            }
+        }
+
+    private:
+        std::vector<const IExceptionTranslator*> m_translators;
+    };
+}
+
+namespace Catch {
+
+    namespace {
+
+        class RegistryHub : public IRegistryHub, public IMutableRegistryHub {
+
+            RegistryHub( RegistryHub const& );
+            void operator=( RegistryHub const& );
+
+        public: // IRegistryHub
+            RegistryHub() {
+            }
+            virtual IReporterRegistry const& getReporterRegistry() const {
+                return m_reporterRegistry;
+            }
+            virtual ITestCaseRegistry const& getTestCaseRegistry() const {
+                return m_testCaseRegistry;
+            }
+            virtual IExceptionTranslatorRegistry& getExceptionTranslatorRegistry() {
+                return m_exceptionTranslatorRegistry;
+            }
+
+        public: // IMutableRegistryHub
+            virtual void registerReporter( std::string const& name, IReporterFactory* factory ) {
+                m_reporterRegistry.registerReporter( name, factory );
+            }
+            virtual void registerTest( TestCase const& testInfo ) {
+                m_testCaseRegistry.registerTest( testInfo );
+            }
+            virtual void registerTranslator( const IExceptionTranslator* translator ) {
+                m_exceptionTranslatorRegistry.registerTranslator( translator );
+            }
+
+        private:
+            TestRegistry m_testCaseRegistry;
+            ReporterRegistry m_reporterRegistry;
+            ExceptionTranslatorRegistry m_exceptionTranslatorRegistry;
+        };
+
+        // Single, global, instance
+        inline RegistryHub*& getTheRegistryHub() {
+            static RegistryHub* theRegistryHub = NULL;
+            if( !theRegistryHub )
+                theRegistryHub = new RegistryHub();
+            return theRegistryHub;
+        }
+    }
+
+    IRegistryHub& getRegistryHub() {
+        return *getTheRegistryHub();
+    }
+    IMutableRegistryHub& getMutableRegistryHub() {
+        return *getTheRegistryHub();
+    }
+    void cleanUp() {
+        delete getTheRegistryHub();
+        getTheRegistryHub() = NULL;
+        cleanUpContext();
+    }
+    std::string translateActiveException() {
+        return getRegistryHub().getExceptionTranslatorRegistry().translateActiveException();
+    }
+
+} // end namespace Catch
+
+// #included from: catch_notimplemented_exception.hpp
+#define TWOBLUECUBES_CATCH_NOTIMPLEMENTED_EXCEPTION_HPP_INCLUDED
+
+#include <ostream>
+
+namespace Catch {
+
+    NotImplementedException::NotImplementedException( SourceLineInfo const& lineInfo )
+    :   m_lineInfo( lineInfo ) {
+        std::ostringstream oss;
+        oss << lineInfo << ": function ";
+        oss << "not implemented";
+        m_what = oss.str();
+    }
+
+    const char* NotImplementedException::what() const CATCH_NOEXCEPT {
+        return m_what.c_str();
+    }
+
+} // end namespace Catch
+
+// #included from: catch_context_impl.hpp
+#define TWOBLUECUBES_CATCH_CONTEXT_IMPL_HPP_INCLUDED
+
+// #included from: catch_stream.hpp
+#define TWOBLUECUBES_CATCH_STREAM_HPP_INCLUDED
+
+// #included from: catch_streambuf.h
+#define TWOBLUECUBES_CATCH_STREAMBUF_H_INCLUDED
+
+#include <streambuf>
+
+namespace Catch {
+
+    class StreamBufBase : public std::streambuf {
+    public:
+        virtual ~StreamBufBase() CATCH_NOEXCEPT;
+    };
+}
+
+#include <stdexcept>
+#include <cstdio>
+
+namespace Catch {
+
+    template<typename WriterF, size_t bufferSize=256>
+    class StreamBufImpl : public StreamBufBase {
+        char data[bufferSize];
+        WriterF m_writer;
+
+    public:
+        StreamBufImpl() {
+            setp( data, data + sizeof(data) );
+        }
+
+        ~StreamBufImpl() CATCH_NOEXCEPT {
+            sync();
+        }
+
+    private:
+        int overflow( int c ) {
+            sync();
+
+            if( c != EOF ) {
+                if( pbase() == epptr() )
+                    m_writer( std::string( 1, static_cast<char>( c ) ) );
+                else
+                    sputc( static_cast<char>( c ) );
+            }
+            return 0;
+        }
+
+        int sync() {
+            if( pbase() != pptr() ) {
+                m_writer( std::string( pbase(), static_cast<std::string::size_type>( pptr() - pbase() ) ) );
+                setp( pbase(), epptr() );
+            }
+            return 0;
+        }
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    struct OutputDebugWriter {
+
+        void operator()( std::string const&str ) {
+            writeToDebugConsole( str );
+        }
+    };
+
+    Stream::Stream()
+    : streamBuf( NULL ), isOwned( false )
+    {}
+
+    Stream::Stream( std::streambuf* _streamBuf, bool _isOwned )
+    : streamBuf( _streamBuf ), isOwned( _isOwned )
+    {}
+
+    void Stream::release() {
+        if( isOwned ) {
+            delete streamBuf;
+            streamBuf = NULL;
+            isOwned = false;
+        }
+    }
+}
+
+namespace Catch {
+
+    class Context : public IMutableContext {
+
+        Context() : m_config( NULL ), m_runner( NULL ), m_resultCapture( NULL ) {}
+        Context( Context const& );
+        void operator=( Context const& );
+
+    public: // IContext
+        virtual IResultCapture* getResultCapture() {
+            return m_resultCapture;
+        }
+        virtual IRunner* getRunner() {
+            return m_runner;
+        }
+        virtual size_t getGeneratorIndex( std::string const& fileInfo, size_t totalSize ) {
+            return getGeneratorsForCurrentTest()
+            .getGeneratorInfo( fileInfo, totalSize )
+            .getCurrentIndex();
+        }
+        virtual bool advanceGeneratorsForCurrentTest() {
+            IGeneratorsForTest* generators = findGeneratorsForCurrentTest();
+            return generators && generators->moveNext();
+        }
+
+        virtual Ptr<IConfig const> getConfig() const {
+            return m_config;
+        }
+
+    public: // IMutableContext
+        virtual void setResultCapture( IResultCapture* resultCapture ) {
+            m_resultCapture = resultCapture;
+        }
+        virtual void setRunner( IRunner* runner ) {
+            m_runner = runner;
+        }
+        virtual void setConfig( Ptr<IConfig const> const& config ) {
+            m_config = config;
+        }
+
+        friend IMutableContext& getCurrentMutableContext();
+
+    private:
+        IGeneratorsForTest* findGeneratorsForCurrentTest() {
+            std::string testName = getResultCapture()->getCurrentTestName();
+
+            std::map<std::string, IGeneratorsForTest*>::const_iterator it =
+            m_generatorsByTestName.find( testName );
+            return it != m_generatorsByTestName.end()
+                ? it->second
+                : NULL;
+        }
+
+        IGeneratorsForTest& getGeneratorsForCurrentTest() {
+            IGeneratorsForTest* generators = findGeneratorsForCurrentTest();
+            if( !generators ) {
+                std::string testName = getResultCapture()->getCurrentTestName();
+                generators = createGeneratorsForTest();
+                m_generatorsByTestName.insert( std::make_pair( testName, generators ) );
+            }
+            return *generators;
+        }
+
+    private:
+        Ptr<IConfig const> m_config;
+        IRunner* m_runner;
+        IResultCapture* m_resultCapture;
+        std::map<std::string, IGeneratorsForTest*> m_generatorsByTestName;
+    };
+
+    namespace {
+        Context* currentContext = NULL;
+    }
+    IMutableContext& getCurrentMutableContext() {
+        if( !currentContext )
+            currentContext = new Context();
+        return *currentContext;
+    }
+    IContext& getCurrentContext() {
+        return getCurrentMutableContext();
+    }
+
+    Stream createStream( std::string const& streamName ) {
+        if( streamName == "stdout" ) return Stream( std::cout.rdbuf(), false );
+        if( streamName == "stderr" ) return Stream( std::cerr.rdbuf(), false );
+        if( streamName == "debug" ) return Stream( new StreamBufImpl<OutputDebugWriter>, true );
+
+        throw std::domain_error( "Unknown stream: " + streamName );
+    }
+
+    void cleanUpContext() {
+        delete currentContext;
+        currentContext = NULL;
+    }
+}
+
+// #included from: catch_console_colour_impl.hpp
+#define TWOBLUECUBES_CATCH_CONSOLE_COLOUR_IMPL_HPP_INCLUDED
+
+namespace Catch { namespace Detail {
+    struct IColourImpl {
+        virtual ~IColourImpl() {}
+        virtual void use( Colour::Code _colourCode ) = 0;
+    };
+}}
+
+#if defined ( CATCH_PLATFORM_WINDOWS ) /////////////////////////////////////////
+
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+
+#ifdef __AFXDLL
+#include <AfxWin.h>
+#else
+#include <windows.h>
+#endif
+
+namespace Catch {
+namespace {
+
+    class Win32ColourImpl : public Detail::IColourImpl {
+    public:
+        Win32ColourImpl() : stdoutHandle( GetStdHandle(STD_OUTPUT_HANDLE) )
+        {
+            CONSOLE_SCREEN_BUFFER_INFO csbiInfo;
+            GetConsoleScreenBufferInfo( stdoutHandle, &csbiInfo );
+            originalAttributes = csbiInfo.wAttributes;
+        }
+
+        virtual void use( Colour::Code _colourCode ) {
+            switch( _colourCode ) {
+                case Colour::None:      return setTextAttribute( originalAttributes );
+                case Colour::White:     return setTextAttribute( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
+                case Colour::Red:       return setTextAttribute( FOREGROUND_RED );
+                case Colour::Green:     return setTextAttribute( FOREGROUND_GREEN );
+                case Colour::Blue:      return setTextAttribute( FOREGROUND_BLUE );
+                case Colour::Cyan:      return setTextAttribute( FOREGROUND_BLUE | FOREGROUND_GREEN );
+                case Colour::Yellow:    return setTextAttribute( FOREGROUND_RED | FOREGROUND_GREEN );
+                case Colour::Grey:      return setTextAttribute( 0 );
+
+                case Colour::LightGrey:     return setTextAttribute( FOREGROUND_INTENSITY );
+                case Colour::BrightRed:     return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED );
+                case Colour::BrightGreen:   return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN );
+                case Colour::BrightWhite:   return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
+
+                case Colour::Bright: throw std::logic_error( "not a colour" );
+            }
+        }
+
+    private:
+        void setTextAttribute( WORD _textAttribute ) {
+            SetConsoleTextAttribute( stdoutHandle, _textAttribute );
+        }
+        HANDLE stdoutHandle;
+        WORD originalAttributes;
+    };
+
+    inline bool shouldUseColourForPlatform() {
+        return true;
+    }
+
+    static Detail::IColourImpl* platformColourInstance() {
+        static Win32ColourImpl s_instance;
+        return &s_instance;
+    }
+
+} // end anon namespace
+} // end namespace Catch
+
+#else // Not Windows - assumed to be POSIX compatible //////////////////////////
+
+#include <unistd.h>
+
+namespace Catch {
+namespace {
+
+    // use POSIX/ ANSI console terminal codes
+    // Thanks to Adam Strzelecki for original contribution
+    // (http://github.com/nanoant)
+    // https://github.com/philsquared/Catch/pull/131
+    class PosixColourImpl : public Detail::IColourImpl {
+    public:
+        virtual void use( Colour::Code _colourCode ) {
+            switch( _colourCode ) {
+                case Colour::None:
+                case Colour::White:     return setColour( "[0m" );
+                case Colour::Red:       return setColour( "[0;31m" );
+                case Colour::Green:     return setColour( "[0;32m" );
+                case Colour::Blue:      return setColour( "[0:34m" );
+                case Colour::Cyan:      return setColour( "[0;36m" );
+                case Colour::Yellow:    return setColour( "[0;33m" );
+                case Colour::Grey:      return setColour( "[1;30m" );
+
+                case Colour::LightGrey:     return setColour( "[0;37m" );
+                case Colour::BrightRed:     return setColour( "[1;31m" );
+                case Colour::BrightGreen:   return setColour( "[1;32m" );
+                case Colour::BrightWhite:   return setColour( "[1;37m" );
+
+                case Colour::Bright: throw std::logic_error( "not a colour" );
+            }
+        }
+    private:
+        void setColour( const char* _escapeCode ) {
+            std::cout << '\033' << _escapeCode;
+        }
+    };
+
+    inline bool shouldUseColourForPlatform() {
+        return isatty(STDOUT_FILENO);
+    }
+
+    static Detail::IColourImpl* platformColourInstance() {
+        static PosixColourImpl s_instance;
+        return &s_instance;
+    }
+
+} // end anon namespace
+} // end namespace Catch
+
+#endif // not Windows
+
+namespace Catch {
+
+    namespace {
+        struct NoColourImpl : Detail::IColourImpl {
+            void use( Colour::Code ) {}
+
+            static IColourImpl* instance() {
+                static NoColourImpl s_instance;
+                return &s_instance;
+            }
+        };
+        static bool shouldUseColour() {
+            return shouldUseColourForPlatform() && !isDebuggerActive();
+        }
+    }
+
+    Colour::Colour( Code _colourCode ) : m_moved( false ) { use( _colourCode ); }
+    Colour::Colour( Colour const& _other ) : m_moved( false ) { const_cast<Colour&>( _other ).m_moved = true; }
+    Colour::~Colour(){ if( !m_moved ) use( None ); }
+    void Colour::use( Code _colourCode ) {
+        impl()->use( _colourCode );
+    }
+
+    Detail::IColourImpl* Colour::impl() {
+        return shouldUseColour()
+            ? platformColourInstance()
+            : NoColourImpl::instance();
+    }
+
+} // end namespace Catch
+
+// #included from: catch_generators_impl.hpp
+#define TWOBLUECUBES_CATCH_GENERATORS_IMPL_HPP_INCLUDED
+
+#include <vector>
+#include <string>
+#include <map>
+
+namespace Catch {
+
+    struct GeneratorInfo : IGeneratorInfo {
+
+        GeneratorInfo( std::size_t size )
+        :   m_size( size ),
+            m_currentIndex( 0 )
+        {}
+
+        bool moveNext() {
+            if( ++m_currentIndex == m_size ) {
+                m_currentIndex = 0;
+                return false;
+            }
+            return true;
+        }
+
+        std::size_t getCurrentIndex() const {
+            return m_currentIndex;
+        }
+
+        std::size_t m_size;
+        std::size_t m_currentIndex;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    class GeneratorsForTest : public IGeneratorsForTest {
+
+    public:
+        ~GeneratorsForTest() {
+            deleteAll( m_generatorsInOrder );
+        }
+
+        IGeneratorInfo& getGeneratorInfo( std::string const& fileInfo, std::size_t size ) {
+            std::map<std::string, IGeneratorInfo*>::const_iterator it = m_generatorsByName.find( fileInfo );
+            if( it == m_generatorsByName.end() ) {
+                IGeneratorInfo* info = new GeneratorInfo( size );
+                m_generatorsByName.insert( std::make_pair( fileInfo, info ) );
+                m_generatorsInOrder.push_back( info );
+                return *info;
+            }
+            return *it->second;
+        }
+
+        bool moveNext() {
+            std::vector<IGeneratorInfo*>::const_iterator it = m_generatorsInOrder.begin();
+            std::vector<IGeneratorInfo*>::const_iterator itEnd = m_generatorsInOrder.end();
+            for(; it != itEnd; ++it ) {
+                if( (*it)->moveNext() )
+                    return true;
+            }
+            return false;
+        }
+
+    private:
+        std::map<std::string, IGeneratorInfo*> m_generatorsByName;
+        std::vector<IGeneratorInfo*> m_generatorsInOrder;
+    };
+
+    IGeneratorsForTest* createGeneratorsForTest()
+    {
+        return new GeneratorsForTest();
+    }
+
+} // end namespace Catch
+
+// #included from: catch_assertionresult.hpp
+#define TWOBLUECUBES_CATCH_ASSERTIONRESULT_HPP_INCLUDED
+
+namespace Catch {
+
+    AssertionInfo::AssertionInfo(   std::string const& _macroName,
+                                    SourceLineInfo const& _lineInfo,
+                                    std::string const& _capturedExpression,
+                                    ResultDisposition::Flags _resultDisposition )
+    :   macroName( _macroName ),
+        lineInfo( _lineInfo ),
+        capturedExpression( _capturedExpression ),
+        resultDisposition( _resultDisposition )
+    {}
+
+    AssertionResult::AssertionResult() {}
+
+    AssertionResult::AssertionResult( AssertionInfo const& info, AssertionResultData const& data )
+    :   m_info( info ),
+        m_resultData( data )
+    {}
+
+    AssertionResult::~AssertionResult() {}
+
+    // Result was a success
+    bool AssertionResult::succeeded() const {
+        return Catch::isOk( m_resultData.resultType );
+    }
+
+    // Result was a success, or failure is suppressed
+    bool AssertionResult::isOk() const {
+        return Catch::isOk( m_resultData.resultType ) || shouldSuppressFailure( m_info.resultDisposition );
+    }
+
+    ResultWas::OfType AssertionResult::getResultType() const {
+        return m_resultData.resultType;
+    }
+
+    bool AssertionResult::hasExpression() const {
+        return !m_info.capturedExpression.empty();
+    }
+
+    bool AssertionResult::hasMessage() const {
+        return !m_resultData.message.empty();
+    }
+
+    std::string AssertionResult::getExpression() const {
+        if( isFalseTest( m_info.resultDisposition ) )
+            return "!" + m_info.capturedExpression;
+        else
+            return m_info.capturedExpression;
+    }
+    std::string AssertionResult::getExpressionInMacro() const {
+        if( m_info.macroName.empty() )
+            return m_info.capturedExpression;
+        else
+            return m_info.macroName + "( " + m_info.capturedExpression + " )";
+    }
+
+    bool AssertionResult::hasExpandedExpression() const {
+        return hasExpression() && getExpandedExpression() != getExpression();
+    }
+
+    std::string AssertionResult::getExpandedExpression() const {
+        return m_resultData.reconstructedExpression;
+    }
+
+    std::string AssertionResult::getMessage() const {
+        return m_resultData.message;
+    }
+    SourceLineInfo AssertionResult::getSourceInfo() const {
+        return m_info.lineInfo;
+    }
+
+    std::string AssertionResult::getTestMacroName() const {
+        return m_info.macroName;
+    }
+
+} // end namespace Catch
+
+// #included from: catch_test_case_info.hpp
+#define TWOBLUECUBES_CATCH_TEST_CASE_INFO_HPP_INCLUDED
+
+namespace Catch {
+
+    inline TestCaseInfo::SpecialProperties parseSpecialTag( std::string const& tag ) {
+        if( tag == "." ||
+            tag == "hide" ||
+            tag == "!hide" )
+            return TestCaseInfo::IsHidden;
+        else if( tag == "!throws" )
+            return TestCaseInfo::Throws;
+        else if( tag == "!shouldfail" )
+            return TestCaseInfo::ShouldFail;
+        else if( tag == "!mayfail" )
+            return TestCaseInfo::MayFail;
+        else
+            return TestCaseInfo::None;
+    }
+    inline bool isReservedTag( std::string const& tag ) {
+        return parseSpecialTag( tag ) == TestCaseInfo::None && tag.size() > 0 && !isalnum( tag[0] );
+    }
+    inline void enforceNotReservedTag( std::string const& tag, SourceLineInfo const& _lineInfo ) {
+        if( isReservedTag( tag ) ) {
+            {
+                Colour colourGuard( Colour::Red );
+                std::cerr
+                    << "Tag name [" << tag << "] not allowed.\n"
+                    << "Tag names starting with non alpha-numeric characters are reserved\n";
+            }
+            {
+                Colour colourGuard( Colour::FileName );
+                std::cerr << _lineInfo << std::endl;
+            }
+            exit(1);
+        }
+    }
+
+    TestCase makeTestCase(  ITestCase* _testCase,
+                            std::string const& _className,
+                            std::string const& _name,
+                            std::string const& _descOrTags,
+                            SourceLineInfo const& _lineInfo )
+    {
+        bool isHidden( startsWith( _name, "./" ) ); // Legacy support
+
+        // Parse out tags
+        std::set<std::string> tags;
+        std::string desc, tag;
+        bool inTag = false;
+        for( std::size_t i = 0; i < _descOrTags.size(); ++i ) {
+            char c = _descOrTags[i];
+            if( !inTag ) {
+                if( c == '[' )
+                    inTag = true;
+                else
+                    desc += c;
+            }
+            else {
+                if( c == ']' ) {
+                    enforceNotReservedTag( tag, _lineInfo );
+
+                    inTag = false;
+                    if( tag == "hide" || tag == "." )
+                        isHidden = true;
+                    else
+                        tags.insert( tag );
+                    tag.clear();
+                }
+                else
+                    tag += c;
+            }
+        }
+        if( isHidden ) {
+            tags.insert( "hide" );
+            tags.insert( "." );
+        }
+
+        TestCaseInfo info( _name, _className, desc, tags, _lineInfo );
+        return TestCase( _testCase, info );
+    }
+
+    TestCaseInfo::TestCaseInfo( std::string const& _name,
+                                std::string const& _className,
+                                std::string const& _description,
+                                std::set<std::string> const& _tags,
+                                SourceLineInfo const& _lineInfo )
+    :   name( _name ),
+        className( _className ),
+        description( _description ),
+        tags( _tags ),
+        lineInfo( _lineInfo ),
+        properties( None )
+    {
+        std::ostringstream oss;
+        for( std::set<std::string>::const_iterator it = _tags.begin(), itEnd = _tags.end(); it != itEnd; ++it ) {
+            oss << "[" << *it << "]";
+            std::string lcaseTag = toLower( *it );
+            properties = static_cast<SpecialProperties>( properties | parseSpecialTag( lcaseTag ) );
+            lcaseTags.insert( lcaseTag );
+        }
+        tagsAsString = oss.str();
+    }
+
+    TestCaseInfo::TestCaseInfo( TestCaseInfo const& other )
+    :   name( other.name ),
+        className( other.className ),
+        description( other.description ),
+        tags( other.tags ),
+        lcaseTags( other.lcaseTags ),
+        tagsAsString( other.tagsAsString ),
+        lineInfo( other.lineInfo ),
+        properties( other.properties )
+    {}
+
+    bool TestCaseInfo::isHidden() const {
+        return ( properties & IsHidden ) != 0;
+    }
+    bool TestCaseInfo::throws() const {
+        return ( properties & Throws ) != 0;
+    }
+    bool TestCaseInfo::okToFail() const {
+        return ( properties & (ShouldFail | MayFail ) ) != 0;
+    }
+    bool TestCaseInfo::expectedToFail() const {
+        return ( properties & (ShouldFail ) ) != 0;
+    }
+
+    TestCase::TestCase( ITestCase* testCase, TestCaseInfo const& info ) : TestCaseInfo( info ), test( testCase ) {}
+
+    TestCase::TestCase( TestCase const& other )
+    :   TestCaseInfo( other ),
+        test( other.test )
+    {}
+
+    TestCase TestCase::withName( std::string const& _newName ) const {
+        TestCase other( *this );
+        other.name = _newName;
+        return other;
+    }
+
+    void TestCase::swap( TestCase& other ) {
+        test.swap( other.test );
+        name.swap( other.name );
+        className.swap( other.className );
+        description.swap( other.description );
+        tags.swap( other.tags );
+        lcaseTags.swap( other.lcaseTags );
+        tagsAsString.swap( other.tagsAsString );
+        std::swap( TestCaseInfo::properties, static_cast<TestCaseInfo&>( other ).properties );
+        std::swap( lineInfo, other.lineInfo );
+    }
+
+    void TestCase::invoke() const {
+        test->invoke();
+    }
+
+    bool TestCase::operator == ( TestCase const& other ) const {
+        return  test.get() == other.test.get() &&
+                name == other.name &&
+                className == other.className;
+    }
+
+    bool TestCase::operator < ( TestCase const& other ) const {
+        return name < other.name;
+    }
+    TestCase& TestCase::operator = ( TestCase const& other ) {
+        TestCase temp( other );
+        swap( temp );
+        return *this;
+    }
+
+    TestCaseInfo const& TestCase::getTestCaseInfo() const
+    {
+        return *this;
+    }
+
+} // end namespace Catch
+
+// #included from: catch_version.hpp
+#define TWOBLUECUBES_CATCH_VERSION_HPP_INCLUDED
+
+namespace Catch {
+
+    // These numbers are maintained by a script
+    Version libraryVersion( 1, 0, 53, "master" );
+}
+
+// #included from: catch_message.hpp
+#define TWOBLUECUBES_CATCH_MESSAGE_HPP_INCLUDED
+
+namespace Catch {
+
+    MessageInfo::MessageInfo(   std::string const& _macroName,
+                                SourceLineInfo const& _lineInfo,
+                                ResultWas::OfType _type )
+    :   macroName( _macroName ),
+        lineInfo( _lineInfo ),
+        type( _type ),
+        sequence( ++globalCount )
+    {}
+
+    // This may need protecting if threading support is added
+    unsigned int MessageInfo::globalCount = 0;
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    ScopedMessage::ScopedMessage( MessageBuilder const& builder )
+    : m_info( builder.m_info )
+    {
+        m_info.message = builder.m_stream.str();
+        getResultCapture().pushScopedMessage( m_info );
+    }
+    ScopedMessage::ScopedMessage( ScopedMessage const& other )
+    : m_info( other.m_info )
+    {}
+
+    ScopedMessage::~ScopedMessage() {
+        getResultCapture().popScopedMessage( m_info );
+    }
+
+} // end namespace Catch
+
+// #included from: catch_legacy_reporter_adapter.hpp
+#define TWOBLUECUBES_CATCH_LEGACY_REPORTER_ADAPTER_HPP_INCLUDED
+
+// #included from: catch_legacy_reporter_adapter.h
+#define TWOBLUECUBES_CATCH_LEGACY_REPORTER_ADAPTER_H_INCLUDED
+
+namespace Catch
+{
+    // Deprecated
+    struct IReporter : IShared {
+        virtual ~IReporter();
+
+        virtual bool shouldRedirectStdout() const = 0;
+
+        virtual void StartTesting() = 0;
+        virtual void EndTesting( Totals const& totals ) = 0;
+        virtual void StartGroup( std::string const& groupName ) = 0;
+        virtual void EndGroup( std::string const& groupName, Totals const& totals ) = 0;
+        virtual void StartTestCase( TestCaseInfo const& testInfo ) = 0;
+        virtual void EndTestCase( TestCaseInfo const& testInfo, Totals const& totals, std::string const& stdOut, std::string const& stdErr ) = 0;
+        virtual void StartSection( std::string const& sectionName, std::string const& description ) = 0;
+        virtual void EndSection( std::string const& sectionName, Counts const& assertions ) = 0;
+        virtual void NoAssertionsInSection( std::string const& sectionName ) = 0;
+        virtual void NoAssertionsInTestCase( std::string const& testName ) = 0;
+        virtual void Aborted() = 0;
+        virtual void Result( AssertionResult const& result ) = 0;
+    };
+
+    class LegacyReporterAdapter : public SharedImpl<IStreamingReporter>
+    {
+    public:
+        LegacyReporterAdapter( Ptr<IReporter> const& legacyReporter );
+        virtual ~LegacyReporterAdapter();
+
+        virtual ReporterPreferences getPreferences() const;
+        virtual void noMatchingTestCases( std::string const& );
+        virtual void testRunStarting( TestRunInfo const& );
+        virtual void testGroupStarting( GroupInfo const& groupInfo );
+        virtual void testCaseStarting( TestCaseInfo const& testInfo );
+        virtual void sectionStarting( SectionInfo const& sectionInfo );
+        virtual void assertionStarting( AssertionInfo const& );
+        virtual bool assertionEnded( AssertionStats const& assertionStats );
+        virtual void sectionEnded( SectionStats const& sectionStats );
+        virtual void testCaseEnded( TestCaseStats const& testCaseStats );
+        virtual void testGroupEnded( TestGroupStats const& testGroupStats );
+        virtual void testRunEnded( TestRunStats const& testRunStats );
+
+    private:
+        Ptr<IReporter> m_legacyReporter;
+    };
+}
+
+namespace Catch
+{
+    LegacyReporterAdapter::LegacyReporterAdapter( Ptr<IReporter> const& legacyReporter )
+    :   m_legacyReporter( legacyReporter )
+    {}
+    LegacyReporterAdapter::~LegacyReporterAdapter() {}
+
+    ReporterPreferences LegacyReporterAdapter::getPreferences() const {
+        ReporterPreferences prefs;
+        prefs.shouldRedirectStdOut = m_legacyReporter->shouldRedirectStdout();
+        return prefs;
+    }
+
+    void LegacyReporterAdapter::noMatchingTestCases( std::string const& ) {}
+    void LegacyReporterAdapter::testRunStarting( TestRunInfo const& ) {
+        m_legacyReporter->StartTesting();
+    }
+    void LegacyReporterAdapter::testGroupStarting( GroupInfo const& groupInfo ) {
+        m_legacyReporter->StartGroup( groupInfo.name );
+    }
+    void LegacyReporterAdapter::testCaseStarting( TestCaseInfo const& testInfo ) {
+        m_legacyReporter->StartTestCase( testInfo );
+    }
+    void LegacyReporterAdapter::sectionStarting( SectionInfo const& sectionInfo ) {
+        m_legacyReporter->StartSection( sectionInfo.name, sectionInfo.description );
+    }
+    void LegacyReporterAdapter::assertionStarting( AssertionInfo const& ) {
+        // Not on legacy interface
+    }
+
+    bool LegacyReporterAdapter::assertionEnded( AssertionStats const& assertionStats ) {
+        if( assertionStats.assertionResult.getResultType() != ResultWas::Ok ) {
+            for( std::vector<MessageInfo>::const_iterator it = assertionStats.infoMessages.begin(), itEnd = assertionStats.infoMessages.end();
+                    it != itEnd;
+                    ++it ) {
+                if( it->type == ResultWas::Info ) {
+                    ResultBuilder rb( it->macroName.c_str(), it->lineInfo, "", ResultDisposition::Normal );
+                    rb << it->message;
+                    rb.setResultType( ResultWas::Info );
+                    AssertionResult result = rb.build();
+                    m_legacyReporter->Result( result );
+                }
+            }
+        }
+        m_legacyReporter->Result( assertionStats.assertionResult );
+        return true;
+    }
+    void LegacyReporterAdapter::sectionEnded( SectionStats const& sectionStats ) {
+        if( sectionStats.missingAssertions )
+            m_legacyReporter->NoAssertionsInSection( sectionStats.sectionInfo.name );
+        m_legacyReporter->EndSection( sectionStats.sectionInfo.name, sectionStats.assertions );
+    }
+    void LegacyReporterAdapter::testCaseEnded( TestCaseStats const& testCaseStats ) {
+        m_legacyReporter->EndTestCase
+            (   testCaseStats.testInfo,
+                testCaseStats.totals,
+                testCaseStats.stdOut,
+                testCaseStats.stdErr );
+    }
+    void LegacyReporterAdapter::testGroupEnded( TestGroupStats const& testGroupStats ) {
+        if( testGroupStats.aborting )
+            m_legacyReporter->Aborted();
+        m_legacyReporter->EndGroup( testGroupStats.groupInfo.name, testGroupStats.totals );
+    }
+    void LegacyReporterAdapter::testRunEnded( TestRunStats const& testRunStats ) {
+        m_legacyReporter->EndTesting( testRunStats.totals );
+    }
+}
+
+// #included from: catch_timer.hpp
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wc++11-long-long"
+#endif
+
+#ifdef CATCH_PLATFORM_WINDOWS
+#include <windows.h>
+#else
+#include <sys/time.h>
+#endif
+
+namespace Catch {
+
+    namespace {
+#ifdef CATCH_PLATFORM_WINDOWS
+        uint64_t getCurrentTicks() {
+            static uint64_t hz=0, hzo=0;
+            if (!hz) {
+                QueryPerformanceFrequency((LARGE_INTEGER*)&hz);
+                QueryPerformanceCounter((LARGE_INTEGER*)&hzo);
+            }
+            uint64_t t;
+            QueryPerformanceCounter((LARGE_INTEGER*)&t);
+            return ((t-hzo)*1000000)/hz;
+        }
+#else
+        uint64_t getCurrentTicks() {
+            timeval t;
+            gettimeofday(&t,NULL);
+            return static_cast<uint64_t>( t.tv_sec ) * 1000000ull + static_cast<uint64_t>( t.tv_usec );
+        }
+#endif
+    }
+
+    void Timer::start() {
+        m_ticks = getCurrentTicks();
+    }
+    unsigned int Timer::getElapsedNanoseconds() const {
+        return static_cast<unsigned int>(getCurrentTicks() - m_ticks);
+    }
+    unsigned int Timer::getElapsedMilliseconds() const {
+        return static_cast<unsigned int>((getCurrentTicks() - m_ticks)/1000);
+    }
+    double Timer::getElapsedSeconds() const {
+        return (getCurrentTicks() - m_ticks)/1000000.0;
+    }
+
+} // namespace Catch
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+// #included from: catch_common.hpp
+#define TWOBLUECUBES_CATCH_COMMON_HPP_INCLUDED
+
+namespace Catch {
+
+    bool startsWith( std::string const& s, std::string const& prefix ) {
+        return s.size() >= prefix.size() && s.substr( 0, prefix.size() ) == prefix;
+    }
+    bool endsWith( std::string const& s, std::string const& suffix ) {
+        return s.size() >= suffix.size() && s.substr( s.size()-suffix.size(), suffix.size() ) == suffix;
+    }
+    bool contains( std::string const& s, std::string const& infix ) {
+        return s.find( infix ) != std::string::npos;
+    }
+    void toLowerInPlace( std::string& s ) {
+        std::transform( s.begin(), s.end(), s.begin(), ::tolower );
+    }
+    std::string toLower( std::string const& s ) {
+        std::string lc = s;
+        toLowerInPlace( lc );
+        return lc;
+    }
+    std::string trim( std::string const& str ) {
+        static char const* whitespaceChars = "\n\r\t ";
+        std::string::size_type start = str.find_first_not_of( whitespaceChars );
+        std::string::size_type end = str.find_last_not_of( whitespaceChars );
+
+        return start != std::string::npos ? str.substr( start, 1+end-start ) : "";
+    }
+
+    pluralise::pluralise( std::size_t count, std::string const& label )
+    :   m_count( count ),
+        m_label( label )
+    {}
+
+    std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser ) {
+        os << pluraliser.m_count << " " << pluraliser.m_label;
+        if( pluraliser.m_count != 1 )
+            os << "s";
+        return os;
+    }
+
+    SourceLineInfo::SourceLineInfo() : line( 0 ){}
+    SourceLineInfo::SourceLineInfo( char const* _file, std::size_t _line )
+    :   file( _file ),
+        line( _line )
+    {}
+    SourceLineInfo::SourceLineInfo( SourceLineInfo const& other )
+    :   file( other.file ),
+        line( other.line )
+    {}
+    bool SourceLineInfo::empty() const {
+        return file.empty();
+    }
+    bool SourceLineInfo::operator == ( SourceLineInfo const& other ) const {
+        return line == other.line && file == other.file;
+    }
+
+    std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ) {
+#ifndef __GNUG__
+        os << info.file << "(" << info.line << ")";
+#else
+        os << info.file << ":" << info.line;
+#endif
+        return os;
+    }
+
+    void throwLogicError( std::string const& message, SourceLineInfo const& locationInfo ) {
+        std::ostringstream oss;
+        oss << locationInfo << ": Internal Catch error: '" << message << "'";
+        if( alwaysTrue() )
+            throw std::logic_error( oss.str() );
+    }
+}
+
+// #included from: catch_section.hpp
+#define TWOBLUECUBES_CATCH_SECTION_HPP_INCLUDED
+
+namespace Catch {
+
+    SectionInfo::SectionInfo
+        (   SourceLineInfo const& _lineInfo,
+            std::string const& _name,
+            std::string const& _description )
+    :   name( _name ),
+        description( _description ),
+        lineInfo( _lineInfo )
+    {}
+
+    Section::Section( SectionInfo const& info )
+    :   m_info( info ),
+        m_sectionIncluded( getResultCapture().sectionStarted( m_info, m_assertions ) )
+    {
+        m_timer.start();
+    }
+
+    Section::~Section() {
+        if( m_sectionIncluded )
+            getResultCapture().sectionEnded( m_info, m_assertions, m_timer.getElapsedSeconds() );
+    }
+
+    // This indicates whether the section should be executed or not
+    Section::operator bool() const {
+        return m_sectionIncluded;
+    }
+
+} // end namespace Catch
+
+// #included from: catch_debugger.hpp
+#define TWOBLUECUBES_CATCH_DEBUGGER_HPP_INCLUDED
+
+#include <iostream>
+
+#ifdef CATCH_PLATFORM_MAC
+
+    #include <assert.h>
+    #include <stdbool.h>
+    #include <sys/types.h>
+    #include <unistd.h>
+    #include <sys/sysctl.h>
+
+    namespace Catch{
+
+        // The following function is taken directly from the following technical note:
+        // http://developer.apple.com/library/mac/#qa/qa2004/qa1361.html
+
+        // Returns true if the current process is being debugged (either
+        // running under the debugger or has a debugger attached post facto).
+        bool isDebuggerActive(){
+
+            int                 mib[4];
+            struct kinfo_proc   info;
+            size_t              size;
+
+            // Initialize the flags so that, if sysctl fails for some bizarre
+            // reason, we get a predictable result.
+
+            info.kp_proc.p_flag = 0;
+
+            // Initialize mib, which tells sysctl the info we want, in this case
+            // we're looking for information about a specific process ID.
+
+            mib[0] = CTL_KERN;
+            mib[1] = KERN_PROC;
+            mib[2] = KERN_PROC_PID;
+            mib[3] = getpid();
+
+            // Call sysctl.
+
+            size = sizeof(info);
+            if( sysctl(mib, sizeof(mib) / sizeof(*mib), &info, &size, NULL, 0) != 0 ) {
+                std::cerr << "\n** Call to sysctl failed - unable to determine if debugger is active **\n" << std::endl;
+                return false;
+            }
+
+            // We're being debugged if the P_TRACED flag is set.
+
+            return ( (info.kp_proc.p_flag & P_TRACED) != 0 );
+        }
+    } // namespace Catch
+
+#elif defined(_MSC_VER)
+    extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
+    namespace Catch {
+        bool isDebuggerActive() {
+            return IsDebuggerPresent() != 0;
+        }
+    }
+#elif defined(__MINGW32__)
+    extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
+    namespace Catch {
+        bool isDebuggerActive() {
+            return IsDebuggerPresent() != 0;
+        }
+    }
+#else
+    namespace Catch {
+       inline bool isDebuggerActive() { return false; }
+    }
+#endif // Platform
+
+#ifdef CATCH_PLATFORM_WINDOWS
+    extern "C" __declspec(dllimport) void __stdcall OutputDebugStringA( const char* );
+    namespace Catch {
+        void writeToDebugConsole( std::string const& text ) {
+            ::OutputDebugStringA( text.c_str() );
+        }
+    }
+#else
+    namespace Catch {
+        void writeToDebugConsole( std::string const& text ) {
+            // !TBD: Need a version for Mac/ XCode and other IDEs
+            std::cout << text;
+        }
+    }
+#endif // Platform
+
+// #included from: catch_tostring.hpp
+#define TWOBLUECUBES_CATCH_TOSTRING_HPP_INCLUDED
+
+namespace Catch {
+
+namespace Detail {
+
+    namespace {
+        struct Endianness {
+            enum Arch { Big, Little };
+
+            static Arch which() {
+                union _{
+                    int asInt;
+                    char asChar[sizeof (int)];
+                } u;
+
+                u.asInt = 1;
+                return ( u.asChar[sizeof(int)-1] == 1 ) ? Big : Little;
+            }
+        };
+    }
+
+    std::string rawMemoryToString( const void *object, std::size_t size )
+    {
+        // Reverse order for little endian architectures
+        int i = 0, end = static_cast<int>( size ), inc = 1;
+        if( Endianness::which() == Endianness::Little ) {
+            i = end-1;
+            end = inc = -1;
+        }
+
+        unsigned char const *bytes = static_cast<unsigned char const *>(object);
+        std::ostringstream os;
+        os << "0x" << std::setfill('0') << std::hex;
+        for( ; i != end; i += inc )
+             os << std::setw(2) << static_cast<unsigned>(bytes[i]);
+       return os.str();
+    }
+}
+
+std::string toString( std::string const& value ) {
+    std::string s = value;
+    if( getCurrentContext().getConfig()->showInvisibles() ) {
+        for(size_t i = 0; i < s.size(); ++i ) {
+            std::string subs;
+            switch( s[i] ) {
+            case '\n': subs = "\\n"; break;
+            case '\t': subs = "\\t"; break;
+            default: break;
+            }
+            if( !subs.empty() ) {
+                s = s.substr( 0, i ) + subs + s.substr( i+1 );
+                ++i;
+            }
+        }
+    }
+    return "\"" + s + "\"";
+}
+std::string toString( std::wstring const& value ) {
+
+    std::string s;
+    s.reserve( value.size() );
+    for(size_t i = 0; i < value.size(); ++i )
+        s += value[i] <= 0xff ? static_cast<char>( value[i] ) : '?';
+    return toString( s );
+}
+
+std::string toString( const char* const value ) {
+    return value ? Catch::toString( std::string( value ) ) : std::string( "{null string}" );
+}
+
+std::string toString( char* const value ) {
+    return Catch::toString( static_cast<const char*>( value ) );
+}
+
+std::string toString( const wchar_t* const value )
+{
+	return value ? Catch::toString( std::wstring(value) ) : std::string( "{null string}" );
+}
+
+std::string toString( wchar_t* const value )
+{
+	return Catch::toString( static_cast<const wchar_t*>( value ) );
+}
+
+std::string toString( int value ) {
+    std::ostringstream oss;
+    oss << value;
+    return oss.str();
+}
+
+std::string toString( unsigned long value ) {
+    std::ostringstream oss;
+    if( value > 8192 )
+        oss << "0x" << std::hex << value;
+    else
+        oss << value;
+    return oss.str();
+}
+
+std::string toString( unsigned int value ) {
+    return toString( static_cast<unsigned long>( value ) );
+}
+
+template<typename T>
+std::string fpToString( T value, int precision ) {
+    std::ostringstream oss;
+    oss << std::setprecision( precision )
+        << std::fixed
+        << value;
+    std::string d = oss.str();
+    std::size_t i = d.find_last_not_of( '0' );
+    if( i != std::string::npos && i != d.size()-1 ) {
+        if( d[i] == '.' )
+            i++;
+        d = d.substr( 0, i+1 );
+    }
+    return d;
+}
+
+std::string toString( const double value ) {
+    return fpToString( value, 10 );
+}
+std::string toString( const float value ) {
+    return fpToString( value, 5 ) + "f";
+}
+
+std::string toString( bool value ) {
+    return value ? "true" : "false";
+}
+
+std::string toString( char value ) {
+    return value < ' '
+        ? toString( static_cast<unsigned int>( value ) )
+        : Detail::makeString( value );
+}
+
+std::string toString( signed char value ) {
+    return toString( static_cast<char>( value ) );
+}
+
+std::string toString( unsigned char value ) {
+    return toString( static_cast<char>( value ) );
+}
+
+#ifdef CATCH_CONFIG_CPP11_NULLPTR
+std::string toString( std::nullptr_t ) {
+    return "nullptr";
+}
+#endif
+
+#ifdef __OBJC__
+    std::string toString( NSString const * const& nsstring ) {
+        if( !nsstring )
+            return "nil";
+        return "@" + toString([nsstring UTF8String]);
+    }
+    std::string toString( NSString * CATCH_ARC_STRONG const& nsstring ) {
+        if( !nsstring )
+            return "nil";
+        return "@" + toString([nsstring UTF8String]);
+    }
+    std::string toString( NSObject* const& nsObject ) {
+        return toString( [nsObject description] );
+    }
+#endif
+
+} // end namespace Catch
+
+// #included from: catch_result_builder.hpp
+#define TWOBLUECUBES_CATCH_RESULT_BUILDER_HPP_INCLUDED
+
+namespace Catch {
+
+    ResultBuilder::ResultBuilder(   char const* macroName,
+                                    SourceLineInfo const& lineInfo,
+                                    char const* capturedExpression,
+                                    ResultDisposition::Flags resultDisposition )
+    :   m_assertionInfo( macroName, lineInfo, capturedExpression, resultDisposition ),
+        m_shouldDebugBreak( false ),
+        m_shouldThrow( false )
+    {}
+
+    ResultBuilder& ResultBuilder::setResultType( ResultWas::OfType result ) {
+        m_data.resultType = result;
+        return *this;
+    }
+    ResultBuilder& ResultBuilder::setResultType( bool result ) {
+        m_data.resultType = result ? ResultWas::Ok : ResultWas::ExpressionFailed;
+        return *this;
+    }
+    ResultBuilder& ResultBuilder::setLhs( std::string const& lhs ) {
+        m_exprComponents.lhs = lhs;
+        return *this;
+    }
+    ResultBuilder& ResultBuilder::setRhs( std::string const& rhs ) {
+        m_exprComponents.rhs = rhs;
+        return *this;
+    }
+    ResultBuilder& ResultBuilder::setOp( std::string const& op ) {
+        m_exprComponents.op = op;
+        return *this;
+    }
+
+    void ResultBuilder::endExpression() {
+        m_exprComponents.testFalse = isFalseTest( m_assertionInfo.resultDisposition );
+        captureExpression();
+    }
+
+    void ResultBuilder::useActiveException( ResultDisposition::Flags resultDisposition ) {
+        m_assertionInfo.resultDisposition = resultDisposition;
+        m_stream.oss << Catch::translateActiveException();
+        captureResult( ResultWas::ThrewException );
+    }
+
+    void ResultBuilder::captureResult( ResultWas::OfType resultType ) {
+        setResultType( resultType );
+        captureExpression();
+    }
+
+    void ResultBuilder::captureExpression() {
+        AssertionResult result = build();
+        getResultCapture().assertionEnded( result );
+
+        if( !result.isOk() ) {
+            if( getCurrentContext().getConfig()->shouldDebugBreak() )
+                m_shouldDebugBreak = true;
+            if( getCurrentContext().getRunner()->aborting() || m_assertionInfo.resultDisposition == ResultDisposition::Normal )
+                m_shouldThrow = true;
+        }
+    }
+    void ResultBuilder::react() {
+        if( m_shouldThrow )
+            throw Catch::TestFailureException();
+    }
+
+    bool ResultBuilder::shouldDebugBreak() const { return m_shouldDebugBreak; }
+    bool ResultBuilder::allowThrows() const { return getCurrentContext().getConfig()->allowThrows(); }
+
+    AssertionResult ResultBuilder::build() const
+    {
+        assert( m_data.resultType != ResultWas::Unknown );
+
+        AssertionResultData data = m_data;
+
+        // Flip bool results if testFalse is set
+        if( m_exprComponents.testFalse ) {
+            if( data.resultType == ResultWas::Ok )
+                data.resultType = ResultWas::ExpressionFailed;
+            else if( data.resultType == ResultWas::ExpressionFailed )
+                data.resultType = ResultWas::Ok;
+        }
+
+        data.message = m_stream.oss.str();
+        data.reconstructedExpression = reconstructExpression();
+        if( m_exprComponents.testFalse ) {
+            if( m_exprComponents.op == "" )
+                data.reconstructedExpression = "!" + data.reconstructedExpression;
+            else
+                data.reconstructedExpression = "!(" + data.reconstructedExpression + ")";
+        }
+        return AssertionResult( m_assertionInfo, data );
+    }
+    std::string ResultBuilder::reconstructExpression() const {
+        if( m_exprComponents.op == "" )
+            return m_exprComponents.lhs.empty() ? m_assertionInfo.capturedExpression : m_exprComponents.op + m_exprComponents.lhs;
+        else if( m_exprComponents.op == "matches" )
+            return m_exprComponents.lhs + " " + m_exprComponents.rhs;
+        else if( m_exprComponents.op != "!" ) {
+            if( m_exprComponents.lhs.size() + m_exprComponents.rhs.size() < 40 &&
+                m_exprComponents.lhs.find("\n") == std::string::npos &&
+                m_exprComponents.rhs.find("\n") == std::string::npos )
+                return m_exprComponents.lhs + " " + m_exprComponents.op + " " + m_exprComponents.rhs;
+            else
+                return m_exprComponents.lhs + "\n" + m_exprComponents.op + "\n" + m_exprComponents.rhs;
+        }
+        else
+            return "{can't expand - use " + m_assertionInfo.macroName + "_FALSE( " + m_assertionInfo.capturedExpression.substr(1) + " ) instead of " + m_assertionInfo.macroName + "( " + m_assertionInfo.capturedExpression + " ) for better diagnostics}";
+    }
+
+} // end namespace Catch
+
+// #included from: catch_tag_alias_registry.hpp
+#define TWOBLUECUBES_CATCH_TAG_ALIAS_REGISTRY_HPP_INCLUDED
+
+// #included from: catch_tag_alias_registry.h
+#define TWOBLUECUBES_CATCH_TAG_ALIAS_REGISTRY_H_INCLUDED
+
+#include <map>
+
+namespace Catch {
+
+    class TagAliasRegistry : public ITagAliasRegistry {
+    public:
+        virtual ~TagAliasRegistry();
+        virtual Option<TagAlias> find( std::string const& alias ) const;
+        virtual std::string expandAliases( std::string const& unexpandedTestSpec ) const;
+        void add( char const* alias, char const* tag, SourceLineInfo const& lineInfo );
+        static TagAliasRegistry& get();
+
+    private:
+        std::map<std::string, TagAlias> m_registry;
+    };
+
+} // end namespace Catch
+
+#include <map>
+#include <iostream>
+
+namespace Catch {
+
+    TagAliasRegistry::~TagAliasRegistry() {}
+
+    Option<TagAlias> TagAliasRegistry::find( std::string const& alias ) const {
+        std::map<std::string, TagAlias>::const_iterator it = m_registry.find( alias );
+        if( it != m_registry.end() )
+            return it->second;
+        else
+            return Option<TagAlias>();
+    }
+
+    std::string TagAliasRegistry::expandAliases( std::string const& unexpandedTestSpec ) const {
+        std::string expandedTestSpec = unexpandedTestSpec;
+        for( std::map<std::string, TagAlias>::const_iterator it = m_registry.begin(), itEnd = m_registry.end();
+                it != itEnd;
+                ++it ) {
+            std::size_t pos = expandedTestSpec.find( it->first );
+            if( pos != std::string::npos ) {
+                expandedTestSpec =  expandedTestSpec.substr( 0, pos ) +
+                                    it->second.tag +
+                                    expandedTestSpec.substr( pos + it->first.size() );
+            }
+        }
+        return expandedTestSpec;
+    }
+
+    void TagAliasRegistry::add( char const* alias, char const* tag, SourceLineInfo const& lineInfo ) {
+
+        if( !startsWith( alias, "[@" ) || !endsWith( alias, "]" ) ) {
+            std::ostringstream oss;
+            oss << "error: tag alias, \"" << alias << "\" is not of the form [@alias name].\n" << lineInfo;
+            throw std::domain_error( oss.str().c_str() );
+        }
+        if( !m_registry.insert( std::make_pair( alias, TagAlias( tag, lineInfo ) ) ).second ) {
+            std::ostringstream oss;
+            oss << "error: tag alias, \"" << alias << "\" already registered.\n"
+                << "\tFirst seen at " << find(alias)->lineInfo << "\n"
+                << "\tRedefined at " << lineInfo;
+            throw std::domain_error( oss.str().c_str() );
+        }
+    }
+
+    TagAliasRegistry& TagAliasRegistry::get() {
+        static TagAliasRegistry instance;
+        return instance;
+
+    }
+
+    ITagAliasRegistry::~ITagAliasRegistry() {}
+    ITagAliasRegistry const& ITagAliasRegistry::get() { return TagAliasRegistry::get(); }
+
+    RegistrarForTagAliases::RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo ) {
+        try {
+            TagAliasRegistry::get().add( alias, tag, lineInfo );
+        }
+        catch( std::exception& ex ) {
+            Colour colourGuard( Colour::Red );
+            std::cerr << ex.what() << std::endl;
+            exit(1);
+        }
+    }
+
+} // end namespace Catch
+
+// #included from: ../reporters/catch_reporter_xml.hpp
+#define TWOBLUECUBES_CATCH_REPORTER_XML_HPP_INCLUDED
+
+// #included from: catch_reporter_bases.hpp
+#define TWOBLUECUBES_CATCH_REPORTER_BASES_HPP_INCLUDED
+
+namespace Catch {
+
+    struct StreamingReporterBase : SharedImpl<IStreamingReporter> {
+
+        StreamingReporterBase( ReporterConfig const& _config )
+        :   m_config( _config.fullConfig() ),
+            stream( _config.stream() )
+        {}
+
+        virtual ~StreamingReporterBase();
+
+        virtual void noMatchingTestCases( std::string const& ) {}
+
+        virtual void testRunStarting( TestRunInfo const& _testRunInfo ) {
+            currentTestRunInfo = _testRunInfo;
+        }
+        virtual void testGroupStarting( GroupInfo const& _groupInfo ) {
+            currentGroupInfo = _groupInfo;
+        }
+
+        virtual void testCaseStarting( TestCaseInfo const& _testInfo ) {
+            currentTestCaseInfo = _testInfo;
+        }
+        virtual void sectionStarting( SectionInfo const& _sectionInfo ) {
+            m_sectionStack.push_back( _sectionInfo );
+        }
+
+        virtual void sectionEnded( SectionStats const& /* _sectionStats */ ) {
+            m_sectionStack.pop_back();
+        }
+        virtual void testCaseEnded( TestCaseStats const& /* _testCaseStats */ ) {
+            currentTestCaseInfo.reset();
+            assert( m_sectionStack.empty() );
+        }
+        virtual void testGroupEnded( TestGroupStats const& /* _testGroupStats */ ) {
+            currentGroupInfo.reset();
+        }
+        virtual void testRunEnded( TestRunStats const& /* _testRunStats */ ) {
+            currentTestCaseInfo.reset();
+            currentGroupInfo.reset();
+            currentTestRunInfo.reset();
+        }
+
+        Ptr<IConfig> m_config;
+        std::ostream& stream;
+
+        LazyStat<TestRunInfo> currentTestRunInfo;
+        LazyStat<GroupInfo> currentGroupInfo;
+        LazyStat<TestCaseInfo> currentTestCaseInfo;
+
+        std::vector<SectionInfo> m_sectionStack;
+    };
+
+    struct CumulativeReporterBase : SharedImpl<IStreamingReporter> {
+        template<typename T, typename ChildNodeT>
+        struct Node : SharedImpl<> {
+            explicit Node( T const& _value ) : value( _value ) {}
+            virtual ~Node() {}
+
+            typedef std::vector<Ptr<ChildNodeT> > ChildNodes;
+            T value;
+            ChildNodes children;
+        };
+        struct SectionNode : SharedImpl<> {
+            explicit SectionNode( SectionStats const& _stats ) : stats( _stats ) {}
+            virtual ~SectionNode();
+
+            bool operator == ( SectionNode const& other ) const {
+                return stats.sectionInfo.lineInfo == other.stats.sectionInfo.lineInfo;
+            }
+            bool operator == ( Ptr<SectionNode> const& other ) const {
+                return operator==( *other );
+            }
+
+            SectionStats stats;
+            typedef std::vector<Ptr<SectionNode> > ChildSections;
+            typedef std::vector<AssertionStats> Assertions;
+            ChildSections childSections;
+            Assertions assertions;
+            std::string stdOut;
+            std::string stdErr;
+        };
+
+        struct BySectionInfo {
+            BySectionInfo( SectionInfo const& other ) : m_other( other ) {}
+			BySectionInfo( BySectionInfo const& other ) : m_other( other.m_other ) {}
+            bool operator() ( Ptr<SectionNode> const& node ) const {
+                return node->stats.sectionInfo.lineInfo == m_other.lineInfo;
+            }
+        private:
+			void operator=( BySectionInfo const& );
+            SectionInfo const& m_other;
+        };
+
+        typedef Node<TestCaseStats, SectionNode> TestCaseNode;
+        typedef Node<TestGroupStats, TestCaseNode> TestGroupNode;
+        typedef Node<TestRunStats, TestGroupNode> TestRunNode;
+
+        CumulativeReporterBase( ReporterConfig const& _config )
+        :   m_config( _config.fullConfig() ),
+            stream( _config.stream() )
+        {}
+        ~CumulativeReporterBase();
+
+        virtual void testRunStarting( TestRunInfo const& ) {}
+        virtual void testGroupStarting( GroupInfo const& ) {}
+
+        virtual void testCaseStarting( TestCaseInfo const& ) {}
+
+        virtual void sectionStarting( SectionInfo const& sectionInfo ) {
+            SectionStats incompleteStats( sectionInfo, Counts(), 0, false );
+            Ptr<SectionNode> node;
+            if( m_sectionStack.empty() ) {
+                if( !m_rootSection )
+                    m_rootSection = new SectionNode( incompleteStats );
+                node = m_rootSection;
+            }
+            else {
+                SectionNode& parentNode = *m_sectionStack.back();
+                SectionNode::ChildSections::const_iterator it =
+                    std::find_if(   parentNode.childSections.begin(),
+                                    parentNode.childSections.end(),
+                                    BySectionInfo( sectionInfo ) );
+                if( it == parentNode.childSections.end() ) {
+                    node = new SectionNode( incompleteStats );
+                    parentNode.childSections.push_back( node );
+                }
+                else
+                    node = *it;
+            }
+            m_sectionStack.push_back( node );
+            m_deepestSection = node;
+        }
+
+        virtual void assertionStarting( AssertionInfo const& ) {}
+
+        virtual bool assertionEnded( AssertionStats const& assertionStats ) {
+            assert( !m_sectionStack.empty() );
+            SectionNode& sectionNode = *m_sectionStack.back();
+            sectionNode.assertions.push_back( assertionStats );
+            return true;
+        }
+        virtual void sectionEnded( SectionStats const& sectionStats ) {
+            assert( !m_sectionStack.empty() );
+            SectionNode& node = *m_sectionStack.back();
+            node.stats = sectionStats;
+            m_sectionStack.pop_back();
+        }
+        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) {
+            Ptr<TestCaseNode> node = new TestCaseNode( testCaseStats );
+            assert( m_sectionStack.size() == 0 );
+            node->children.push_back( m_rootSection );
+            m_testCases.push_back( node );
+            m_rootSection.reset();
+
+            assert( m_deepestSection );
+            m_deepestSection->stdOut = testCaseStats.stdOut;
+            m_deepestSection->stdErr = testCaseStats.stdErr;
+        }
+        virtual void testGroupEnded( TestGroupStats const& testGroupStats ) {
+            Ptr<TestGroupNode> node = new TestGroupNode( testGroupStats );
+            node->children.swap( m_testCases );
+            m_testGroups.push_back( node );
+        }
+        virtual void testRunEnded( TestRunStats const& testRunStats ) {
+            Ptr<TestRunNode> node = new TestRunNode( testRunStats );
+            node->children.swap( m_testGroups );
+            m_testRuns.push_back( node );
+            testRunEndedCumulative();
+        }
+        virtual void testRunEndedCumulative() = 0;
+
+        Ptr<IConfig> m_config;
+        std::ostream& stream;
+        std::vector<AssertionStats> m_assertions;
+        std::vector<std::vector<Ptr<SectionNode> > > m_sections;
+        std::vector<Ptr<TestCaseNode> > m_testCases;
+        std::vector<Ptr<TestGroupNode> > m_testGroups;
+
+        std::vector<Ptr<TestRunNode> > m_testRuns;
+
+        Ptr<SectionNode> m_rootSection;
+        Ptr<SectionNode> m_deepestSection;
+        std::vector<Ptr<SectionNode> > m_sectionStack;
+
+    };
+
+} // end namespace Catch
+
+// #included from: ../internal/catch_reporter_registrars.hpp
+#define TWOBLUECUBES_CATCH_REPORTER_REGISTRARS_HPP_INCLUDED
+
+namespace Catch {
+
+    template<typename T>
+    class LegacyReporterRegistrar {
+
+        class ReporterFactory : public IReporterFactory {
+            virtual IStreamingReporter* create( ReporterConfig const& config ) const {
+                return new LegacyReporterAdapter( new T( config ) );
+            }
+
+            virtual std::string getDescription() const {
+                return T::getDescription();
+            }
+        };
+
+    public:
+
+        LegacyReporterRegistrar( std::string const& name ) {
+            getMutableRegistryHub().registerReporter( name, new ReporterFactory() );
+        }
+    };
+
+    template<typename T>
+    class ReporterRegistrar {
+
+        class ReporterFactory : public IReporterFactory {
+
+            // *** Please Note ***:
+            // - If you end up here looking at a compiler error because it's trying to register
+            // your custom reporter class be aware that the native reporter interface has changed
+            // to IStreamingReporter. The "legacy" interface, IReporter, is still supported via
+            // an adapter. Just use REGISTER_LEGACY_REPORTER to take advantage of the adapter.
+            // However please consider updating to the new interface as the old one is now
+            // deprecated and will probably be removed quite soon!
+            // Please contact me via github if you have any questions at all about this.
+            // In fact, ideally, please contact me anyway to let me know you've hit this - as I have
+            // no idea who is actually using custom reporters at all (possibly no-one!).
+            // The new interface is designed to minimise exposure to interface changes in the future.
+            virtual IStreamingReporter* create( ReporterConfig const& config ) const {
+                return new T( config );
+            }
+
+            virtual std::string getDescription() const {
+                return T::getDescription();
+            }
+        };
+
+    public:
+
+        ReporterRegistrar( std::string const& name ) {
+            getMutableRegistryHub().registerReporter( name, new ReporterFactory() );
+        }
+    };
+}
+
+#define INTERNAL_CATCH_REGISTER_LEGACY_REPORTER( name, reporterType ) \
+    namespace{ Catch::LegacyReporterRegistrar<reporterType> catch_internal_RegistrarFor##reporterType( name ); }
+#define INTERNAL_CATCH_REGISTER_REPORTER( name, reporterType ) \
+    namespace{ Catch::ReporterRegistrar<reporterType> catch_internal_RegistrarFor##reporterType( name ); }
+
+// #included from: ../internal/catch_xmlwriter.hpp
+#define TWOBLUECUBES_CATCH_XMLWRITER_HPP_INCLUDED
+
+#include <sstream>
+#include <iostream>
+#include <string>
+#include <vector>
+
+namespace Catch {
+
+    class XmlWriter {
+    public:
+
+        class ScopedElement {
+        public:
+            ScopedElement( XmlWriter* writer )
+            :   m_writer( writer )
+            {}
+
+            ScopedElement( ScopedElement const& other )
+            :   m_writer( other.m_writer ){
+                other.m_writer = NULL;
+            }
+
+            ~ScopedElement() {
+                if( m_writer )
+                    m_writer->endElement();
+            }
+
+            ScopedElement& writeText( std::string const& text, bool indent = true ) {
+                m_writer->writeText( text, indent );
+                return *this;
+            }
+
+            template<typename T>
+            ScopedElement& writeAttribute( std::string const& name, T const& attribute ) {
+                m_writer->writeAttribute( name, attribute );
+                return *this;
+            }
+
+        private:
+            mutable XmlWriter* m_writer;
+        };
+
+        XmlWriter()
+        :   m_tagIsOpen( false ),
+            m_needsNewline( false ),
+            m_os( &std::cout )
+        {}
+
+        XmlWriter( std::ostream& os )
+        :   m_tagIsOpen( false ),
+            m_needsNewline( false ),
+            m_os( &os )
+        {}
+
+        ~XmlWriter() {
+            while( !m_tags.empty() )
+                endElement();
+        }
+
+//#  ifndef CATCH_CPP11_OR_GREATER
+//        XmlWriter& operator = ( XmlWriter const& other ) {
+//            XmlWriter temp( other );
+//            swap( temp );
+//            return *this;
+//        }
+//#  else
+//        XmlWriter( XmlWriter const& )              = default;
+//        XmlWriter( XmlWriter && )                  = default;
+//        XmlWriter& operator = ( XmlWriter const& ) = default;
+//        XmlWriter& operator = ( XmlWriter && )     = default;
+//#  endif
+//
+//        void swap( XmlWriter& other ) {
+//            std::swap( m_tagIsOpen, other.m_tagIsOpen );
+//            std::swap( m_needsNewline, other.m_needsNewline );
+//            std::swap( m_tags, other.m_tags );
+//            std::swap( m_indent, other.m_indent );
+//            std::swap( m_os, other.m_os );
+//        }
+
+        XmlWriter& startElement( std::string const& name ) {
+            ensureTagClosed();
+            newlineIfNecessary();
+            stream() << m_indent << "<" << name;
+            m_tags.push_back( name );
+            m_indent += "  ";
+            m_tagIsOpen = true;
+            return *this;
+        }
+
+        ScopedElement scopedElement( std::string const& name ) {
+            ScopedElement scoped( this );
+            startElement( name );
+            return scoped;
+        }
+
+        XmlWriter& endElement() {
+            newlineIfNecessary();
+            m_indent = m_indent.substr( 0, m_indent.size()-2 );
+            if( m_tagIsOpen ) {
+                stream() << "/>\n";
+                m_tagIsOpen = false;
+            }
+            else {
+                stream() << m_indent << "</" << m_tags.back() << ">\n";
+            }
+            m_tags.pop_back();
+            return *this;
+        }
+
+        XmlWriter& writeAttribute( std::string const& name, std::string const& attribute ) {
+            if( !name.empty() && !attribute.empty() ) {
+                stream() << " " << name << "=\"";
+                writeEncodedText( attribute );
+                stream() << "\"";
+            }
+            return *this;
+        }
+
+        XmlWriter& writeAttribute( std::string const& name, bool attribute ) {
+            stream() << " " << name << "=\"" << ( attribute ? "true" : "false" ) << "\"";
+            return *this;
+        }
+
+        template<typename T>
+        XmlWriter& writeAttribute( std::string const& name, T const& attribute ) {
+            if( !name.empty() )
+                stream() << " " << name << "=\"" << attribute << "\"";
+            return *this;
+        }
+
+        XmlWriter& writeText( std::string const& text, bool indent = true ) {
+            if( !text.empty() ){
+                bool tagWasOpen = m_tagIsOpen;
+                ensureTagClosed();
+                if( tagWasOpen && indent )
+                    stream() << m_indent;
+                writeEncodedText( text );
+                m_needsNewline = true;
+            }
+            return *this;
+        }
+
+        XmlWriter& writeComment( std::string const& text ) {
+            ensureTagClosed();
+            stream() << m_indent << "<!--" << text << "-->";
+            m_needsNewline = true;
+            return *this;
+        }
+
+        XmlWriter& writeBlankLine() {
+            ensureTagClosed();
+            stream() << "\n";
+            return *this;
+        }
+
+        void setStream( std::ostream& os ) {
+            m_os = &os;
+        }
+
+    private:
+        XmlWriter( XmlWriter const& );
+        void operator=( XmlWriter const& );
+
+        std::ostream& stream() {
+            return *m_os;
+        }
+
+        void ensureTagClosed() {
+            if( m_tagIsOpen ) {
+                stream() << ">\n";
+                m_tagIsOpen = false;
+            }
+        }
+
+        void newlineIfNecessary() {
+            if( m_needsNewline ) {
+                stream() << "\n";
+                m_needsNewline = false;
+            }
+        }
+
+        void writeEncodedText( std::string const& text ) {
+            static const char* charsToEncode = "<&\"";
+            std::string mtext = text;
+            std::string::size_type pos = mtext.find_first_of( charsToEncode );
+            while( pos != std::string::npos ) {
+                stream() << mtext.substr( 0, pos );
+
+                switch( mtext[pos] ) {
+                    case '<':
+                        stream() << "&lt;";
+                        break;
+                    case '&':
+                        stream() << "&amp;";
+                        break;
+                    case '\"':
+                        stream() << "&quot;";
+                        break;
+                }
+                mtext = mtext.substr( pos+1 );
+                pos = mtext.find_first_of( charsToEncode );
+            }
+            stream() << mtext;
+        }
+
+        bool m_tagIsOpen;
+        bool m_needsNewline;
+        std::vector<std::string> m_tags;
+        std::string m_indent;
+        std::ostream* m_os;
+    };
+
+}
+namespace Catch {
+    class XmlReporter : public SharedImpl<IReporter> {
+    public:
+        XmlReporter( ReporterConfig const& config ) : m_config( config ), m_sectionDepth( 0 ) {}
+
+        static std::string getDescription() {
+            return "Reports test results as an XML document";
+        }
+        virtual ~XmlReporter();
+
+    private: // IReporter
+
+        virtual bool shouldRedirectStdout() const {
+            return true;
+        }
+
+        virtual void StartTesting() {
+            m_xml.setStream( m_config.stream() );
+            m_xml.startElement( "Catch" );
+            if( !m_config.fullConfig()->name().empty() )
+                m_xml.writeAttribute( "name", m_config.fullConfig()->name() );
+        }
+
+        virtual void EndTesting( const Totals& totals ) {
+            m_xml.scopedElement( "OverallResults" )
+                .writeAttribute( "successes", totals.assertions.passed )
+                .writeAttribute( "failures", totals.assertions.failed )
+                .writeAttribute( "expectedFailures", totals.assertions.failedButOk );
+            m_xml.endElement();
+        }
+
+        virtual void StartGroup( const std::string& groupName ) {
+            m_xml.startElement( "Group" )
+                .writeAttribute( "name", groupName );
+        }
+
+        virtual void EndGroup( const std::string&, const Totals& totals ) {
+            m_xml.scopedElement( "OverallResults" )
+                .writeAttribute( "successes", totals.assertions.passed )
+                .writeAttribute( "failures", totals.assertions.failed )
+                .writeAttribute( "expectedFailures", totals.assertions.failedButOk );
+            m_xml.endElement();
+        }
+
+        virtual void StartSection( const std::string& sectionName, const std::string& description ) {
+            if( m_sectionDepth++ > 0 ) {
+                m_xml.startElement( "Section" )
+                    .writeAttribute( "name", trim( sectionName ) )
+                    .writeAttribute( "description", description );
+            }
+        }
+        virtual void NoAssertionsInSection( const std::string& ) {}
+        virtual void NoAssertionsInTestCase( const std::string& ) {}
+
+        virtual void EndSection( const std::string& /*sectionName*/, const Counts& assertions ) {
+            if( --m_sectionDepth > 0 ) {
+                m_xml.scopedElement( "OverallResults" )
+                    .writeAttribute( "successes", assertions.passed )
+                    .writeAttribute( "failures", assertions.failed )
+                    .writeAttribute( "expectedFailures", assertions.failedButOk );
+                m_xml.endElement();
+            }
+        }
+
+        virtual void StartTestCase( const Catch::TestCaseInfo& testInfo ) {
+            m_xml.startElement( "TestCase" ).writeAttribute( "name", trim( testInfo.name ) );
+            m_currentTestSuccess = true;
+        }
+
+        virtual void Result( const Catch::AssertionResult& assertionResult ) {
+            if( !m_config.fullConfig()->includeSuccessfulResults() && assertionResult.getResultType() == ResultWas::Ok )
+                return;
+
+            if( assertionResult.hasExpression() ) {
+                m_xml.startElement( "Expression" )
+                    .writeAttribute( "success", assertionResult.succeeded() )
+                    .writeAttribute( "filename", assertionResult.getSourceInfo().file )
+                    .writeAttribute( "line", assertionResult.getSourceInfo().line );
+
+                m_xml.scopedElement( "Original" )
+                    .writeText( assertionResult.getExpression() );
+                m_xml.scopedElement( "Expanded" )
+                    .writeText( assertionResult.getExpandedExpression() );
+                m_currentTestSuccess &= assertionResult.succeeded();
+            }
+
+            switch( assertionResult.getResultType() ) {
+                case ResultWas::ThrewException:
+                    m_xml.scopedElement( "Exception" )
+                        .writeAttribute( "filename", assertionResult.getSourceInfo().file )
+                        .writeAttribute( "line", assertionResult.getSourceInfo().line )
+                        .writeText( assertionResult.getMessage() );
+                    m_currentTestSuccess = false;
+                    break;
+                case ResultWas::Info:
+                    m_xml.scopedElement( "Info" )
+                        .writeText( assertionResult.getMessage() );
+                    break;
+                case ResultWas::Warning:
+                    m_xml.scopedElement( "Warning" )
+                        .writeText( assertionResult.getMessage() );
+                    break;
+                case ResultWas::ExplicitFailure:
+                    m_xml.scopedElement( "Failure" )
+                        .writeText( assertionResult.getMessage() );
+                    m_currentTestSuccess = false;
+                    break;
+                case ResultWas::Unknown:
+                case ResultWas::Ok:
+                case ResultWas::FailureBit:
+                case ResultWas::ExpressionFailed:
+                case ResultWas::Exception:
+                case ResultWas::DidntThrowException:
+                    break;
+            }
+            if( assertionResult.hasExpression() )
+                m_xml.endElement();
+        }
+
+        virtual void Aborted() {
+            // !TBD
+        }
+
+        virtual void EndTestCase( const Catch::TestCaseInfo&, const Totals&, const std::string&, const std::string& ) {
+            m_xml.scopedElement( "OverallResult" ).writeAttribute( "success", m_currentTestSuccess );
+            m_xml.endElement();
+        }
+
+    private:
+        ReporterConfig m_config;
+        bool m_currentTestSuccess;
+        XmlWriter m_xml;
+        int m_sectionDepth;
+    };
+
+} // end namespace Catch
+
+// #included from: ../reporters/catch_reporter_junit.hpp
+#define TWOBLUECUBES_CATCH_REPORTER_JUNIT_HPP_INCLUDED
+
+#include <assert.h>
+
+namespace Catch {
+
+    class JunitReporter : public CumulativeReporterBase {
+    public:
+        JunitReporter( ReporterConfig const& _config )
+        :   CumulativeReporterBase( _config ),
+            xml( _config.stream() )
+        {}
+
+        ~JunitReporter();
+
+        static std::string getDescription() {
+            return "Reports test results in an XML format that looks like Ant's junitreport target";
+        }
+
+        virtual void noMatchingTestCases( std::string const& /*spec*/ ) {}
+
+        virtual ReporterPreferences getPreferences() const {
+            ReporterPreferences prefs;
+            prefs.shouldRedirectStdOut = true;
+            return prefs;
+        }
+
+        virtual void testRunStarting( TestRunInfo const& runInfo ) {
+            CumulativeReporterBase::testRunStarting( runInfo );
+            xml.startElement( "testsuites" );
+        }
+
+        virtual void testGroupStarting( GroupInfo const& groupInfo ) {
+            suiteTimer.start();
+            stdOutForSuite.str("");
+            stdErrForSuite.str("");
+            unexpectedExceptions = 0;
+            CumulativeReporterBase::testGroupStarting( groupInfo );
+        }
+
+        virtual bool assertionEnded( AssertionStats const& assertionStats ) {
+            if( assertionStats.assertionResult.getResultType() == ResultWas::ThrewException )
+                unexpectedExceptions++;
+            return CumulativeReporterBase::assertionEnded( assertionStats );
+        }
+
+        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) {
+            stdOutForSuite << testCaseStats.stdOut;
+            stdErrForSuite << testCaseStats.stdErr;
+            CumulativeReporterBase::testCaseEnded( testCaseStats );
+        }
+
+        virtual void testGroupEnded( TestGroupStats const& testGroupStats ) {
+            double suiteTime = suiteTimer.getElapsedSeconds();
+            CumulativeReporterBase::testGroupEnded( testGroupStats );
+            writeGroup( *m_testGroups.back(), suiteTime );
+        }
+
+        virtual void testRunEndedCumulative() {
+            xml.endElement();
+        }
+
+        void writeGroup( TestGroupNode const& groupNode, double suiteTime ) {
+            XmlWriter::ScopedElement e = xml.scopedElement( "testsuite" );
+            TestGroupStats const& stats = groupNode.value;
+            xml.writeAttribute( "name", stats.groupInfo.name );
+            xml.writeAttribute( "errors", unexpectedExceptions );
+            xml.writeAttribute( "failures", stats.totals.assertions.failed-unexpectedExceptions );
+            xml.writeAttribute( "tests", stats.totals.assertions.total() );
+            xml.writeAttribute( "hostname", "tbd" ); // !TBD
+            if( m_config->showDurations() == ShowDurations::Never )
+                xml.writeAttribute( "time", "" );
+            else
+                xml.writeAttribute( "time", suiteTime );
+            xml.writeAttribute( "timestamp", "tbd" ); // !TBD
+
+            // Write test cases
+            for( TestGroupNode::ChildNodes::const_iterator
+                    it = groupNode.children.begin(), itEnd = groupNode.children.end();
+                    it != itEnd;
+                    ++it )
+                writeTestCase( **it );
+
+            xml.scopedElement( "system-out" ).writeText( trim( stdOutForSuite.str() ), false );
+            xml.scopedElement( "system-err" ).writeText( trim( stdErrForSuite.str() ), false );
+        }
+
+        void writeTestCase( TestCaseNode const& testCaseNode ) {
+            TestCaseStats const& stats = testCaseNode.value;
+
+            // All test cases have exactly one section - which represents the
+            // test case itself. That section may have 0-n nested sections
+            assert( testCaseNode.children.size() == 1 );
+            SectionNode const& rootSection = *testCaseNode.children.front();
+
+            std::string className = stats.testInfo.className;
+
+            if( className.empty() ) {
+                if( rootSection.childSections.empty() )
+                    className = "global";
+            }
+            writeSection( className, "", rootSection );
+        }
+
+        void writeSection(  std::string const& className,
+                            std::string const& rootName,
+                            SectionNode const& sectionNode ) {
+            std::string name = trim( sectionNode.stats.sectionInfo.name );
+            if( !rootName.empty() )
+                name = rootName + "/" + name;
+
+            if( !sectionNode.assertions.empty() ||
+                !sectionNode.stdOut.empty() ||
+                !sectionNode.stdErr.empty() ) {
+                XmlWriter::ScopedElement e = xml.scopedElement( "testcase" );
+                if( className.empty() ) {
+                    xml.writeAttribute( "classname", name );
+                    xml.writeAttribute( "name", "root" );
+                }
+                else {
+                    xml.writeAttribute( "classname", className );
+                    xml.writeAttribute( "name", name );
+                }
+                xml.writeAttribute( "time", toString( sectionNode.stats.durationInSeconds ) );
+
+                writeAssertions( sectionNode );
+
+                if( !sectionNode.stdOut.empty() )
+                    xml.scopedElement( "system-out" ).writeText( trim( sectionNode.stdOut ), false );
+                if( !sectionNode.stdErr.empty() )
+                    xml.scopedElement( "system-err" ).writeText( trim( sectionNode.stdErr ), false );
+            }
+            for( SectionNode::ChildSections::const_iterator
+                    it = sectionNode.childSections.begin(),
+                    itEnd = sectionNode.childSections.end();
+                    it != itEnd;
+                    ++it )
+                if( className.empty() )
+                    writeSection( name, "", **it );
+                else
+                    writeSection( className, name, **it );
+        }
+
+        void writeAssertions( SectionNode const& sectionNode ) {
+            for( SectionNode::Assertions::const_iterator
+                    it = sectionNode.assertions.begin(), itEnd = sectionNode.assertions.end();
+                    it != itEnd;
+                    ++it )
+                writeAssertion( *it );
+        }
+        void writeAssertion( AssertionStats const& stats ) {
+            AssertionResult const& result = stats.assertionResult;
+            if( !result.isOk() ) {
+                std::string elementName;
+                switch( result.getResultType() ) {
+                    case ResultWas::ThrewException:
+                        elementName = "error";
+                        break;
+                    case ResultWas::ExplicitFailure:
+                        elementName = "failure";
+                        break;
+                    case ResultWas::ExpressionFailed:
+                        elementName = "failure";
+                        break;
+                    case ResultWas::DidntThrowException:
+                        elementName = "failure";
+                        break;
+
+                    // We should never see these here:
+                    case ResultWas::Info:
+                    case ResultWas::Warning:
+                    case ResultWas::Ok:
+                    case ResultWas::Unknown:
+                    case ResultWas::FailureBit:
+                    case ResultWas::Exception:
+                        elementName = "internalError";
+                        break;
+                }
+
+                XmlWriter::ScopedElement e = xml.scopedElement( elementName );
+
+                xml.writeAttribute( "message", result.getExpandedExpression() );
+                xml.writeAttribute( "type", result.getTestMacroName() );
+
+                std::ostringstream oss;
+                if( !result.getMessage().empty() )
+                    oss << result.getMessage() << "\n";
+                for( std::vector<MessageInfo>::const_iterator
+                        it = stats.infoMessages.begin(),
+                        itEnd = stats.infoMessages.end();
+                            it != itEnd;
+                            ++it )
+                    if( it->type == ResultWas::Info )
+                        oss << it->message << "\n";
+
+                oss << "at " << result.getSourceInfo();
+                xml.writeText( oss.str(), false );
+            }
+        }
+
+        XmlWriter xml;
+        Timer suiteTimer;
+        std::ostringstream stdOutForSuite;
+        std::ostringstream stdErrForSuite;
+        unsigned int unexpectedExceptions;
+    };
+
+    INTERNAL_CATCH_REGISTER_REPORTER( "junit", JunitReporter )
+
+} // end namespace Catch
+
+// #included from: ../reporters/catch_reporter_console.hpp
+#define TWOBLUECUBES_CATCH_REPORTER_CONSOLE_HPP_INCLUDED
+
+#include <cstring>
+
+namespace Catch {
+
+    struct ConsoleReporter : StreamingReporterBase {
+        ConsoleReporter( ReporterConfig const& _config )
+        :   StreamingReporterBase( _config ),
+            m_headerPrinted( false )
+        {}
+
+        virtual ~ConsoleReporter();
+        static std::string getDescription() {
+            return "Reports test results as plain lines of text";
+        }
+        virtual ReporterPreferences getPreferences() const {
+            ReporterPreferences prefs;
+            prefs.shouldRedirectStdOut = false;
+            return prefs;
+        }
+
+        virtual void noMatchingTestCases( std::string const& spec ) {
+            stream << "No test cases matched '" << spec << "'" << std::endl;
+        }
+
+        virtual void assertionStarting( AssertionInfo const& ) {
+        }
+
+        virtual bool assertionEnded( AssertionStats const& _assertionStats ) {
+            AssertionResult const& result = _assertionStats.assertionResult;
+
+            bool printInfoMessages = true;
+
+            // Drop out if result was successful and we're not printing those
+            if( !m_config->includeSuccessfulResults() && result.isOk() ) {
+                if( result.getResultType() != ResultWas::Warning )
+                    return false;
+                printInfoMessages = false;
+            }
+
+            lazyPrint();
+
+            AssertionPrinter printer( stream, _assertionStats, printInfoMessages );
+            printer.print();
+            stream << std::endl;
+            return true;
+        }
+
+        virtual void sectionStarting( SectionInfo const& _sectionInfo ) {
+            m_headerPrinted = false;
+            StreamingReporterBase::sectionStarting( _sectionInfo );
+        }
+        virtual void sectionEnded( SectionStats const& _sectionStats ) {
+            if( _sectionStats.missingAssertions ) {
+                lazyPrint();
+                Colour colour( Colour::ResultError );
+                if( m_sectionStack.size() > 1 )
+                    stream << "\nNo assertions in section";
+                else
+                    stream << "\nNo assertions in test case";
+                stream << " '" << _sectionStats.sectionInfo.name << "'\n" << std::endl;
+            }
+            if( m_headerPrinted ) {
+                if( m_config->showDurations() == ShowDurations::Always )
+                    stream << "Completed in " << _sectionStats.durationInSeconds << "s" << std::endl;
+                m_headerPrinted = false;
+            }
+            else {
+                if( m_config->showDurations() == ShowDurations::Always )
+                    stream << _sectionStats.sectionInfo.name << " completed in " << _sectionStats.durationInSeconds << "s" << std::endl;
+            }
+            StreamingReporterBase::sectionEnded( _sectionStats );
+        }
+
+        virtual void testCaseEnded( TestCaseStats const& _testCaseStats ) {
+            StreamingReporterBase::testCaseEnded( _testCaseStats );
+            m_headerPrinted = false;
+        }
+        virtual void testGroupEnded( TestGroupStats const& _testGroupStats ) {
+            if( currentGroupInfo.used ) {
+                printSummaryDivider();
+                stream << "Summary for group '" << _testGroupStats.groupInfo.name << "':\n";
+                printTotals( _testGroupStats.totals );
+                stream << "\n" << std::endl;
+            }
+            StreamingReporterBase::testGroupEnded( _testGroupStats );
+        }
+        virtual void testRunEnded( TestRunStats const& _testRunStats ) {
+            printTotalsDivider( _testRunStats.totals );
+            printTotals( _testRunStats.totals );
+            stream << std::endl;
+            StreamingReporterBase::testRunEnded( _testRunStats );
+        }
+
+    private:
+
+        class AssertionPrinter {
+            void operator= ( AssertionPrinter const& );
+        public:
+            AssertionPrinter( std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages )
+            :   stream( _stream ),
+                stats( _stats ),
+                result( _stats.assertionResult ),
+                colour( Colour::None ),
+                message( result.getMessage() ),
+                messages( _stats.infoMessages ),
+                printInfoMessages( _printInfoMessages )
+            {
+                switch( result.getResultType() ) {
+                    case ResultWas::Ok:
+                        colour = Colour::Success;
+                        passOrFail = "PASSED";
+                        //if( result.hasMessage() )
+                        if( _stats.infoMessages.size() == 1 )
+                            messageLabel = "with message";
+                        if( _stats.infoMessages.size() > 1 )
+                            messageLabel = "with messages";
+                        break;
+                    case ResultWas::ExpressionFailed:
+                        if( result.isOk() ) {
+                            colour = Colour::Success;
+                            passOrFail = "FAILED - but was ok";
+                        }
+                        else {
+                            colour = Colour::Error;
+                            passOrFail = "FAILED";
+                        }
+                        if( _stats.infoMessages.size() == 1 )
+                            messageLabel = "with message";
+                        if( _stats.infoMessages.size() > 1 )
+                            messageLabel = "with messages";
+                        break;
+                    case ResultWas::ThrewException:
+                        colour = Colour::Error;
+                        passOrFail = "FAILED";
+                        messageLabel = "due to unexpected exception with message";
+                        break;
+                    case ResultWas::DidntThrowException:
+                        colour = Colour::Error;
+                        passOrFail = "FAILED";
+                        messageLabel = "because no exception was thrown where one was expected";
+                        break;
+                    case ResultWas::Info:
+                        messageLabel = "info";
+                        break;
+                    case ResultWas::Warning:
+                        messageLabel = "warning";
+                        break;
+                    case ResultWas::ExplicitFailure:
+                        passOrFail = "FAILED";
+                        colour = Colour::Error;
+                        if( _stats.infoMessages.size() == 1 )
+                            messageLabel = "explicitly with message";
+                        if( _stats.infoMessages.size() > 1 )
+                            messageLabel = "explicitly with messages";
+                        break;
+                    // These cases are here to prevent compiler warnings
+                    case ResultWas::Unknown:
+                    case ResultWas::FailureBit:
+                    case ResultWas::Exception:
+                        passOrFail = "** internal error **";
+                        colour = Colour::Error;
+                        break;
+                }
+            }
+
+            void print() const {
+                printSourceInfo();
+                if( stats.totals.assertions.total() > 0 ) {
+                    if( result.isOk() )
+                        stream << "\n";
+                    printResultType();
+                    printOriginalExpression();
+                    printReconstructedExpression();
+                }
+                else {
+                    stream << "\n";
+                }
+                printMessage();
+            }
+
+        private:
+            void printResultType() const {
+                if( !passOrFail.empty() ) {
+                    Colour colourGuard( colour );
+                    stream << passOrFail << ":\n";
+                }
+            }
+            void printOriginalExpression() const {
+                if( result.hasExpression() ) {
+                    Colour colourGuard( Colour::OriginalExpression );
+                    stream  << "  ";
+                    stream << result.getExpressionInMacro();
+                    stream << "\n";
+                }
+            }
+            void printReconstructedExpression() const {
+                if( result.hasExpandedExpression() ) {
+                    stream << "with expansion:\n";
+                    Colour colourGuard( Colour::ReconstructedExpression );
+                    stream << Text( result.getExpandedExpression(), TextAttributes().setIndent(2) ) << "\n";
+                }
+            }
+            void printMessage() const {
+                if( !messageLabel.empty() )
+                    stream << messageLabel << ":" << "\n";
+                for( std::vector<MessageInfo>::const_iterator it = messages.begin(), itEnd = messages.end();
+                        it != itEnd;
+                        ++it ) {
+                    // If this assertion is a warning ignore any INFO messages
+                    if( printInfoMessages || it->type != ResultWas::Info )
+                        stream << Text( it->message, TextAttributes().setIndent(2) ) << "\n";
+                }
+            }
+            void printSourceInfo() const {
+                Colour colourGuard( Colour::FileName );
+                stream << result.getSourceInfo() << ": ";
+            }
+
+            std::ostream& stream;
+            AssertionStats const& stats;
+            AssertionResult const& result;
+            Colour::Code colour;
+            std::string passOrFail;
+            std::string messageLabel;
+            std::string message;
+            std::vector<MessageInfo> messages;
+            bool printInfoMessages;
+        };
+
+        void lazyPrint() {
+
+            if( !currentTestRunInfo.used )
+                lazyPrintRunInfo();
+            if( !currentGroupInfo.used )
+                lazyPrintGroupInfo();
+
+            if( !m_headerPrinted ) {
+                printTestCaseAndSectionHeader();
+                m_headerPrinted = true;
+            }
+        }
+        void lazyPrintRunInfo() {
+            stream  << "\n" << getLineOfChars<'~'>() << "\n";
+            Colour colour( Colour::SecondaryText );
+            stream  << currentTestRunInfo->name
+                    << " is a Catch v"  << libraryVersion.majorVersion << "."
+                    << libraryVersion.minorVersion << " b"
+                    << libraryVersion.buildNumber;
+            if( libraryVersion.branchName != std::string( "master" ) )
+                stream << " (" << libraryVersion.branchName << ")";
+            stream  << " host application.\n"
+                    << "Run with -? for options\n\n";
+
+            currentTestRunInfo.used = true;
+        }
+        void lazyPrintGroupInfo() {
+            if( !currentGroupInfo->name.empty() && currentGroupInfo->groupsCounts > 1 ) {
+                printClosedHeader( "Group: " + currentGroupInfo->name );
+                currentGroupInfo.used = true;
+            }
+        }
+        void printTestCaseAndSectionHeader() {
+            assert( !m_sectionStack.empty() );
+            printOpenHeader( currentTestCaseInfo->name );
+
+            if( m_sectionStack.size() > 1 ) {
+                Colour colourGuard( Colour::Headers );
+
+                std::vector<SectionInfo>::const_iterator
+                    it = m_sectionStack.begin()+1, // Skip first section (test case)
+                    itEnd = m_sectionStack.end();
+                for( ; it != itEnd; ++it )
+                    printHeaderString( it->name, 2 );
+            }
+
+            SourceLineInfo lineInfo = m_sectionStack.front().lineInfo;
+
+            if( !lineInfo.empty() ){
+                stream << getLineOfChars<'-'>() << "\n";
+                Colour colourGuard( Colour::FileName );
+                stream << lineInfo << "\n";
+            }
+            stream << getLineOfChars<'.'>() << "\n" << std::endl;
+        }
+
+        void printClosedHeader( std::string const& _name ) {
+            printOpenHeader( _name );
+            stream << getLineOfChars<'.'>() << "\n";
+        }
+        void printOpenHeader( std::string const& _name ) {
+            stream  << getLineOfChars<'-'>() << "\n";
+            {
+                Colour colourGuard( Colour::Headers );
+                printHeaderString( _name );
+            }
+        }
+
+        // if string has a : in first line will set indent to follow it on
+        // subsequent lines
+        void printHeaderString( std::string const& _string, std::size_t indent = 0 ) {
+            std::size_t i = _string.find( ": " );
+            if( i != std::string::npos )
+                i+=2;
+            else
+                i = 0;
+            stream << Text( _string, TextAttributes()
+                                        .setIndent( indent+i)
+                                        .setInitialIndent( indent ) ) << "\n";
+        }
+
+        struct SummaryColumn {
+
+            SummaryColumn( std::string const& _label, Colour::Code _colour )
+            :   label( _label ),
+                colour( _colour )
+            {}
+            SummaryColumn addRow( std::size_t count ) {
+                std::ostringstream oss;
+                oss << count;
+                std::string row = oss.str();
+                for( std::vector<std::string>::iterator it = rows.begin(); it != rows.end(); ++it ) {
+                    while( it->size() < row.size() )
+                        *it = " " + *it;
+                    while( it->size() > row.size() )
+                        row = " " + row;
+                }
+                rows.push_back( row );
+                return *this;
+            }
+
+            std::string label;
+            Colour::Code colour;
+            std::vector<std::string> rows;
+
+        };
+
+        void printTotals( Totals const& totals ) {
+            if( totals.testCases.total() == 0 ) {
+                stream << Colour( Colour::Warning ) << "No tests ran\n";
+            }
+            else if( totals.assertions.total() > 0 && totals.assertions.allPassed() ) {
+                stream << Colour( Colour::ResultSuccess ) << "All tests passed";
+                stream << " ("
+                        << pluralise( totals.assertions.passed, "assertion" ) << " in "
+                        << pluralise( totals.testCases.passed, "test case" ) << ")"
+                        << "\n";
+            }
+            else {
+
+                std::vector<SummaryColumn> columns;
+                columns.push_back( SummaryColumn( "", Colour::None )
+                                        .addRow( totals.testCases.total() )
+                                        .addRow( totals.assertions.total() ) );
+                columns.push_back( SummaryColumn( "passed", Colour::Success )
+                                        .addRow( totals.testCases.passed )
+                                        .addRow( totals.assertions.passed ) );
+                columns.push_back( SummaryColumn( "failed", Colour::ResultError )
+                                        .addRow( totals.testCases.failed )
+                                        .addRow( totals.assertions.failed ) );
+                columns.push_back( SummaryColumn( "failed as expected", Colour::ResultExpectedFailure )
+                                        .addRow( totals.testCases.failedButOk )
+                                        .addRow( totals.assertions.failedButOk ) );
+
+                printSummaryRow( "test cases", columns, 0 );
+                printSummaryRow( "assertions", columns, 1 );
+            }
+        }
+        void printSummaryRow( std::string const& label, std::vector<SummaryColumn> const& cols, std::size_t row ) {
+            for( std::vector<SummaryColumn>::const_iterator it = cols.begin(); it != cols.end(); ++it ) {
+                std::string value = it->rows[row];
+                if( it->label.empty() ) {
+                    stream << label << ": ";
+                    if( value != "0" )
+                        stream << value;
+                    else
+                        stream << Colour( Colour::Warning ) << "- none -";
+                }
+                else if( value != "0" ) {
+                    stream  << Colour( Colour::LightGrey ) << " | ";
+                    stream  << Colour( it->colour )
+                            << value << " " << it->label;
+                }
+            }
+            stream << "\n";
+        }
+
+        static std::size_t makeRatio( std::size_t number, std::size_t total ) {
+            std::size_t ratio = total > 0 ? CATCH_CONFIG_CONSOLE_WIDTH * number/ total : 0;
+            return ( ratio == 0 && number > 0 ) ? 1 : ratio;
+        }
+        static std::size_t& findMax( std::size_t& i, std::size_t& j, std::size_t& k ) {
+            if( i > j && i > k )
+                return i;
+            else if( j > k )
+                return j;
+            else
+                return k;
+        }
+
+        void printTotalsDivider( Totals const& totals ) {
+            if( totals.testCases.total() > 0 ) {
+                std::size_t failedRatio = makeRatio( totals.testCases.failed, totals.testCases.total() );
+                std::size_t failedButOkRatio = makeRatio( totals.testCases.failedButOk, totals.testCases.total() );
+                std::size_t passedRatio = makeRatio( totals.testCases.passed, totals.testCases.total() );
+                while( failedRatio + failedButOkRatio + passedRatio < CATCH_CONFIG_CONSOLE_WIDTH-1 )
+                    findMax( failedRatio, failedButOkRatio, passedRatio )++;
+                while( failedRatio + failedButOkRatio + passedRatio > CATCH_CONFIG_CONSOLE_WIDTH-1 )
+                    findMax( failedRatio, failedButOkRatio, passedRatio )--;
+
+                stream << Colour( Colour::Error ) << std::string( failedRatio, '=' );
+                stream << Colour( Colour::ResultExpectedFailure ) << std::string( failedButOkRatio, '=' );
+                if( totals.testCases.allPassed() )
+                    stream << Colour( Colour::ResultSuccess ) << std::string( passedRatio, '=' );
+                else
+                    stream << Colour( Colour::Success ) << std::string( passedRatio, '=' );
+            }
+            else {
+                stream << Colour( Colour::Warning ) << std::string( CATCH_CONFIG_CONSOLE_WIDTH-1, '=' );
+            }
+            stream << "\n";
+        }
+        void printSummaryDivider() {
+            stream << getLineOfChars<'-'>() << "\n";
+        }
+        template<char C>
+        static char const* getLineOfChars() {
+            static char line[CATCH_CONFIG_CONSOLE_WIDTH] = {0};
+            if( !*line ) {
+                memset( line, C, CATCH_CONFIG_CONSOLE_WIDTH-1 );
+                line[CATCH_CONFIG_CONSOLE_WIDTH-1] = 0;
+            }
+            return line;
+        }
+
+    private:
+        bool m_headerPrinted;
+    };
+
+    INTERNAL_CATCH_REGISTER_REPORTER( "console", ConsoleReporter )
+
+} // end namespace Catch
+
+// #included from: ../reporters/catch_reporter_compact.hpp
+#define TWOBLUECUBES_CATCH_REPORTER_COMPACT_HPP_INCLUDED
+
+namespace Catch {
+
+    struct CompactReporter : StreamingReporterBase {
+
+        CompactReporter( ReporterConfig const& _config )
+        : StreamingReporterBase( _config )
+        {}
+
+        virtual ~CompactReporter();
+
+        static std::string getDescription() {
+            return "Reports test results on a single line, suitable for IDEs";
+        }
+
+        virtual ReporterPreferences getPreferences() const {
+            ReporterPreferences prefs;
+            prefs.shouldRedirectStdOut = false;
+            return prefs;
+        }
+
+        virtual void noMatchingTestCases( std::string const& spec ) {
+            stream << "No test cases matched '" << spec << "'" << std::endl;
+        }
+
+        virtual void assertionStarting( AssertionInfo const& ) {
+        }
+
+        virtual bool assertionEnded( AssertionStats const& _assertionStats ) {
+            AssertionResult const& result = _assertionStats.assertionResult;
+
+            bool printInfoMessages = true;
+
+            // Drop out if result was successful and we're not printing those
+            if( !m_config->includeSuccessfulResults() && result.isOk() ) {
+                if( result.getResultType() != ResultWas::Warning )
+                    return false;
+                printInfoMessages = false;
+            }
+
+            AssertionPrinter printer( stream, _assertionStats, printInfoMessages );
+            printer.print();
+
+            stream << std::endl;
+            return true;
+        }
+
+        virtual void testRunEnded( TestRunStats const& _testRunStats ) {
+            printTotals( _testRunStats.totals );
+            stream << "\n" << std::endl;
+            StreamingReporterBase::testRunEnded( _testRunStats );
+        }
+
+    private:
+        class AssertionPrinter {
+            void operator= ( AssertionPrinter const& );
+        public:
+            AssertionPrinter( std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages )
+            : stream( _stream )
+            , stats( _stats )
+            , result( _stats.assertionResult )
+            , messages( _stats.infoMessages )
+            , itMessage( _stats.infoMessages.begin() )
+            , printInfoMessages( _printInfoMessages )
+            {}
+
+            void print() {
+                printSourceInfo();
+
+                itMessage = messages.begin();
+
+                switch( result.getResultType() ) {
+                    case ResultWas::Ok:
+                        printResultType( Colour::ResultSuccess, passedString() );
+                        printOriginalExpression();
+                        printReconstructedExpression();
+                        if ( ! result.hasExpression() )
+                            printRemainingMessages( Colour::None );
+                        else
+                            printRemainingMessages();
+                        break;
+                    case ResultWas::ExpressionFailed:
+                        if( result.isOk() )
+                            printResultType( Colour::ResultSuccess, failedString() + std::string( " - but was ok" ) );
+                        else
+                            printResultType( Colour::Error, failedString() );
+                        printOriginalExpression();
+                        printReconstructedExpression();
+                        printRemainingMessages();
+                        break;
+                    case ResultWas::ThrewException:
+                        printResultType( Colour::Error, failedString() );
+                        printIssue( "unexpected exception with message:" );
+                        printMessage();
+                        printExpressionWas();
+                        printRemainingMessages();
+                        break;
+                    case ResultWas::DidntThrowException:
+                        printResultType( Colour::Error, failedString() );
+                        printIssue( "expected exception, got none" );
+                        printExpressionWas();
+                        printRemainingMessages();
+                        break;
+                    case ResultWas::Info:
+                        printResultType( Colour::None, "info" );
+                        printMessage();
+                        printRemainingMessages();
+                        break;
+                    case ResultWas::Warning:
+                        printResultType( Colour::None, "warning" );
+                        printMessage();
+                        printRemainingMessages();
+                        break;
+                    case ResultWas::ExplicitFailure:
+                        printResultType( Colour::Error, failedString() );
+                        printIssue( "explicitly" );
+                        printRemainingMessages( Colour::None );
+                        break;
+                    // These cases are here to prevent compiler warnings
+                    case ResultWas::Unknown:
+                    case ResultWas::FailureBit:
+                    case ResultWas::Exception:
+                        printResultType( Colour::Error, "** internal error **" );
+                        break;
+                }
+            }
+
+        private:
+            // Colour::LightGrey
+
+            static Colour::Code dimColour() { return Colour::FileName; }
+
+#ifdef CATCH_PLATFORM_MAC
+            static const char* failedString() { return "FAILED"; }
+            static const char* passedString() { return "PASSED"; }
+#else
+            static const char* failedString() { return "failed"; }
+            static const char* passedString() { return "passed"; }
+#endif
+
+            void printSourceInfo() const {
+                Colour colourGuard( Colour::FileName );
+                stream << result.getSourceInfo() << ":";
+            }
+
+            void printResultType( Colour::Code colour, std::string passOrFail ) const {
+                if( !passOrFail.empty() ) {
+                    {
+                        Colour colourGuard( colour );
+                        stream << " " << passOrFail;
+                    }
+                    stream << ":";
+                }
+            }
+
+            void printIssue( std::string issue ) const {
+                stream << " " << issue;
+            }
+
+            void printExpressionWas() {
+                if( result.hasExpression() ) {
+                    stream << ";";
+                    {
+                        Colour colour( dimColour() );
+                        stream << " expression was:";
+                    }
+                    printOriginalExpression();
+                }
+            }
+
+            void printOriginalExpression() const {
+                if( result.hasExpression() ) {
+                    stream << " " << result.getExpression();
+                }
+            }
+
+            void printReconstructedExpression() const {
+                if( result.hasExpandedExpression() ) {
+                    {
+                        Colour colour( dimColour() );
+                        stream << " for: ";
+                    }
+                    stream << result.getExpandedExpression();
+                }
+            }
+
+            void printMessage() {
+                if ( itMessage != messages.end() ) {
+                    stream << " '" << itMessage->message << "'";
+                    ++itMessage;
+                }
+            }
+
+            void printRemainingMessages( Colour::Code colour = dimColour() ) {
+                if ( itMessage == messages.end() )
+                    return;
+
+                // using messages.end() directly yields compilation error:
+                std::vector<MessageInfo>::const_iterator itEnd = messages.end();
+                const std::size_t N = static_cast<std::size_t>( std::distance( itMessage, itEnd ) );
+
+                {
+                    Colour colourGuard( colour );
+                    stream << " with " << pluralise( N, "message" ) << ":";
+                }
+
+                for(; itMessage != itEnd; ) {
+                    // If this assertion is a warning ignore any INFO messages
+                    if( printInfoMessages || itMessage->type != ResultWas::Info ) {
+                        stream << " '" << itMessage->message << "'";
+                        if ( ++itMessage != itEnd ) {
+                            Colour colourGuard( dimColour() );
+                            stream << " and";
+                        }
+                    }
+                }
+            }
+
+        private:
+            std::ostream& stream;
+            AssertionStats const& stats;
+            AssertionResult const& result;
+            std::vector<MessageInfo> messages;
+            std::vector<MessageInfo>::const_iterator itMessage;
+            bool printInfoMessages;
+        };
+
+        // Colour, message variants:
+        // - white: No tests ran.
+        // -   red: Failed [both/all] N test cases, failed [both/all] M assertions.
+        // - white: Passed [both/all] N test cases (no assertions).
+        // -   red: Failed N tests cases, failed M assertions.
+        // - green: Passed [both/all] N tests cases with M assertions.
+
+        std::string bothOrAll( std::size_t count ) const {
+            return count == 1 ? "" : count == 2 ? "both " : "all " ;
+        }
+
+        void printTotals( const Totals& totals ) const {
+            if( totals.testCases.total() == 0 ) {
+                stream << "No tests ran.";
+            }
+            else if( totals.testCases.failed == totals.testCases.total() ) {
+                Colour colour( Colour::ResultError );
+                const std::string qualify_assertions_failed =
+                    totals.assertions.failed == totals.assertions.total() ?
+                        bothOrAll( totals.assertions.failed ) : "";
+                stream <<
+                    "Failed " << bothOrAll( totals.testCases.failed )
+                              << pluralise( totals.testCases.failed, "test case"  ) << ", "
+                    "failed " << qualify_assertions_failed <<
+                                 pluralise( totals.assertions.failed, "assertion" ) << ".";
+            }
+            else if( totals.assertions.total() == 0 ) {
+                stream <<
+                    "Passed " << bothOrAll( totals.testCases.total() )
+                              << pluralise( totals.testCases.total(), "test case" )
+                              << " (no assertions).";
+            }
+            else if( totals.assertions.failed ) {
+                Colour colour( Colour::ResultError );
+                stream <<
+                    "Failed " << pluralise( totals.testCases.failed, "test case"  ) << ", "
+                    "failed " << pluralise( totals.assertions.failed, "assertion" ) << ".";
+            }
+            else {
+                Colour colour( Colour::ResultSuccess );
+                stream <<
+                    "Passed " << bothOrAll( totals.testCases.passed )
+                              << pluralise( totals.testCases.passed, "test case"  ) <<
+                    " with "  << pluralise( totals.assertions.passed, "assertion" ) << ".";
+            }
+        }
+    };
+
+    INTERNAL_CATCH_REGISTER_REPORTER( "compact", CompactReporter )
+
+} // end namespace Catch
+
+namespace Catch {
+    NonCopyable::~NonCopyable() {}
+    IShared::~IShared() {}
+    StreamBufBase::~StreamBufBase() CATCH_NOEXCEPT {}
+    IContext::~IContext() {}
+    IResultCapture::~IResultCapture() {}
+    ITestCase::~ITestCase() {}
+    ITestCaseRegistry::~ITestCaseRegistry() {}
+    IRegistryHub::~IRegistryHub() {}
+    IMutableRegistryHub::~IMutableRegistryHub() {}
+    IExceptionTranslator::~IExceptionTranslator() {}
+    IExceptionTranslatorRegistry::~IExceptionTranslatorRegistry() {}
+    IReporter::~IReporter() {}
+    IReporterFactory::~IReporterFactory() {}
+    IReporterRegistry::~IReporterRegistry() {}
+    IStreamingReporter::~IStreamingReporter() {}
+    AssertionStats::~AssertionStats() {}
+    SectionStats::~SectionStats() {}
+    TestCaseStats::~TestCaseStats() {}
+    TestGroupStats::~TestGroupStats() {}
+    TestRunStats::~TestRunStats() {}
+    CumulativeReporterBase::SectionNode::~SectionNode() {}
+    CumulativeReporterBase::~CumulativeReporterBase() {}
+
+    StreamingReporterBase::~StreamingReporterBase() {}
+    ConsoleReporter::~ConsoleReporter() {}
+    CompactReporter::~CompactReporter() {}
+    IRunner::~IRunner() {}
+    IMutableContext::~IMutableContext() {}
+    IConfig::~IConfig() {}
+    XmlReporter::~XmlReporter() {}
+    JunitReporter::~JunitReporter() {}
+    TestRegistry::~TestRegistry() {}
+    FreeFunctionTestCase::~FreeFunctionTestCase() {}
+    IGeneratorInfo::~IGeneratorInfo() {}
+    IGeneratorsForTest::~IGeneratorsForTest() {}
+    TestSpec::Pattern::~Pattern() {}
+    TestSpec::NamePattern::~NamePattern() {}
+    TestSpec::TagPattern::~TagPattern() {}
+    TestSpec::ExcludedPattern::~ExcludedPattern() {}
+
+    Matchers::Impl::StdString::Equals::~Equals() {}
+    Matchers::Impl::StdString::Contains::~Contains() {}
+    Matchers::Impl::StdString::StartsWith::~StartsWith() {}
+    Matchers::Impl::StdString::EndsWith::~EndsWith() {}
+
+    void Config::dummy() {}
+
+    INTERNAL_CATCH_REGISTER_LEGACY_REPORTER( "xml", XmlReporter )
+}
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+#endif
+
+#ifdef CATCH_CONFIG_MAIN
+// #included from: internal/catch_default_main.hpp
+#define TWOBLUECUBES_CATCH_DEFAULT_MAIN_HPP_INCLUDED
+
+#ifndef __OBJC__
+
+// Standard C/C++ main entry point
+int main (int argc, char * const argv[]) {
+    return Catch::Session().run( argc, argv );
+}
+
+#else // __OBJC__
+
+// Objective-C entry point
+int main (int argc, char * const argv[]) {
+#if !CATCH_ARC_ENABLED
+    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
+#endif
+
+    Catch::registerTestMethods();
+    int result = Catch::Session().run( argc, (char* const*)argv );
+
+#if !CATCH_ARC_ENABLED
+    [pool drain];
+#endif
+
+    return result;
+}
+
+#endif // __OBJC__
+
+#endif
+
+#ifdef CLARA_CONFIG_MAIN_NOT_DEFINED
+#  undef CLARA_CONFIG_MAIN
+#endif
+
+//////
+
+// If this config identifier is defined then all CATCH macros are prefixed with CATCH_
+#ifdef CATCH_CONFIG_PREFIX_ALL
+
+#define CATCH_REQUIRE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::Normal, "CATCH_REQUIRE" )
+#define CATCH_REQUIRE_FALSE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, "CATCH_REQUIRE_FALSE" )
+
+#define CATCH_REQUIRE_THROWS( expr ) INTERNAL_CATCH_THROWS( expr, Catch::ResultDisposition::Normal, "CATCH_REQUIRE_THROWS" )
+#define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( expr, exceptionType, Catch::ResultDisposition::Normal, "CATCH_REQUIRE_THROWS_AS" )
+#define CATCH_REQUIRE_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( expr, Catch::ResultDisposition::Normal, "CATCH_REQUIRE_NOTHROW" )
+
+#define CATCH_CHECK( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK" )
+#define CATCH_CHECK_FALSE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, "CATCH_CHECK_FALSE" )
+#define CATCH_CHECKED_IF( expr ) INTERNAL_CATCH_IF( expr, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECKED_IF" )
+#define CATCH_CHECKED_ELSE( expr ) INTERNAL_CATCH_ELSE( expr, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECKED_ELSE" )
+#define CATCH_CHECK_NOFAIL( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, "CATCH_CHECK_NOFAIL" )
+
+#define CATCH_CHECK_THROWS( expr )  INTERNAL_CATCH_THROWS( expr, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK_THROWS" )
+#define CATCH_CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( expr, exceptionType, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK_THROWS_AS" )
+#define CATCH_CHECK_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( expr, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK_NOTHROW" )
+
+#define CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( arg, matcher, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK_THAT" )
+#define CATCH_REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( arg, matcher, Catch::ResultDisposition::Normal, "CATCH_REQUIRE_THAT" )
+
+#define CATCH_INFO( msg ) INTERNAL_CATCH_INFO( msg, "CATCH_INFO" )
+#define CATCH_WARN( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, "CATCH_WARN", msg )
+#define CATCH_SCOPED_INFO( msg ) INTERNAL_CATCH_INFO( msg, "CATCH_INFO" )
+#define CATCH_CAPTURE( msg ) INTERNAL_CATCH_INFO( #msg " := " << msg, "CATCH_CAPTURE" )
+#define CATCH_SCOPED_CAPTURE( msg ) INTERNAL_CATCH_INFO( #msg " := " << msg, "CATCH_CAPTURE" )
+
+#ifdef CATCH_CONFIG_VARIADIC_MACROS
+    #define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
+    #define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
+    #define CATCH_METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
+    #define CATCH_SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
+    #define CATCH_FAIL( ... ) INTERNAL_CATCH_MSG( Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, "CATCH_FAIL", __VA_ARGS__ )
+    #define CATCH_SUCCEED( ... ) INTERNAL_CATCH_MSG( Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, "CATCH_SUCCEED", __VA_ARGS__ )
+#else
+    #define CATCH_TEST_CASE( name, description ) INTERNAL_CATCH_TESTCASE( name, description )
+    #define CATCH_TEST_CASE_METHOD( className, name, description ) INTERNAL_CATCH_TEST_CASE_METHOD( className, name, description )
+    #define CATCH_METHOD_AS_TEST_CASE( method, name, description ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, name, description )
+    #define CATCH_SECTION( name, description ) INTERNAL_CATCH_SECTION( name, description )
+    #define CATCH_FAIL( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, "CATCH_FAIL", msg )
+    #define CATCH_SUCCEED( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, "CATCH_SUCCEED", msg )
+#endif
+#define CATCH_ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE( "", "" )
+
+#define CATCH_REGISTER_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_REPORTER( name, reporterType )
+#define CATCH_REGISTER_LEGACY_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_LEGACY_REPORTER( name, reporterType )
+
+#define CATCH_GENERATE( expr) INTERNAL_CATCH_GENERATE( expr )
+
+// "BDD-style" convenience wrappers
+#ifdef CATCH_CONFIG_VARIADIC_MACROS
+#define CATCH_SCENARIO( ... ) CATCH_TEST_CASE( "Scenario: " __VA_ARGS__ )
+#define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
+#else
+#define CATCH_SCENARIO( name, tags ) CATCH_TEST_CASE( "Scenario: " name, tags )
+#define CATCH_SCENARIO_METHOD( className, name, tags ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " name, tags )
+#endif
+#define CATCH_GIVEN( desc )    CATCH_SECTION( "Given: " desc, "" )
+#define CATCH_WHEN( desc )     CATCH_SECTION( " When: " desc, "" )
+#define CATCH_AND_WHEN( desc ) CATCH_SECTION( "  And: " desc, "" )
+#define CATCH_THEN( desc )     CATCH_SECTION( " Then: " desc, "" )
+#define CATCH_AND_THEN( desc ) CATCH_SECTION( "  And: " desc, "" )
+
+// If CATCH_CONFIG_PREFIX_ALL is not defined then the CATCH_ prefix is not required
+#else
+
+#define REQUIRE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::Normal, "REQUIRE" )
+#define REQUIRE_FALSE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, "REQUIRE_FALSE" )
+
+#define REQUIRE_THROWS( expr ) INTERNAL_CATCH_THROWS( expr, Catch::ResultDisposition::Normal, "REQUIRE_THROWS" )
+#define REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( expr, exceptionType, Catch::ResultDisposition::Normal, "REQUIRE_THROWS_AS" )
+#define REQUIRE_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( expr, Catch::ResultDisposition::Normal, "REQUIRE_NOTHROW" )
+
+#define CHECK( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure, "CHECK" )
+#define CHECK_FALSE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, "CHECK_FALSE" )
+#define CHECKED_IF( expr ) INTERNAL_CATCH_IF( expr, Catch::ResultDisposition::ContinueOnFailure, "CHECKED_IF" )
+#define CHECKED_ELSE( expr ) INTERNAL_CATCH_ELSE( expr, Catch::ResultDisposition::ContinueOnFailure, "CHECKED_ELSE" )
+#define CHECK_NOFAIL( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, "CHECK_NOFAIL" )
+
+#define CHECK_THROWS( expr )  INTERNAL_CATCH_THROWS( expr, Catch::ResultDisposition::ContinueOnFailure, "CHECK_THROWS" )
+#define CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( expr, exceptionType, Catch::ResultDisposition::ContinueOnFailure, "CHECK_THROWS_AS" )
+#define CHECK_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( expr, Catch::ResultDisposition::ContinueOnFailure, "CHECK_NOTHROW" )
+
+#define CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( arg, matcher, Catch::ResultDisposition::ContinueOnFailure, "CHECK_THAT" )
+#define REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( arg, matcher, Catch::ResultDisposition::Normal, "REQUIRE_THAT" )
+
+#define INFO( msg ) INTERNAL_CATCH_INFO( msg, "INFO" )
+#define WARN( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, "WARN", msg )
+#define SCOPED_INFO( msg ) INTERNAL_CATCH_INFO( msg, "INFO" )
+#define CAPTURE( msg ) INTERNAL_CATCH_INFO( #msg " := " << msg, "CAPTURE" )
+#define SCOPED_CAPTURE( msg ) INTERNAL_CATCH_INFO( #msg " := " << msg, "CAPTURE" )
+
+#ifdef CATCH_CONFIG_VARIADIC_MACROS
+    #define TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
+    #define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
+    #define METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
+    #define SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
+    #define FAIL( ... ) INTERNAL_CATCH_MSG( Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, "FAIL", __VA_ARGS__ )
+    #define SUCCEED( ... ) INTERNAL_CATCH_MSG( Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, "SUCCEED", __VA_ARGS__ )
+#else
+    #define TEST_CASE( name, description ) INTERNAL_CATCH_TESTCASE( name, description )
+    #define TEST_CASE_METHOD( className, name, description ) INTERNAL_CATCH_TEST_CASE_METHOD( className, name, description )
+    #define METHOD_AS_TEST_CASE( method, name, description ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, name, description )
+    #define SECTION( name, description ) INTERNAL_CATCH_SECTION( name, description )
+    #define FAIL( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, "FAIL", msg )
+    #define SUCCEED( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, "SUCCEED", msg )
+#endif
+#define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE( "", "" )
+
+#define REGISTER_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_REPORTER( name, reporterType )
+#define REGISTER_LEGACY_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_LEGACY_REPORTER( name, reporterType )
+
+#define GENERATE( expr) INTERNAL_CATCH_GENERATE( expr )
+
+#endif
+
+#define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature )
+
+// "BDD-style" convenience wrappers
+#ifdef CATCH_CONFIG_VARIADIC_MACROS
+#define SCENARIO( ... ) TEST_CASE( "Scenario: " __VA_ARGS__ )
+#define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
+#else
+#define SCENARIO( name, tags ) TEST_CASE( "Scenario: " name, tags )
+#define SCENARIO_METHOD( className, name, tags ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " name, tags )
+#endif
+#define GIVEN( desc )    SECTION( "   Given: " desc, "" )
+#define WHEN( desc )     SECTION( "    When: " desc, "" )
+#define AND_WHEN( desc ) SECTION( "And when: " desc, "" )
+#define THEN( desc )     SECTION( "    Then: " desc, "" )
+#define AND_THEN( desc ) SECTION( "     And: " desc, "" )
+
+using Catch::Detail::Approx;
+
+// #included from: internal/catch_reenable_warnings.h
+
+#define TWOBLUECUBES_CATCH_REENABLE_WARNINGS_H_INCLUDED
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#elif defined __GNUC__
+#pragma GCC diagnostic pop
+#endif
+
+#endif // TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
+

From e02a28aab85d95604525752de03383355367ba04 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 13 Nov 2014 09:12:41 -0500
Subject: [PATCH 0549/1866] Adds catch test for range *makefile to be replaced

---
 catchtest/Makefile           |  13 ++++
 catchtest/run_test_range.cpp |   2 +
 catchtest/test_range.cpp     | 140 +++++++++++++++++++++++++++++++++++
 3 files changed, 155 insertions(+)
 create mode 100644 catchtest/Makefile
 create mode 100644 catchtest/run_test_range.cpp
 create mode 100644 catchtest/test_range.cpp

diff --git a/catchtest/Makefile b/catchtest/Makefile
new file mode 100644
index 00000000..c3ba6c57
--- /dev/null
+++ b/catchtest/Makefile
@@ -0,0 +1,13 @@
+CXX = g++
+CXXFLAGS = -Wall -Wextra -pedantic -std=c++11
+CPPFLAGS = -I..
+LINK.o = $(CXX)
+
+all: test_range
+
+test_range: test_range.o run_test_range.o
+
+test_range.o: test_range.cpp 
+
+clean:
+	rm -f test_range *.o
diff --git a/catchtest/run_test_range.cpp b/catchtest/run_test_range.cpp
new file mode 100644
index 00000000..0c7c351f
--- /dev/null
+++ b/catchtest/run_test_range.cpp
@@ -0,0 +1,2 @@
+#define CATCH_CONFIG_MAIN
+#include "catch.hpp"
diff --git a/catchtest/test_range.cpp b/catchtest/test_range.cpp
new file mode 100644
index 00000000..7c853595
--- /dev/null
+++ b/catchtest/test_range.cpp
@@ -0,0 +1,140 @@
+#include "range.hpp"
+
+#include <vector>
+#include <iterator>
+#include <algorithm>
+
+#include "catch.hpp"
+
+using Vec = const std::vector<int>;
+using iter::range;
+
+
+TEST_CASE("Range works with only stop", "[range]") {
+    auto r = range(5);
+    Vec v(std::begin(r), std::end(r));
+    Vec vc{0, 1, 2, 3, 4};
+
+    REQUIRE( v == vc );
+}
+
+TEST_CASE("Range works with start and stop", "[range]") {
+    auto r = range(1, 5);
+    Vec v(std::begin(r), std::end(r));
+    Vec vc {1, 2, 3, 4};
+
+    REQUIRE( v == vc );
+}
+
+TEST_CASE("Range works with positive step > 1", "[range]") {
+    auto r = range(1, 10, 3);
+    Vec v(std::begin(r), std::end(r));
+    Vec vc{1, 4, 7};
+
+    REQUIRE( v == vc );
+}
+
+TEST_CASE("range(0) is empty", "[range]") {
+    auto r = iter::range(0);
+    Vec v(std::begin(r), std::end(r));
+    REQUIRE( v.empty() );
+}
+
+TEST_CASE("start > stop produces empty range", "[range]") {
+    auto r = range(5, 0);
+    Vec v(std::begin(r), std::end(r));
+    REQUIRE( v.empty() );
+}
+
+TEST_CASE("start < stop and step < 0 produces empty range", "[range]") {
+    auto r = range(0, 5, -1);
+    Vec v(std::begin(r), std::end(r));
+    REQUIRE( v.empty() );
+}
+
+TEST_CASE("Range with only a negative stop is empty", "[range]") {
+    auto r = range(-3);
+    Vec v(std::begin(r), std::end(r));
+
+    REQUIRE( v.empty() );
+}
+
+TEST_CASE("Range works with negative step", "[range]") {
+    auto r = range(5, -5, -3);
+    Vec v(std::begin(r), std::end(r));
+    Vec vc{5, 2, -1, -4};
+
+    REQUIRE( v == vc );
+}
+
+TEST_CASE("Range stops short when step doesn't divide stop-start", "[range]") {
+    auto r = range(0, 5, 2);
+    Vec v(std::begin(r), std::end(r));
+    Vec vc{0, 2, 4};
+
+    REQUIRE( v == vc );
+
+}
+
+TEST_CASE("Range stops short when step > stop-start", "[range]") {
+    auto r = range(0, 10, 20);
+    Vec v(std::begin(r), std::end(r));
+    REQUIRE( v.size() == 1 );
+}
+
+TEST_CASE("No 0 step ranges allowed", "[range]") {
+    REQUIRE_THROWS(range(0, 1, 0));
+}
+
+TEST_CASE("Range works with a variable start, stop, and step", "[range]") {
+    constexpr int a = 10;
+    constexpr int b = 100;
+    constexpr int c = 50;
+    SECTION("Going up works") {
+        auto r = range(a, a+2);
+        Vec v(std::begin(r), std::end(r));
+        Vec vc{a, a+1};
+        REQUIRE( v == vc );
+    }
+
+    SECTION("Going down works") {
+        auto r = range(a+2, a, -1);
+        Vec v(std::begin(r), std::end(r));
+        Vec vc{a+2, a+1};
+        REQUIRE( v == vc );
+    }
+
+    SECTION("Going down with -2 stop works") {
+        auto r = range(a+4, a, -2);
+        Vec v(std::begin(r), std::end(r));
+        Vec vc{a+4, a+2};
+        REQUIRE( v == vc );
+    }
+
+    SECTION("Using three variable") {
+        auto r = range(a, b, c);
+        Vec v(std::begin(r), std::end(r));
+        REQUIRE( std::find(std::begin(v), std::end(v), a) != std::end(v) );
+        REQUIRE( std::find(std::begin(v), std::end(v), b) == std::end(v) );
+        REQUIRE( v.size() == 2 );
+    }
+
+    SECTION("Using three with a unary negate on step") {
+        auto r = range(b, a, -c);
+        Vec v(std::begin(r), std::end(r));
+
+        REQUIRE( std::find(std::begin(v), std::end(v), b) != std::end(v) );
+        REQUIRE( std::find(std::begin(v), std::end(v), a) == std::end(v) );
+        REQUIRE( v.size() == 2 );
+    }
+
+    SECTION("Using all three negated") {
+        auto r = range(-a, -b, -c);
+        Vec v(std::begin(r), std::end(r));
+
+        REQUIRE( std::find(std::begin(v), std::end(v), -a) != std::end(v) );
+        REQUIRE( std::find(std::begin(v), std::end(v), -b) == std::end(v) );
+        REQUIRE( v.size() == 2 );
+    }
+
+}

From 15e0a89e12b3e7b4bd8120d66aa3e622ffb8a2e7 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 13 Nov 2014 10:58:27 -0500
Subject: [PATCH 0550/1866] Has IterYeild inherit from pair

I feel this may be a controversial decision, but if I had the chance I'd
probably go back to when I first made the enumerate decision and replace
IterYield with a pair completely.  index and element are just "aliases"
for the data members in pair
---
 enumerate.hpp | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index 52ee3db5..cb798363 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -43,6 +43,9 @@ namespace iter {
             friend Enumerable<std::initializer_list<T>> enumerate(
                     std::initializer_list<T>);
 
+            // for IterYield
+            using BasePair = std::pair<std::size_t, iterator_deref<Container>> ;
+
             // Value constructor for use only in the enumerate function
             Enumerable(Container container)
                 : container(std::forward<Container>(container))
@@ -51,14 +54,11 @@ namespace iter {
         public:
             // "yielded" by the Enumerable::Iterator.  Has a .index, and a 
             // .element referencing the value yielded by the subiterator
-            class IterYield {
+            class IterYield : public BasePair {
                 public:
-                    std::size_t index;
-                    iterator_deref<Container> element;
-                    IterYield(std::size_t i, iterator_deref<Container> elem)
-                        : index{i},
-                        element{elem}
-                    { }
+                    using BasePair::BasePair;
+                    decltype(BasePair::first)& index = BasePair::first;
+                    decltype(BasePair::second)& element = BasePair::second;
             };
 
             //  Holds an iterator of the contained type and a size_t for the

From bd3e652afb1610df62729738642eef5708292109 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 13 Nov 2014 11:00:36 -0500
Subject: [PATCH 0551/1866] enumerate iterator marked as forward_iterator

---
 enumerate.hpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index cb798363..659d2c0a 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -44,7 +44,7 @@ namespace iter {
                     std::initializer_list<T>);
 
             // for IterYield
-            using BasePair = std::pair<std::size_t, iterator_deref<Container>> ;
+            using BasePair = std::pair<std::size_t, iterator_deref<Container>>;
 
             // Value constructor for use only in the enumerate function
             Enumerable(Container container)
@@ -64,7 +64,9 @@ namespace iter {
             //  Holds an iterator of the contained type and a size_t for the
             //  index.  Each call to ++ increments both of these data members.
             //  Each dereference returns an IterYield.
-            class Iterator {
+            class Iterator :
+                public std::iterator<std::forward_iterator_tag, IterYield>
+            {
                 private:
                     iterator_type<Container> sub_iter;
                     std::size_t index;

From 62ab6c4cc369bd65d94bdd0e40762e114d306de1 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 13 Nov 2014 11:44:49 -0500
Subject: [PATCH 0552/1866] removes run_test_range.cpp

---
 catchtest/run_test_range.cpp | 2 --
 1 file changed, 2 deletions(-)
 delete mode 100644 catchtest/run_test_range.cpp

diff --git a/catchtest/run_test_range.cpp b/catchtest/run_test_range.cpp
deleted file mode 100644
index 0c7c351f..00000000
--- a/catchtest/run_test_range.cpp
+++ /dev/null
@@ -1,2 +0,0 @@
-#define CATCH_CONFIG_MAIN
-#include "catch.hpp"

From 5d81b565bfeea445c4bf0fc803fe9b3dd450d6b2 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 13 Nov 2014 11:45:39 -0500
Subject: [PATCH 0553/1866] range iterator marked as forward iterator

---
 range.hpp | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/range.hpp b/range.hpp
index 53752a3f..95ed6d8d 100644
--- a/range.hpp
+++ b/range.hpp
@@ -17,6 +17,7 @@
 
 #include <exception>
 #include <type_traits>
+#include <iterator>
 
 namespace iter {
 
@@ -63,7 +64,9 @@ namespace iter {
         public:
             Range() = delete;
             Range(const Range&) = default;
-            class Iterator {
+            class Iterator :
+                public std::iterator<std::forward_iterator_tag, T>
+            {
                 private:
                     T value;
                     T step;

From 72a711e7af0354b1ba7a9e4d4738464bfe830422 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 13 Nov 2014 11:46:09 -0500
Subject: [PATCH 0554/1866] Adds basic catch test for enumerate

---
 catchtest/Makefile           | 11 ++++++-----
 catchtest/test_enumerate.cpp | 27 +++++++++++++++++++++++++++
 catchtest/test_main.cpp      |  2 ++
 3 files changed, 35 insertions(+), 5 deletions(-)
 create mode 100644 catchtest/test_enumerate.cpp
 create mode 100644 catchtest/test_main.cpp

diff --git a/catchtest/Makefile b/catchtest/Makefile
index c3ba6c57..6e26db78 100644
--- a/catchtest/Makefile
+++ b/catchtest/Makefile
@@ -1,13 +1,14 @@
 CXX = g++
-CXXFLAGS = -Wall -Wextra -pedantic -std=c++11
+CXXFLAGS = -Wall -Wextra -pedantic -std=c++11 -fdiagnostics-color=auto
 CPPFLAGS = -I..
 LINK.o = $(CXX)
 
-all: test_range
+all: test_main
 
-test_range: test_range.o run_test_range.o
+test_main: test_main.o test_range.o test_enumerate.o
 
-test_range.o: test_range.cpp 
+test_range.o: test_range.cpp ../range.hpp
+test_enumerate.o: test_enumerate.cpp ../enumerate.hpp
 
 clean:
-	rm -f test_range *.o
+	rm -f test_main *.o
diff --git a/catchtest/test_enumerate.cpp b/catchtest/test_enumerate.cpp
new file mode 100644
index 00000000..c6253e9f
--- /dev/null
+++ b/catchtest/test_enumerate.cpp
@@ -0,0 +1,27 @@
+#include <enumerate.hpp>
+
+#include <vector>
+#include <string>
+#include <iterator>
+#include <utility>
+
+#include "catch.hpp"
+
+using Vec = std::vector<std::pair<std::size_t, char>>;
+using iter::enumerate;
+
+TEST_CASE("Basic Function", "[enumerate]") {
+    std::string str = "abc";
+    auto e = enumerate(str);
+    Vec v(std::begin(e), std::end(e));
+    Vec vc{{0, 'a'}, {1, 'b'}, {2, 'c'}};
+
+    REQUIRE( v == vc );
+}
+
+TEST_CASE("Empty", "[enumerate]") {
+    std::string emp{};
+    auto e = enumerate(emp);
+    Vec v(std::begin(e), std::end(e));
+    REQUIRE( v.empty() );
+}
diff --git a/catchtest/test_main.cpp b/catchtest/test_main.cpp
new file mode 100644
index 00000000..0c7c351f
--- /dev/null
+++ b/catchtest/test_main.cpp
@@ -0,0 +1,2 @@
+#define CATCH_CONFIG_MAIN
+#include "catch.hpp"

From 602f3d2710e159f2175db4cba018c30f5c3a966b Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 14 Nov 2014 00:15:51 -0500
Subject: [PATCH 0555/1866] marks enumerate iterator as forward_iterator

---
 enumerate.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index 659d2c0a..93592838 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -65,7 +65,7 @@ namespace iter {
             //  index.  Each call to ++ increments both of these data members.
             //  Each dereference returns an IterYield.
             class Iterator :
-                public std::iterator<std::forward_iterator_tag, IterYield>
+                public std::iterator<std::input_iterator_tag, IterYield>
             {
                 private:
                     iterator_type<Container> sub_iter;

From 3bab276571b568464d91b3ff9d5ea4eb86889a5a Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 20 Nov 2014 21:07:57 -0500
Subject: [PATCH 0556/1866] adds more serious tests for enumerate

---
 catchtest/test_enumerate.cpp | 48 ++++++++++++++++++++++++++++++++++++
 1 file changed, 48 insertions(+)

diff --git a/catchtest/test_enumerate.cpp b/catchtest/test_enumerate.cpp
index c6253e9f..fc3f8e78 100644
--- a/catchtest/test_enumerate.cpp
+++ b/catchtest/test_enumerate.cpp
@@ -4,6 +4,16 @@
 #include <string>
 #include <iterator>
 #include <utility>
+#include <sstream>
+
+namespace Catch {
+template <typename A, typename B>
+std::string toString( const std::pair<A, B>& p) {
+    std::ostringstream oss;
+    oss << '{' << p.first << ", " << p.second << '}';
+    return oss.str();
+}
+}
 
 #include "catch.hpp"
 
@@ -23,5 +33,43 @@ TEST_CASE("Empty", "[enumerate]") {
     std::string emp{};
     auto e = enumerate(emp);
     Vec v(std::begin(e), std::end(e));
+
     REQUIRE( v.empty() );
 }
+
+TEST_CASE("Modifications through enumerate affect container", "[enumerate]") {
+    std::vector<int> v{1, 2, 3, 4};
+    std::vector<int> vc(v.size(), -1);
+    for (auto&& p : enumerate(v)){
+        p.second = -1;
+    }
+
+    REQUIRE( v == vc );
+}
+
+TEST_CASE("Static array works", "[enumerate]") {
+    char arr[] = {'w', 'x', 'y'};
+
+    SECTION("Conversion to vector") {
+        auto e = enumerate(arr);
+        Vec v(std::begin(e), std::end(e));
+        Vec vc{{0, 'w'}, {1, 'x'}, {2, 'y'}};
+        REQUIRE( v == vc );
+    }
+
+    SECTION("Modification through enumerate") {
+        for (auto&& p : enumerate(arr)) {
+            p.second = 'z';
+        }
+        std::vector<char> v(std::begin(arr), std::end(arr));
+        decltype(v) vc(v.size(), 'z');
+        REQUIRE( v == vc );
+    }
+}
+
+TEST_CASE("initializer_list works", "[enumerate]") {
+    auto e = enumerate({'a', 'b', 'c'});
+    Vec v(std::begin(e), std::end(e));
+    Vec vc{{0, 'a'}, {1, 'b'}, {2, 'c'}};
+    REQUIRE( v == vc );
+}

From b488fc5a963cb34e123dfe3eb56c7a7ba75ccd1c Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 20 Nov 2014 22:41:51 -0500
Subject: [PATCH 0557/1866] adds minimal requirements for testing

---
 catchtest/test_helpers.hpp | 119 +++++++++++++++++++++++++++++++++++++
 1 file changed, 119 insertions(+)
 create mode 100644 catchtest/test_helpers.hpp

diff --git a/catchtest/test_helpers.hpp b/catchtest/test_helpers.hpp
new file mode 100644
index 00000000..175434e0
--- /dev/null
+++ b/catchtest/test_helpers.hpp
@@ -0,0 +1,119 @@
+#ifndef TEST_HELPER_H_
+#define TEST_HELPER_H_
+
+namespace itertest {
+
+// move-constructible only int wrapper
+class SolidInt {
+    private:
+        const int i;
+    public:
+        constexpr SolidInt(int n)
+            : i{n}
+        { }
+
+        constexpr int getint() const {
+            return this->i;
+        }
+
+        SolidInt() = delete;
+        SolidInt(const SolidInt&) = delete;
+        constexpr SolidInt(SolidInt&&) noexcept = default;
+        SolidInt& operator=(const SolidInt&) = delete;
+        SolidInt& operator=(SolidInt&&) = delete;
+};
+
+
+// BasicIterable provides a minimal forward iterator
+// operator++(), operator!=(const BasicIterable&), operator*()
+// move constructible only
+// not copy constructible, move assignable, or copy assignable
+template <typename T>
+class BasicIterable {
+    private:
+        T *data;
+        std::size_t size;
+        bool was_moved_from_ = false;
+        bool was_copied_from_ = false;
+    public:
+        BasicIterable(std::initializer_list<T> il)
+            : data{new T[il.size()]},
+            size{il.size()}
+        {
+            // would like to use enumerate, can't because it's for unit
+            // testing enumerate
+            std::size_t i = 0;
+            for (auto&& e : il) {
+                data[i] = e;
+                ++i;
+            }
+        }
+
+        BasicIterable& operator=(BasicIterable&&) = delete;
+        BasicIterable& operator=(const BasicIterable&) = delete;
+
+        BasicIterable(const BasicIterable&) = delete;
+#if 0
+        BasicIterable(const BasicIterable& other)
+            : data{new T[other.size()]},
+            size{other.size}
+        { 
+            for (auto it = this->begin(), o_it = other.begin();
+                    o_it != other.end();
+                    ++it, ++o_it) {
+                *it = *o_it;
+            }
+        }
+#endif
+
+
+        BasicIterable(BasicIterable&& other)
+            : data{other.data},
+            size{other.size}
+        {
+            other.data = nullptr;
+            other.was_moved_from_ = true;
+        }
+
+        bool was_moved_from() const {
+            return this->was_moved_from_;
+        }
+
+        bool was_copied_from() const {
+            return this->was_copied_from_;
+        }
+
+        ~BasicIterable() {
+            delete [] this->data;
+        }
+
+        class Iterator {
+            private:
+                T *p;
+            public:
+                Iterator(T *b) : p{b} { }
+                bool operator!=(const Iterator& other) const {
+                    return this->p != other.p;
+                }
+
+                Iterator& operator++() {
+                    ++this->p;
+                }
+
+                T& operator*() {
+                    return *this->p;
+                }
+        };
+
+        Iterator begin() {
+            return {this->data};
+        }
+
+        Iterator end() {
+            return {this->data + this->size};
+        }
+};
+
+}
+
+#endif

From b8c5c9543eb115be80365c8faf6c24bfd12c5cea Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 20 Nov 2014 22:42:14 -0500
Subject: [PATCH 0558/1866] tests enumerate with minimal requirements

---
 catchtest/test_enumerate.cpp | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/catchtest/test_enumerate.cpp b/catchtest/test_enumerate.cpp
index fc3f8e78..b2832c6e 100644
--- a/catchtest/test_enumerate.cpp
+++ b/catchtest/test_enumerate.cpp
@@ -1,5 +1,7 @@
 #include <enumerate.hpp>
 
+#include "test_helpers.hpp"
+
 #include <vector>
 #include <string>
 #include <iterator>
@@ -20,6 +22,9 @@ std::string toString( const std::pair<A, B>& p) {
 using Vec = std::vector<std::pair<std::size_t, char>>;
 using iter::enumerate;
 
+using itertest::BasicIterable;
+using itertest::SolidInt;
+
 TEST_CASE("Basic Function", "[enumerate]") {
     std::string str = "abc";
     auto e = enumerate(str);
@@ -73,3 +78,24 @@ TEST_CASE("initializer_list works", "[enumerate]") {
     Vec vc{{0, 'a'}, {1, 'b'}, {2, 'c'}};
     REQUIRE( v == vc );
 }
+
+TEST_CASE("binds reference when it should", "[enumerate]") {
+    BasicIterable<char> bi{'x', 'y', 'z'};
+    auto e = enumerate(bi);
+    (void)e;
+    REQUIRE_FALSE( bi.was_moved_from() );
+}
+
+TEST_CASE("moves rvalues into enumerable object", "[enumerate]") {
+    BasicIterable<char> bi{'x', 'y', 'z'};
+    auto e = enumerate(std::move(bi));
+    REQUIRE( bi.was_moved_from());
+    (void)e;
+}
+
+TEST_CASE("Doesn't move or copy elements of iterable", "[enumerate]") {
+    constexpr SolidInt arr[] = {6, 7, 8};
+    for (auto&& i : enumerate(arr)) {
+        (void)i;
+    }
+}

From 2b81f4adc296a495836b29e93af638448b7a32b3 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 20 Nov 2014 23:03:33 -0500
Subject: [PATCH 0559/1866] adds catch test gitignore

---
 catchtest/.gitignore | 2 ++
 1 file changed, 2 insertions(+)
 create mode 100644 catchtest/.gitignore

diff --git a/catchtest/.gitignore b/catchtest/.gitignore
new file mode 100644
index 00000000..f3f25933
--- /dev/null
+++ b/catchtest/.gitignore
@@ -0,0 +1,2 @@
+*.o
+test_main

From a6df6d8139524ca67b5f4a3984bf3824793ed109 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 22 Nov 2014 17:59:07 -0500
Subject: [PATCH 0560/1866] zip iterator inherits from std::iterator

---
 zip.hpp | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/zip.hpp b/zip.hpp
index 08d2ec1a..240ee0f5 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -18,8 +18,9 @@ namespace iter {
     // specialization for at least 1 template argument
     template <typename Container, typename... RestContainers>
     class Zipped <Container, RestContainers...> {
-        static_assert(!std::is_rvalue_reference<Container>::value,
-                "Itertools cannot be templated with rvalue references");
+        using ZipIterDeref =
+            std::tuple<iterator_deref<Container>,
+                iterator_deref<RestContainers>...>;
 
         friend Zipped zip<Container, RestContainers...>(
                 Container&&, RestContainers&&...);
@@ -36,7 +37,9 @@ namespace iter {
             { }
 
         public:
-            class Iterator {
+            class Iterator :
+                public std::iterator<std::forward_iterator_tag, ZipIterDeref>
+        {
                 private:
                     using RestIter =
                         typename Zipped<RestContainers...>::Iterator;
@@ -90,7 +93,9 @@ namespace iter {
     template <>
     class Zipped<> {
         public:
-            class Iterator {
+            class Iterator
+                : public std::iterator<std::forward_iterator_tag, std::tuple<>>
+            {
                 public:
                     constexpr static const bool is_base_iter = true;
 

From ca5b9ede248851f426bf511b19cf664be9d3ef9b Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 22 Nov 2014 18:02:19 -0500
Subject: [PATCH 0561/1866] basic zip test

---
 catchtest/test_zip.cpp | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 catchtest/test_zip.cpp

diff --git a/catchtest/test_zip.cpp b/catchtest/test_zip.cpp
new file mode 100644
index 00000000..3f836322
--- /dev/null
+++ b/catchtest/test_zip.cpp
@@ -0,0 +1,28 @@
+#include <zip.hpp>
+
+#include "test_helpers.hpp"
+
+#include <vector>
+#include <tuple>
+#include <string>
+#include <iterator>
+#include <utility>
+#include <sstream>
+
+#include "catch.hpp"
+
+using iter::zip;
+
+TEST_CASE("Simple case, same length", "[zip]") {
+    using Tu = std::tuple<int, char, double>;
+    using ResVec = const std::vector<Tu>;
+    std::vector<int> iv {10, 20, 30};
+    std::string s{"hey"};
+    double arr[] = {1.0, 2.0, 4.0};
+
+    auto z = zip(iv, s, arr);
+    ResVec v(std::begin(z), std::end(z));
+    ResVec vc {Tu{10, 'h', 1.0}, Tu{20, 'e', 2.0}, Tu{30, 'y', 4.0}};
+    REQUIRE( v == vc );
+}
+

From 909e0324c6858c63600def5ee8c3c49abcefae3a Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 22 Nov 2014 18:02:32 -0500
Subject: [PATCH 0562/1866] adds test_zip to main catch test

---
 catchtest/Makefile | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/catchtest/Makefile b/catchtest/Makefile
index 6e26db78..16cd013d 100644
--- a/catchtest/Makefile
+++ b/catchtest/Makefile
@@ -5,10 +5,11 @@ LINK.o = $(CXX)
 
 all: test_main
 
-test_main: test_main.o test_range.o test_enumerate.o
+test_main: test_main.o test_range.o test_enumerate.o test_zip.o
 
 test_range.o: test_range.cpp ../range.hpp
 test_enumerate.o: test_enumerate.cpp ../enumerate.hpp
+test_zip.o: test_zip.cpp ../zip.hpp
 
 clean:
 	rm -f test_main *.o

From 3ee9977768352634bbaea821391c15a4a14c823b Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 23 Nov 2014 14:32:11 -0500
Subject: [PATCH 0563/1866] adds test for correct empty zip

---
 catchtest/test_zip.cpp | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/catchtest/test_zip.cpp b/catchtest/test_zip.cpp
index 3f836322..309dc4a9 100644
--- a/catchtest/test_zip.cpp
+++ b/catchtest/test_zip.cpp
@@ -26,3 +26,11 @@ TEST_CASE("Simple case, same length", "[zip]") {
     REQUIRE( v == vc );
 }
 
+TEST_CASE("One empty, all empty", "[zip]") {
+    std::vector<int> iv = {1,2,3};
+    std::string s{};
+    auto z = zip(iv, s);
+    REQUIRE_FALSE( std::begin(z) != std::end(z) );
+    auto z2 = zip(s, iv);
+    REQUIRE_FALSE( std::begin(z2) != std::end(z2) );
+}

From 06122d3295b2a9f7e72892a51027b9c604df2ceb Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 23 Nov 2014 14:35:14 -0500
Subject: [PATCH 0564/1866] adds enumerate test with const sequence

---
 catchtest/test_enumerate.cpp | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/catchtest/test_enumerate.cpp b/catchtest/test_enumerate.cpp
index b2832c6e..b3c1f01a 100644
--- a/catchtest/test_enumerate.cpp
+++ b/catchtest/test_enumerate.cpp
@@ -93,6 +93,14 @@ TEST_CASE("moves rvalues into enumerable object", "[enumerate]") {
     (void)e;
 }
 
+TEST_CASE("Works with const iterable", "[enumerate]") {
+    const std::string s{"ace"};
+    auto e = enumerate(s);
+    Vec v(std::begin(e), std::end(e));
+    Vec vc{{0, 'a'}, {1, 'c'}, {2, 'e'}};
+    REQUIRE( v == vc );
+}
+
 TEST_CASE("Doesn't move or copy elements of iterable", "[enumerate]") {
     constexpr SolidInt arr[] = {6, 7, 8};
     for (auto&& i : enumerate(arr)) {

From c107e8b4d9a71e34ba18aeb2b935c5e4fdbbd51a Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 23 Nov 2014 14:55:11 -0500
Subject: [PATCH 0565/1866] adds zip test for shortest sequence termination

---
 catchtest/test_zip.cpp | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/catchtest/test_zip.cpp b/catchtest/test_zip.cpp
index 309dc4a9..bf8c8152 100644
--- a/catchtest/test_zip.cpp
+++ b/catchtest/test_zip.cpp
@@ -8,6 +8,7 @@
 #include <iterator>
 #include <utility>
 #include <sstream>
+#include <iterator>
 
 #include "catch.hpp"
 
@@ -34,3 +35,12 @@ TEST_CASE("One empty, all empty", "[zip]") {
     auto z2 = zip(s, iv);
     REQUIRE_FALSE( std::begin(z2) != std::end(z2) );
 }
+
+TEST_CASE("terminates on shortest sequence", "[zip]") {
+    std::vector<int> iv{1,2,3,4,5};
+    std::string s{"hi"};
+    auto z = zip(iv, s);
+
+    REQUIRE( std::distance(std::begin(z), std::end(z)) == 2 );
+}
+

From 0d00a525b9d0a969a9964890f68f7c064d6a3b8b Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 23 Nov 2014 14:55:30 -0500
Subject: [PATCH 0566/1866] adds test for empty zip()

---
 catchtest/test_zip.cpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/catchtest/test_zip.cpp b/catchtest/test_zip.cpp
index bf8c8152..ee99a473 100644
--- a/catchtest/test_zip.cpp
+++ b/catchtest/test_zip.cpp
@@ -44,3 +44,7 @@ TEST_CASE("terminates on shortest sequence", "[zip]") {
     REQUIRE( std::distance(std::begin(z), std::end(z)) == 2 );
 }
 
+TEST_CASE("Empty zip()", "[zip]") {
+    auto z = zip();
+    REQUIRE_FALSE( std::begin(z) != std::end(z) );
+}

From 1b091c4460263ba64b5a89cd665f8f0ac7819af4 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 23 Nov 2014 14:56:03 -0500
Subject: [PATCH 0567/1866] tests for modifying iterables through zip

---
 catchtest/test_zip.cpp | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/catchtest/test_zip.cpp b/catchtest/test_zip.cpp
index ee99a473..5bf41a67 100644
--- a/catchtest/test_zip.cpp
+++ b/catchtest/test_zip.cpp
@@ -48,3 +48,13 @@ TEST_CASE("Empty zip()", "[zip]") {
     auto z = zip();
     REQUIRE_FALSE( std::begin(z) != std::end(z) );
 }
+
+TEST_CASE("Modify sequence through zip", "[zip]") {
+    std::vector<int> iv{1,2,3};
+    for (auto&& t : zip(iv)) {
+        std::get<0>(t) = -1;
+    }
+
+    const std::vector<int> vc{-1, -1, -1};
+    REQUIRE( iv == vc);
+}

From 71ae2777c1739476f2e2c3db2fc7a558a7df87c0 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 23 Nov 2014 15:02:10 -0500
Subject: [PATCH 0568/1866] tests zip for correct bind and move

---
 catchtest/test_zip.cpp | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/catchtest/test_zip.cpp b/catchtest/test_zip.cpp
index 5bf41a67..8c7ec369 100644
--- a/catchtest/test_zip.cpp
+++ b/catchtest/test_zip.cpp
@@ -13,6 +13,8 @@
 #include "catch.hpp"
 
 using iter::zip;
+using itertest::BasicIterable;
+using itertest::SolidInt;
 
 TEST_CASE("Simple case, same length", "[zip]") {
     using Tu = std::tuple<int, char, double>;
@@ -58,3 +60,23 @@ TEST_CASE("Modify sequence through zip", "[zip]") {
     const std::vector<int> vc{-1, -1, -1};
     REQUIRE( iv == vc);
 }
+
+TEST_CASE("Binds reference when it should", "[zip]") {
+    BasicIterable<char> bi{'x', 'y', 'z'};
+    zip(bi);
+    REQUIRE_FALSE( bi.was_moved_from() );
+}
+
+TEST_CASE("Moves rvalues", "[zip]") {
+    BasicIterable<char> bi{'x', 'y', 'z'};
+    zip(std::move(bi));
+    REQUIRE( bi.was_moved_from() );
+}
+
+TEST_CASE("Can bind ref and move in single zip", "[zip]") {
+    BasicIterable<char> b1{'x', 'y', 'z'};
+    BasicIterable<char> b2{'a', 'b'};
+    zip(b1, std::move(b2));
+    REQUIRE_FALSE( b1.was_moved_from() );
+    REQUIRE( b2.was_moved_from() );
+}

From e54c86c3d5a0bce3b12978fb2509d703de1ba32b Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 23 Nov 2014 15:10:05 -0500
Subject: [PATCH 0569/1866] soldint throws if two levels of moves happen

---
 catchtest/test_helpers.hpp | 15 ++++++++++++++-
 catchtest/test_zip.cpp     | 11 +++++++++--
 2 files changed, 23 insertions(+), 3 deletions(-)

diff --git a/catchtest/test_helpers.hpp b/catchtest/test_helpers.hpp
index 175434e0..e5e1546f 100644
--- a/catchtest/test_helpers.hpp
+++ b/catchtest/test_helpers.hpp
@@ -1,12 +1,15 @@
 #ifndef TEST_HELPER_H_
 #define TEST_HELPER_H_
 
+#include <stdexcept>
+
 namespace itertest {
 
 // move-constructible only int wrapper
 class SolidInt {
     private:
         const int i;
+        bool moved_from = false;
     public:
         constexpr SolidInt(int n)
             : i{n}
@@ -18,9 +21,19 @@ class SolidInt {
 
         SolidInt() = delete;
         SolidInt(const SolidInt&) = delete;
-        constexpr SolidInt(SolidInt&&) noexcept = default;
         SolidInt& operator=(const SolidInt&) = delete;
         SolidInt& operator=(SolidInt&&) = delete;
+
+        SolidInt(SolidInt&& other)
+            : i{other.i}
+        {
+            if (other.moved_from) {
+                throw std::invalid_argument{
+                    "Object was constructed with a move ctor"};
+            }
+            other.moved_from = true;
+        }
+
 };
 
 
diff --git a/catchtest/test_zip.cpp b/catchtest/test_zip.cpp
index 8c7ec369..06a409ba 100644
--- a/catchtest/test_zip.cpp
+++ b/catchtest/test_zip.cpp
@@ -61,13 +61,13 @@ TEST_CASE("Modify sequence through zip", "[zip]") {
     REQUIRE( iv == vc);
 }
 
-TEST_CASE("Binds reference when it should", "[zip]") {
+TEST_CASE("zip binds reference when it should", "[zip]") {
     BasicIterable<char> bi{'x', 'y', 'z'};
     zip(bi);
     REQUIRE_FALSE( bi.was_moved_from() );
 }
 
-TEST_CASE("Moves rvalues", "[zip]") {
+TEST_CASE("zip moves rvalues", "[zip]") {
     BasicIterable<char> bi{'x', 'y', 'z'};
     zip(std::move(bi));
     REQUIRE( bi.was_moved_from() );
@@ -80,3 +80,10 @@ TEST_CASE("Can bind ref and move in single zip", "[zip]") {
     REQUIRE_FALSE( b1.was_moved_from() );
     REQUIRE( b2.was_moved_from() );
 }
+
+TEST_CASE("zip doesn't move or copy elements of iterable", "[zip]") {
+    constexpr SolidInt arr[] = {6, 7, 8};
+    for (auto&& t : zip(arr)) {
+        (void)std::get<0>(t);
+    }
+}

From ea91611df147ac2173441b0c64b5e60b32354eef Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 23 Nov 2014 20:58:48 -0500
Subject: [PATCH 0570/1866] renames test_helpers to helpers

---
 catchtest/{test_helpers.hpp => helpers.hpp} | 0
 catchtest/test_enumerate.cpp                | 2 +-
 catchtest/test_zip.cpp                      | 2 +-
 3 files changed, 2 insertions(+), 2 deletions(-)
 rename catchtest/{test_helpers.hpp => helpers.hpp} (100%)

diff --git a/catchtest/test_helpers.hpp b/catchtest/helpers.hpp
similarity index 100%
rename from catchtest/test_helpers.hpp
rename to catchtest/helpers.hpp
diff --git a/catchtest/test_enumerate.cpp b/catchtest/test_enumerate.cpp
index b3c1f01a..e9131fe5 100644
--- a/catchtest/test_enumerate.cpp
+++ b/catchtest/test_enumerate.cpp
@@ -1,6 +1,6 @@
 #include <enumerate.hpp>
 
-#include "test_helpers.hpp"
+#include "helpers.hpp"
 
 #include <vector>
 #include <string>
diff --git a/catchtest/test_zip.cpp b/catchtest/test_zip.cpp
index 06a409ba..f0c93914 100644
--- a/catchtest/test_zip.cpp
+++ b/catchtest/test_zip.cpp
@@ -1,6 +1,6 @@
 #include <zip.hpp>
 
-#include "test_helpers.hpp"
+#include "helpers.hpp"
 
 #include <vector>
 #include <tuple>

From 915a889c4d0dcc3e89538314a2c490ffd5e87016 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 23 Nov 2014 21:07:09 -0500
Subject: [PATCH 0571/1866] makes solidint throw at correct time

---
 catchtest/helpers.hpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/catchtest/helpers.hpp b/catchtest/helpers.hpp
index e5e1546f..570373b0 100644
--- a/catchtest/helpers.hpp
+++ b/catchtest/helpers.hpp
@@ -9,7 +9,7 @@ namespace itertest {
 class SolidInt {
     private:
         const int i;
-        bool moved_from = false;
+        bool made_from_move = false;
     public:
         constexpr SolidInt(int n)
             : i{n}
@@ -25,13 +25,13 @@ class SolidInt {
         SolidInt& operator=(SolidInt&&) = delete;
 
         SolidInt(SolidInt&& other)
-            : i{other.i}
+            : i{other.i},
+            made_from_move{true}
         {
-            if (other.moved_from) {
+            if (other.made_from_move) {
                 throw std::invalid_argument{
                     "Object was constructed with a move ctor"};
             }
-            other.moved_from = true;
         }
 
 };

From 375af8665d28e3fd96aa065f0c471ed5b637cede Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 23 Nov 2014 21:07:26 -0500
Subject: [PATCH 0572/1866] test_main tests the helpers

---
 catchtest/Makefile         |  3 ++-
 catchtest/test_helpers.cpp | 17 +++++++++++++++++
 2 files changed, 19 insertions(+), 1 deletion(-)
 create mode 100644 catchtest/test_helpers.cpp

diff --git a/catchtest/Makefile b/catchtest/Makefile
index 16cd013d..44032298 100644
--- a/catchtest/Makefile
+++ b/catchtest/Makefile
@@ -5,11 +5,12 @@ LINK.o = $(CXX)
 
 all: test_main
 
-test_main: test_main.o test_range.o test_enumerate.o test_zip.o
+test_main: test_main.o test_range.o test_enumerate.o test_zip.o test_helpers.o
 
 test_range.o: test_range.cpp ../range.hpp
 test_enumerate.o: test_enumerate.cpp ../enumerate.hpp
 test_zip.o: test_zip.cpp ../zip.hpp
+test_helpers.o: test_helpers.cpp helpers.hpp
 
 clean:
 	rm -f test_main *.o
diff --git a/catchtest/test_helpers.cpp b/catchtest/test_helpers.cpp
new file mode 100644
index 00000000..f3c59813
--- /dev/null
+++ b/catchtest/test_helpers.cpp
@@ -0,0 +1,17 @@
+#include "helpers.hpp"
+#include <utility>
+
+#include "catch.hpp"
+
+using itertest::SolidInt;
+
+TEST_CASE("SolidInt can be moved only once", "[helpers]") {
+    SolidInt i{3};
+    SECTION("Doesn't throw on first move") {
+        REQUIRE_NOTHROW( SolidInt{std::move(i)} );
+    }
+    SECTION("Throws on second move") {
+        SolidInt i2{std::move(i)};
+        REQUIRE_THROWS( SolidInt i3{std::move(i2)} );
+    }
+}

From 0da2d5ce95f47fb592feaee41b35e9448f5f16f4 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 23 Nov 2014 21:10:08 -0500
Subject: [PATCH 0573/1866] tests modifying two sequences

---
 catchtest/test_zip.cpp | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/catchtest/test_zip.cpp b/catchtest/test_zip.cpp
index f0c93914..1374feb1 100644
--- a/catchtest/test_zip.cpp
+++ b/catchtest/test_zip.cpp
@@ -53,12 +53,16 @@ TEST_CASE("Empty zip()", "[zip]") {
 
 TEST_CASE("Modify sequence through zip", "[zip]") {
     std::vector<int> iv{1,2,3};
-    for (auto&& t : zip(iv)) {
+    std::vector<int> iv2{1,2,3,4};
+    for (auto&& t : zip(iv, iv2)) {
         std::get<0>(t) = -1;
+        std::get<1>(t) = -1;
     }
 
     const std::vector<int> vc{-1, -1, -1};
+    const std::vector<int> vc2{-1, -1, -1, 4};
     REQUIRE( iv == vc);
+    REQUIRE( iv2 == vc2);
 }
 
 TEST_CASE("zip binds reference when it should", "[zip]") {

From 372a85fb79437aeef0abf7a89840b44fcf680268 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 23 Nov 2014 21:14:04 -0500
Subject: [PATCH 0574/1866] removes import platform

---
 tests/SConstruct | 1 -
 1 file changed, 1 deletion(-)

diff --git a/tests/SConstruct b/tests/SConstruct
index 626cb51a..74195c1e 100644
--- a/tests/SConstruct
+++ b/tests/SConstruct
@@ -1,4 +1,3 @@
-import platform
 import os
 
 env = Environment(

From 3b1e72e020f21d59e5039468a9f29c9707e2a728 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 23 Nov 2014 21:39:15 -0500
Subject: [PATCH 0575/1866] replaces makefile with SConstruct

---
 catchtest/Makefile   | 16 ----------------
 catchtest/SConstruct | 30 ++++++++++++++++++++++++++++++
 2 files changed, 30 insertions(+), 16 deletions(-)
 delete mode 100644 catchtest/Makefile
 create mode 100644 catchtest/SConstruct

diff --git a/catchtest/Makefile b/catchtest/Makefile
deleted file mode 100644
index 44032298..00000000
--- a/catchtest/Makefile
+++ /dev/null
@@ -1,16 +0,0 @@
-CXX = g++
-CXXFLAGS = -Wall -Wextra -pedantic -std=c++11 -fdiagnostics-color=auto
-CPPFLAGS = -I..
-LINK.o = $(CXX)
-
-all: test_main
-
-test_main: test_main.o test_range.o test_enumerate.o test_zip.o test_helpers.o
-
-test_range.o: test_range.cpp ../range.hpp
-test_enumerate.o: test_enumerate.cpp ../enumerate.hpp
-test_zip.o: test_zip.cpp ../zip.hpp
-test_helpers.o: test_helpers.cpp helpers.hpp
-
-clean:
-	rm -f test_main *.o
diff --git a/catchtest/SConstruct b/catchtest/SConstruct
new file mode 100644
index 00000000..574317c4
--- /dev/null
+++ b/catchtest/SConstruct
@@ -0,0 +1,30 @@
+import os
+
+env = Environment(
+    ENV = {'PATH' : os.environ['PATH']},
+    CXX='c++',
+    CXXFLAGS= ['-g', '-Wall', '-Wextra',
+               '-pedantic', '-std=c++11',
+                '-fdiagnostics-color=always',
+               '-I/usr/local/include'],
+    CPPPATH='..',
+    LINKFLAGS='-L/usr/local/lib')
+
+# allows highighting to print to terminal from compiler output
+env['ENV']['TERM'] = os.environ['TERM']
+
+progs = Split(
+    '''
+    enumerate
+    zip
+    range
+    '''
+)
+
+test_sources = ['test_{}.cpp'.format(p) for p in progs]
+
+for test_src in test_sources:
+    env.Program([test_src, 'test_main.cpp'])
+
+env.Program('test_all', ['test_main.cpp'] + test_sources)
+

From cc292dbb76b4c1a64195a1d01b76a62efdc83742 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 23 Nov 2014 21:42:48 -0500
Subject: [PATCH 0576/1866] ignores all test_ executables

---
 catchtest/.gitignore | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/catchtest/.gitignore b/catchtest/.gitignore
index f3f25933..427dd64a 100644
--- a/catchtest/.gitignore
+++ b/catchtest/.gitignore
@@ -1,2 +1,4 @@
 *.o
-test_main
+test_*
+!test_*.cpp
+.sconsign.dblite

From ea3b49ba5ea7ec3bdaf5ca296ab7bc710cc8546e Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 23 Nov 2014 21:52:09 -0500
Subject: [PATCH 0577/1866] removes __ from include guards

---
 accumulate.hpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/accumulate.hpp b/accumulate.hpp
index ef4ed42c..9c7da049 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -1,5 +1,5 @@
-#ifndef ACCUMULATE__H__
-#define ACCUMULATE__H__
+#ifndef ITER_ACCUMULATE_H_
+#define ITER_ACCUMULATE_H_
 
 #include "iterbase.hpp"
 
@@ -143,4 +143,4 @@ namespace iter {
 
 }
 
-#endif //ifndef ACCUMULATE__H__
+#endif //ifndef ITER_ACCUMULATE_H_

From 2994dee81967723614c6ef8c29585e4b1cd71885 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 23 Nov 2014 21:56:02 -0500
Subject: [PATCH 0578/1866] tests basic accumulate

---
 catchtest/test_accumulate.cpp | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 catchtest/test_accumulate.cpp

diff --git a/catchtest/test_accumulate.cpp b/catchtest/test_accumulate.cpp
new file mode 100644
index 00000000..0783ecc9
--- /dev/null
+++ b/catchtest/test_accumulate.cpp
@@ -0,0 +1,19 @@
+#include <accumulate.hpp>
+
+#include <vector>
+#include <iterator>
+#include <string>
+
+#include "catch.hpp"
+
+using iter::accumulate;
+
+TEST_CASE("Simple sum", "[accumulate]") {
+    std::vector<int> ns{1,2,3,4,5};
+    auto a = accumulate(ns);
+
+    const std::vector<int> v(std::begin(a), std::end(a));
+    const std::vector<int> vc{1,3,6,10,15};
+    REQUIRE( v == vc );
+}
+

From f03b28a51443c4349a2b30a5af033f018ac30c1f Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 23 Nov 2014 21:56:10 -0500
Subject: [PATCH 0579/1866] accumulate iterator inherits from std::iterator

---
 accumulate.hpp | 25 +++++++++++++------------
 1 file changed, 13 insertions(+), 12 deletions(-)

diff --git a/accumulate.hpp b/accumulate.hpp
index 9c7da049..0ff49028 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -36,7 +36,16 @@ namespace iter {
             friend Accumulator<std::initializer_list<T>, AF> accumulate(
                     std::initializer_list<T>, AF);
             
-            // Value constructor for use only in the accumulate function
+            // AccumVal must be default constructible
+            using AccumVal =
+                typename std::remove_reference<
+                    typename std::result_of<AccumulateFunc(
+                            iterator_deref<Container>,
+                            iterator_deref<Container>)>::type>::type;
+            static_assert(
+                    std::is_default_constructible<AccumVal>::value,
+                    "Cannot accumulate a non-default constructible type");
+
             Accumulator(Container container, AccumulateFunc accumulate_func)
                 : container(std::forward<Container>(container)),
                 accumulate_func(accumulate_func)
@@ -47,17 +56,9 @@ namespace iter {
         public:
             Accumulator(const Accumulator&) = default;
 
-            class Iterator {
-                // AccumVal must be default constructible
-                using AccumVal =
-                    typename std::remove_reference<
-                        typename std::result_of<AccumulateFunc(
-                                iterator_deref<Container>,
-                                iterator_deref<Container>)>::type>::type;
-                static_assert(
-                        std::is_default_constructible<AccumVal>::value,
-                        "Cannot accumulate a non-default constructible type");
-
+            class Iterator 
+                : public std::iterator<std::forward_iterator_tag, AccumVal>
+            {
                 private:
                     iterator_type<Container> sub_iter;
                     const iterator_type<Container> sub_end;

From 7872f85739c905eefabb218e0502badfb8dec395 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 23 Nov 2014 21:56:43 -0500
Subject: [PATCH 0580/1866] builds test_accumulate

---
 catchtest/SConstruct | 1 +
 1 file changed, 1 insertion(+)

diff --git a/catchtest/SConstruct b/catchtest/SConstruct
index 574317c4..181a7ce4 100644
--- a/catchtest/SConstruct
+++ b/catchtest/SConstruct
@@ -18,6 +18,7 @@ progs = Split(
     enumerate
     zip
     range
+    accumulate
     '''
 )
 

From c64f5463ac38fd001ff8c3b41887d03f1daeb4b7 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 23 Nov 2014 22:15:40 -0500
Subject: [PATCH 0581/1866] removes delete/default on accumulate ctor and =

Let the compiler figure it out.
---
 accumulate.hpp | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/accumulate.hpp b/accumulate.hpp
index 0ff49028..9e810dc5 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -50,11 +50,7 @@ namespace iter {
                 : container(std::forward<Container>(container)),
                 accumulate_func(accumulate_func)
             { }
-            Accumulator() = delete;
-            Accumulator& operator=(const Accumulator&) = delete;
-
         public:
-            Accumulator(const Accumulator&) = default;
 
             class Iterator 
                 : public std::iterator<std::forward_iterator_tag, AccumVal>

From bae980337ec83d27d03f05a3c0caf8c17258cb5b Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 23 Nov 2014 22:18:58 -0500
Subject: [PATCH 0582/1866] tests accumulate with BasicIterable

---
 catchtest/test_accumulate.cpp | 37 ++++++++++++++++++++++++++++++++---
 1 file changed, 34 insertions(+), 3 deletions(-)

diff --git a/catchtest/test_accumulate.cpp b/catchtest/test_accumulate.cpp
index 0783ecc9..c52feb33 100644
--- a/catchtest/test_accumulate.cpp
+++ b/catchtest/test_accumulate.cpp
@@ -1,4 +1,5 @@
 #include <accumulate.hpp>
+#include "helpers.hpp"
 
 #include <vector>
 #include <iterator>
@@ -7,13 +8,43 @@
 #include "catch.hpp"
 
 using iter::accumulate;
+using itertest::BasicIterable;
 
+using Vec = const std::vector<int>;
 TEST_CASE("Simple sum", "[accumulate]") {
-    std::vector<int> ns{1,2,3,4,5};
+    Vec ns{1,2,3,4,5};
     auto a = accumulate(ns);
 
-    const std::vector<int> v(std::begin(a), std::end(a));
-    const std::vector<int> vc{1,3,6,10,15};
+    Vec v(std::begin(a), std::end(a));
+    Vec vc{1,3,6,10,15};
     REQUIRE( v == vc );
 }
 
+TEST_CASE("With subtraction lambda", "[accumulate]") {
+    Vec ns{5,4,3,2,1};
+    auto a = accumulate(ns, [](int a, int b){return a - b; });
+
+    Vec v(std::begin(a), std::end(a));
+    Vec vc{5, 1, -2, -4, -5};
+    REQUIRE( v == vc );
+}
+
+TEST_CASE("initializer_list works", "[accumulate]") {
+    auto a = accumulate({1, 2, 3});
+    Vec v(std::begin(a), std::end(a));
+    Vec vc{1, 3, 6};
+
+    REQUIRE( v == vc );
+}
+
+TEST_CASE("binds reference when it should", "[enumerate]") {
+    BasicIterable<int> bi{1, 2};
+    accumulate(bi);
+    REQUIRE_FALSE( bi.was_moved_from() );
+}
+
+TEST_CASE("moves rvalues into enumerable object", "[enumerate]") {
+    BasicIterable<int> bi{1, 2};
+    accumulate(std::move(bi));
+    REQUIRE( bi.was_moved_from() );
+}

From 17c32b76054ea8cfccd1cf6addfc9067233333bd Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 23 Nov 2014 22:22:46 -0500
Subject: [PATCH 0583/1866] iterator dereferences to const ref to avoid copy

---
 accumulate.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/accumulate.hpp b/accumulate.hpp
index 9e810dc5..362e5a35 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -71,7 +71,7 @@ namespace iter {
                         acc_val(!(iter != end) ? AccumVal{} : *iter)
                     { } 
 
-                    AccumVal operator*() const {
+                    const AccumVal& operator*() const {
                         return this->acc_val;
                     }
 

From e6a83dc18210be2d6a073d76e722884886553104 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 24 Nov 2014 00:28:23 -0500
Subject: [PATCH 0584/1866] replace enumerate tag in accumulate tests

---
 catchtest/test_accumulate.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/catchtest/test_accumulate.cpp b/catchtest/test_accumulate.cpp
index c52feb33..f251dd03 100644
--- a/catchtest/test_accumulate.cpp
+++ b/catchtest/test_accumulate.cpp
@@ -37,13 +37,13 @@ TEST_CASE("initializer_list works", "[accumulate]") {
     REQUIRE( v == vc );
 }
 
-TEST_CASE("binds reference when it should", "[enumerate]") {
+TEST_CASE("binds reference when it should", "[accumulate]") {
     BasicIterable<int> bi{1, 2};
     accumulate(bi);
     REQUIRE_FALSE( bi.was_moved_from() );
 }
 
-TEST_CASE("moves rvalues into enumerable object", "[enumerate]") {
+TEST_CASE("moves rvalues into accumulator object", "[accumulate]") {
     BasicIterable<int> bi{1, 2};
     accumulate(std::move(bi));
     REQUIRE( bi.was_moved_from() );

From e637d257d37e66ef97e5bfab97f9b4c4335bec55 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 24 Nov 2014 00:28:58 -0500
Subject: [PATCH 0585/1866] Removes boost_tests

it wasn't gonna happen
---
 boost_tests/.gitignore                   |   3 -
 boost_tests/SConstruct                   |  31 -------
 boost_tests/pattern_files/zip_output.txt |  36 --------
 boost_tests/testzip.cpp                  | 106 -----------------------
 4 files changed, 176 deletions(-)
 delete mode 100644 boost_tests/.gitignore
 delete mode 100644 boost_tests/SConstruct
 delete mode 100644 boost_tests/pattern_files/zip_output.txt
 delete mode 100644 boost_tests/testzip.cpp

diff --git a/boost_tests/.gitignore b/boost_tests/.gitignore
deleted file mode 100644
index 5d88f468..00000000
--- a/boost_tests/.gitignore
+++ /dev/null
@@ -1,3 +0,0 @@
-*.o
-*.dblite
-testzip
diff --git a/boost_tests/SConstruct b/boost_tests/SConstruct
deleted file mode 100644
index 13eb390c..00000000
--- a/boost_tests/SConstruct
+++ /dev/null
@@ -1,31 +0,0 @@
-import platform
-import os
-
-env = Environment(
-    CXX='c++',
-    CXXFLAGS= ['-g',  '-Wall', '-Wextra',  '-Weffc++', '-Wno-unused-parameter' ,
-               '-pedantic', '-std=c++11',
-               '-I/usr/local/include', '-I/opt/local/include'],
-    CPPPATH='..',
-    LINKFLAGS=['-L/usr/local/lib', '-L/opt/local/lib']
-    )
-
-# allows highighting to print to terminal from compiler output
-env['ENV']['TERM'] = os.environ['TERM']
-
-# if on MAC, needs the linker flag for -stdlib=libc++
-# obselete with mavericks
-""" if platform.system() == 'Darwin':
-    env['CXX'] += '-stdlib=libc++'
-    env['CXXFLAGS'].append('-stdlib=libc++')
-"""
-
-
-
-progs = Split( '''
-		zip 
-        ''')
-
-
-for p in progs:
-    env.Program('test{0}.cpp'.format(p))
diff --git a/boost_tests/pattern_files/zip_output.txt b/boost_tests/pattern_files/zip_output.txt
deleted file mode 100644
index f2ea8edd..00000000
--- a/boost_tests/pattern_files/zip_output.txt
+++ /dev/null
@@ -1,36 +0,0 @@
-1
-hello
-4
-good day
-9
-goodbye
-69
-hello
-69
-good day
-69
-goodbye
-
-Variadic template zip iterator
-1 1.2 i 1.2
-2 1.4 like 1.2
-3 12.3 apples 1.2
-4 4.5 alot 1.2
-
-1 i 2.2 1.2
-2 like 2.2 1.2
-3 apples 2.2 1.2
-4 alot 2.2 1.2
-
-Try some weird range differences
-
-
-2.2 i 1 1.2
-2.2 like 2 1.2
-2.2 apples 3 1.2
-2.2 alot 4 1.2
-
-1 asdfas 1.1
-5 aaron 2.2
-1 ryan 3.3
-2 apple 4.4
diff --git a/boost_tests/testzip.cpp b/boost_tests/testzip.cpp
deleted file mode 100644
index 802924d3..00000000
--- a/boost_tests/testzip.cpp
+++ /dev/null
@@ -1,106 +0,0 @@
-#include "../zip.hpp"
-#include "../chain.hpp"
-#include <vector>
-#include <string>
-#include <iostream>
-#include <array>
-
-#define BOOST_TEST_MODULE ZipTest test
-
-#ifdef COMPILED_BINARY
-    #include <boost/test/unit_test.hpp>
-#else
-    #include <boost/test/included/unit_test.hpp>
-#endif
-
-#include <boost/test/output_test_stream.hpp>
-using boost::test_tools::output_test_stream;
-
-
-using iter::zip;
-
-BOOST_AUTO_TEST_CASE ( zip_test ) {
-
-    output_test_stream output("pattern_files/zip_output.txt",true);
-    //Ryan's test
-    {
-        std::vector<int> ivec{1, 4, 9, 16, 25, 36};
-        std::vector<std::string> svec{"hello", "good day", "goodbye"};
-
-        for (auto e : zip(ivec, svec)) {
-            auto &i = std::get<0>(e);
-            output << i << std::endl;
-            i = 69;
-            output << std::get<1>(e) << std::endl;
-        }
-        BOOST_REQUIRE(output.match_pattern());
-        for (auto e : zip(ivec, svec)) {
-            output << std::get<0>(e) << std::endl;
-            output << std::get<1>(e) << std::endl;
-        }
-        BOOST_REQUIRE(output.match_pattern());
-    }
-    //Aaron's test
-    {
-        std::array<int,4> i{{1,2,3,4}};
-        std::vector<float> f{1.2,1.4,12.3,4.5,9.9};
-        std::vector<std::string> s{"i","like","apples","alot","dude"};
-        std::array<double,5> d{{1.2,1.2,1.2,1.2,1.2}};
-        output << std::endl << "Variadic template zip iterator" << std::endl;
-        for (auto e : iter::zip(i,f,s,d)) {
-            output << std::get<0>(e) << " " 
-                << std::get<1>(e) << " " 
-                << std::get<2>(e) << " "
-                << std::get<3>(e) << std::endl;
-            std::get<1>(e)=2.2f; //modify the float array
-        }
-        output<<std::endl;
-        BOOST_REQUIRE(output.match_pattern());
-        for (auto e : iter::zip(i,s,f,d)) {
-            output << std::get<0>(e) << " " 
-                << std::get<1>(e) << " "
-                << std::get<2>(e) << " " 
-                << std::get<3>(e) << std::endl;
-        }
-        BOOST_REQUIRE(output.match_pattern());
-        output << std::endl << "Try some weird range differences" << std::endl;
-        std::vector<int> empty{};
-        for (auto e : iter::zip(empty,f,s,d)) {
-            output << std::get<0>(e) << " " 
-                << std::get<1>(e) << " " 
-                << std::get<2>(e) << " "
-                << std::get<3>(e) << std::endl;
-        }
-        output<<std::endl;
-        BOOST_REQUIRE(output.match_pattern());
-        for (auto e : iter::zip(f,s,empty,d)) {
-            output << std::get<0>(e) << " " 
-                << std::get<1>(e) << " " 
-                << std::get<2>(e) << " "
-                << std::get<3>(e) << std::endl;
-        }//both should print nothing
-        output<<std::endl;
-        BOOST_REQUIRE(output.match_pattern());
-        for (auto e : iter::zip(f,s,i,d)) { //i should be the limiter now
-            output << std::get<0>(e) << " " 
-                << std::get<1>(e) << " " 
-                << std::get<2>(e) << " "
-                << std::get<3>(e) << std::endl;
-        }
-        output<<std::endl;
-        BOOST_REQUIRE(output.match_pattern());
-        const std::vector<double> constvector{1.1,2.2,3.3,4.4};
-        for (auto e : zip(iter::chain(std::vector<int>{1,5},std::array<int,2>{{1,2}}),
-                    std::initializer_list<std::string>{"asdfas","aaron","ryan","apple","juice"},
-                    constvector)) 
-        { 
-
-            output << std::get<0>(e) << " " 
-                << std::get<1>(e) << " " 
-                << std::get<2>(e) << std::endl;
-        }
-        BOOST_REQUIRE(output.match_pattern());
-    }
-    BOOST_REQUIRE(output.match_pattern());
-}
-

From 3dbb274b48cbd24838fe83b4fcec8cc90bd258d9 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 26 Nov 2014 16:41:51 -0500
Subject: [PATCH 0586/1866] differs accumulate test names from enumerate

---
 catchtest/test_accumulate.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/catchtest/test_accumulate.cpp b/catchtest/test_accumulate.cpp
index f251dd03..a1cbf92e 100644
--- a/catchtest/test_accumulate.cpp
+++ b/catchtest/test_accumulate.cpp
@@ -29,7 +29,7 @@ TEST_CASE("With subtraction lambda", "[accumulate]") {
     REQUIRE( v == vc );
 }
 
-TEST_CASE("initializer_list works", "[accumulate]") {
+TEST_CASE("accumulate with initializer_list works", "[accumulate]") {
     auto a = accumulate({1, 2, 3});
     Vec v(std::begin(a), std::end(a));
     Vec vc{1, 3, 6};
@@ -37,7 +37,7 @@ TEST_CASE("initializer_list works", "[accumulate]") {
     REQUIRE( v == vc );
 }
 
-TEST_CASE("binds reference when it should", "[accumulate]") {
+TEST_CASE("accumulate binds reference when it should", "[accumulate]") {
     BasicIterable<int> bi{1, 2};
     accumulate(bi);
     REQUIRE_FALSE( bi.was_moved_from() );

From e67b6fd5ecd14f53c6eb59cbfbbcb3e2ef1867a2 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 26 Nov 2014 16:42:03 -0500
Subject: [PATCH 0587/1866] zip iters are input not forward

---
 zip.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/zip.hpp b/zip.hpp
index 240ee0f5..cda4c5c4 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -38,7 +38,7 @@ namespace iter {
 
         public:
             class Iterator :
-                public std::iterator<std::forward_iterator_tag, ZipIterDeref>
+                public std::iterator<std::input_iterator_tag, ZipIterDeref>
         {
                 private:
                     using RestIter =
@@ -94,7 +94,7 @@ namespace iter {
     class Zipped<> {
         public:
             class Iterator
-                : public std::iterator<std::forward_iterator_tag, std::tuple<>>
+                : public std::iterator<std::input_iterator_tag, std::tuple<>>
             {
                 public:
                     constexpr static const bool is_base_iter = true;

From 04a4d373d2401f22d3b9e0f73959e1590d213c71 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 26 Nov 2014 16:42:45 -0500
Subject: [PATCH 0588/1866] accumulate iterators are input not forward

---
 accumulate.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/accumulate.hpp b/accumulate.hpp
index 362e5a35..013a6b2e 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -53,7 +53,7 @@ namespace iter {
         public:
 
             class Iterator 
-                : public std::iterator<std::forward_iterator_tag, AccumVal>
+                : public std::iterator<std::input_iterator_tag, AccumVal>
             {
                 private:
                     iterator_type<Container> sub_iter;

From 46a4fad931ebb40eb84683887c74c906404ddff2 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 26 Nov 2014 17:53:46 -0500
Subject: [PATCH 0589/1866] chain iterators inherit from std::iterator

---
 chain.hpp | 16 ++++++++++++++--
 1 file changed, 14 insertions(+), 2 deletions(-)

diff --git a/chain.hpp b/chain.hpp
index 3d4dc723..10d8a9ac 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -19,6 +19,9 @@ namespace iter {
         friend class ChainMaker;
         template <typename C, typename... RC>
         friend class Chained;
+        
+        using iter_traits_deref =
+            typename std::remove_reference<iterator_deref<Container>>::type;
 
         private:
             Container container;
@@ -29,7 +32,10 @@ namespace iter {
             { }
 
         public:
-            class Iterator {
+            class Iterator
+                : public std::iterator<
+                      std::input_iterator_tag, iter_traits_deref>
+            {
                 private:
                     using RestIter =
                         typename Chained<RestContainers...>::Iterator;
@@ -89,6 +95,9 @@ namespace iter {
         template <typename C, typename... RC>
         friend class Chained;
 
+        using iter_traits_deref =
+            typename std::remove_reference<iterator_deref<Container>>::type;
+
         private:
             Container container;
             Chained(Container container)
@@ -96,7 +105,10 @@ namespace iter {
             { }
 
         public:
-            class Iterator {
+            class Iterator
+                : public std::iterator<
+                      std::input_iterator_tag, iter_traits_deref>
+            {
                 private:
                     iterator_type<Container> sub_iter;
                     const iterator_type<Container> sub_end;

From a24422117617b0af1ad0e4aece08cd1005d21048 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 26 Nov 2014 17:54:14 -0500
Subject: [PATCH 0590/1866] adds basic chain test

---
 catchtest/test_chain.cpp | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 catchtest/test_chain.cpp

diff --git a/catchtest/test_chain.cpp b/catchtest/test_chain.cpp
new file mode 100644
index 00000000..1feac050
--- /dev/null
+++ b/catchtest/test_chain.cpp
@@ -0,0 +1,26 @@
+#include <chain.hpp>
+
+#include <vector>
+#include <list>
+#include <string>
+#include <vector>
+#include <iterator>
+#include <utility>
+
+#include "catch.hpp"
+
+using iter::chain;
+using Vec = const std::vector<char>;
+
+TEST_CASE("chain three strings", "[chain]") {
+    std::string s1{"abc"};
+    std::string s2{"mno"};
+    std::string s3{"xyz"};
+    auto ch = chain(s1, s2, s3);
+
+    Vec v(std::begin(ch), std::end(ch));
+    Vec vc{'a','b','c','m','n','o','x','y','z'};
+
+    REQUIRE( v == vc );
+}
+

From 905669eeb0eb99ff3f3c49d5e5ff060fd63c2aa5 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 26 Nov 2014 17:54:27 -0500
Subject: [PATCH 0591/1866] makes scons build chain test

---
 catchtest/SConstruct | 1 +
 1 file changed, 1 insertion(+)

diff --git a/catchtest/SConstruct b/catchtest/SConstruct
index 181a7ce4..e048c8b9 100644
--- a/catchtest/SConstruct
+++ b/catchtest/SConstruct
@@ -19,6 +19,7 @@ progs = Split(
     zip
     range
     accumulate
+    chain
     '''
 )
 

From 9340b9ad91cf4502887c9ce0d410ddb7cde61520 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 26 Nov 2014 18:09:01 -0500
Subject: [PATCH 0592/1866] chain uses static_assert to check contained types

static_assert is triggered when iterator_deref isn't the same for all
containers.  I have added an are_same to iterbase to do the checking.
it's basically a variadic version of std::is_same.
---
 chain.hpp    |  7 +++++++
 iterbase.hpp | 12 ++++++++++++
 2 files changed, 19 insertions(+)

diff --git a/chain.hpp b/chain.hpp
index 10d8a9ac..5029a9df 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -16,6 +16,13 @@ namespace iter {
 
     template <typename Container, typename... RestContainers>
     class Chained {
+        static_assert(
+                are_same<iterator_deref<Container>,
+                    iterator_deref<RestContainers>...>::value,
+                "All chained iterables must have iterators that "
+                "dereference to the same type, including cv-qualifiers "
+                "and references.");
+
         friend class ChainMaker;
         template <typename C, typename... RC>
         friend class Chained;
diff --git a/iterbase.hpp b/iterbase.hpp
index 15f0a0a0..76eee7b5 100644
--- a/iterbase.hpp
+++ b/iterbase.hpp
@@ -79,6 +79,18 @@ namespace iter {
         typename std::remove_const<
             iterator_deref<Container>>::type>::type;
 
+
+    template <typename... Ts>
+    struct are_same {
+        constexpr static bool value = true;
+    };
+
+    template <typename T, typename U, typename... Ts>
+    struct are_same<T, U, Ts...> {
+        constexpr static bool value =
+            std::is_same<T, U>::value && are_same<T, Ts...>::value;
+    };
+
 }
 
 #endif // #ifndef ITERBASE_HPP_

From 43ba5c7d9a7b3d10829e22b7276772e73200dadd Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 26 Nov 2014 18:34:35 -0500
Subject: [PATCH 0593/1866] tests chain with different container types

---
 catchtest/test_chain.cpp | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/catchtest/test_chain.cpp b/catchtest/test_chain.cpp
index 1feac050..0831abd1 100644
--- a/catchtest/test_chain.cpp
+++ b/catchtest/test_chain.cpp
@@ -24,3 +24,14 @@ TEST_CASE("chain three strings", "[chain]") {
     REQUIRE( v == vc );
 }
 
+TEST_CASE("chain with different container types", "[chain]") {
+    std::string s1{"abc"};
+    std::list<char> li{'m', 'n', 'o'};
+    std::vector<char> vec{'x', 'y', 'z'};
+    auto ch = chain(s1, li, vec);
+
+    Vec v(std::begin(ch), std::end(ch));
+    Vec vc{'a','b','c','m','n','o','x','y','z'};
+
+    REQUIRE( v == vc );
+}

From 6eeebecf45b4dbd921bf57d1720121c54947e764 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 26 Nov 2014 18:54:12 -0500
Subject: [PATCH 0594/1866] adds chain test with empty containers throughout

---
 catchtest/test_chain.cpp | 50 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 50 insertions(+)

diff --git a/catchtest/test_chain.cpp b/catchtest/test_chain.cpp
index 0831abd1..4f716aa7 100644
--- a/catchtest/test_chain.cpp
+++ b/catchtest/test_chain.cpp
@@ -35,3 +35,53 @@ TEST_CASE("chain with different container types", "[chain]") {
 
     REQUIRE( v == vc );
 }
+
+TEST_CASE("chain handles empty containers", "[chain]") {
+    std::string emp;
+    std::string a{"a"};
+    std::string b{"b"};
+    std::string c{"c"};
+    Vec vc{'a', 'b', 'c'};
+
+    SECTION("Empty container at front") {
+        auto ch = chain(emp, a, b, c);
+        Vec v(std::begin(ch), std::end(ch));
+
+        REQUIRE( v == vc );
+    }
+
+    SECTION("Empty container at back") {
+        auto ch = chain(a, b, c, emp);
+        Vec v(std::begin(ch), std::end(ch));
+
+        REQUIRE( v == vc );
+    }
+
+    SECTION("Empty container in middle") {
+        auto ch = chain(a, emp, b, emp, c);
+        Vec v(std::begin(ch), std::end(ch));
+
+        REQUIRE( v == vc );
+    }
+
+    SECTION("Consecutive empty containers at front") {
+        auto ch = chain(emp, emp, a, b, c);
+        Vec v(std::begin(ch), std::end(ch));
+
+        REQUIRE( v == vc );
+    }
+
+    SECTION("Consecutive empty containers at back") {
+        auto ch = chain(a, b, c, emp, emp);
+        Vec v(std::begin(ch), std::end(ch));
+
+        REQUIRE( v == vc );
+    }
+
+    SECTION("Consecutive empty containers in middle") {
+        auto ch = chain(a, emp, emp, b, emp, emp, c);
+        Vec v(std::begin(ch), std::end(ch));
+
+        REQUIRE( v == vc );
+    }
+}

From e72ff1038a0318be44937dcac381edf0722a4c82 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 26 Nov 2014 18:56:53 -0500
Subject: [PATCH 0595/1866] adds chain tests with only empty containers

---
 catchtest/test_chain.cpp | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/catchtest/test_chain.cpp b/catchtest/test_chain.cpp
index 4f716aa7..e01dbed5 100644
--- a/catchtest/test_chain.cpp
+++ b/catchtest/test_chain.cpp
@@ -85,3 +85,21 @@ TEST_CASE("chain handles empty containers", "[chain]") {
         REQUIRE( v == vc );
     }
 }
+
+TEST_CASE("chain with only empty containers", "[chain]") {
+    std::string emp{};
+    SECTION("one empty container") {
+        auto ch = chain(emp);
+        REQUIRE_FALSE( std::begin(ch) != std::end(ch) );
+    }
+
+    SECTION("two empty containers") {
+        auto ch = chain(emp, emp);
+        REQUIRE_FALSE( std::begin(ch) != std::end(ch) );
+    }
+
+    SECTION("three empty containers") {
+        auto ch = chain(emp, emp, emp);
+        REQUIRE_FALSE( std::begin(ch) != std::end(ch) );
+    }
+}

From d840e332a09484c22b99f06dc0862f544c9b7428 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 26 Nov 2014 19:04:19 -0500
Subject: [PATCH 0596/1866] better template meta programming for are_same

---
 iterbase.hpp | 13 +++++--------
 1 file changed, 5 insertions(+), 8 deletions(-)

diff --git a/iterbase.hpp b/iterbase.hpp
index 76eee7b5..3e6f38d5 100644
--- a/iterbase.hpp
+++ b/iterbase.hpp
@@ -12,6 +12,7 @@
 #include <iterator>
 #include <functional>
 #include <cstddef>
+#include <type_traits>
 
 namespace iter {
     // because std::advance assumes a lot and is actually smart, I need a dumb
@@ -81,16 +82,12 @@ namespace iter {
 
 
     template <typename... Ts>
-    struct are_same {
-        constexpr static bool value = true;
-    };
+    struct are_same : std::true_type { };
 
     template <typename T, typename U, typename... Ts>
-    struct are_same<T, U, Ts...> {
-        constexpr static bool value =
-            std::is_same<T, U>::value && are_same<T, Ts...>::value;
-    };
-
+    struct are_same<T, U, Ts...> 
+        : std::integral_constant<bool,
+            std::is_same<T, U>::value && are_same<T, Ts...>::value> { };
 }
 
 #endif // #ifndef ITERBASE_HPP_

From 8ca26267972cb258f72e5ccaf95bf09860dd24f1 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 4 Dec 2014 16:17:36 -0500
Subject: [PATCH 0597/1866] SConstruct gets whole environment

---
 catchtest/SConstruct | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/catchtest/SConstruct b/catchtest/SConstruct
index e048c8b9..22f75cfb 100644
--- a/catchtest/SConstruct
+++ b/catchtest/SConstruct
@@ -1,7 +1,7 @@
 import os
 
 env = Environment(
-    ENV = {'PATH' : os.environ['PATH']},
+    ENV = os.environ,
     CXX='c++',
     CXXFLAGS= ['-g', '-Wall', '-Wextra',
                '-pedantic', '-std=c++11',

From 7766143fe525836c56db91396aa242649ab3957c Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 4 Dec 2014 16:17:51 -0500
Subject: [PATCH 0598/1866] SolidInt is non-movable and non-copyable

---
 catchtest/helpers.hpp | 15 ++-------------
 1 file changed, 2 insertions(+), 13 deletions(-)

diff --git a/catchtest/helpers.hpp b/catchtest/helpers.hpp
index 570373b0..bb034e16 100644
--- a/catchtest/helpers.hpp
+++ b/catchtest/helpers.hpp
@@ -5,11 +5,10 @@
 
 namespace itertest {
 
-// move-constructible only int wrapper
+// non-copyable. non-movable. non-default-constructible
 class SolidInt {
     private:
         const int i;
-        bool made_from_move = false;
     public:
         constexpr SolidInt(int n)
             : i{n}
@@ -23,17 +22,7 @@ class SolidInt {
         SolidInt(const SolidInt&) = delete;
         SolidInt& operator=(const SolidInt&) = delete;
         SolidInt& operator=(SolidInt&&) = delete;
-
-        SolidInt(SolidInt&& other)
-            : i{other.i},
-            made_from_move{true}
-        {
-            if (other.made_from_move) {
-                throw std::invalid_argument{
-                    "Object was constructed with a move ctor"};
-            }
-        }
-
+        SolidInt(SolidInt&&) = delete;
 };
 
 

From 886ceb09a21b791c77daa97b41cbb4f3e763664e Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 4 Dec 2014 16:18:07 -0500
Subject: [PATCH 0599/1866] enumerate test builds SolidInts in place

---
 catchtest/test_enumerate.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/catchtest/test_enumerate.cpp b/catchtest/test_enumerate.cpp
index e9131fe5..b1b10474 100644
--- a/catchtest/test_enumerate.cpp
+++ b/catchtest/test_enumerate.cpp
@@ -102,7 +102,7 @@ TEST_CASE("Works with const iterable", "[enumerate]") {
 }
 
 TEST_CASE("Doesn't move or copy elements of iterable", "[enumerate]") {
-    constexpr SolidInt arr[] = {6, 7, 8};
+    constexpr SolidInt arr[] = {{6}, {7}, {8}};
     for (auto&& i : enumerate(arr)) {
         (void)i;
     }

From 7dcd511a1b7a44efdbcf53b0e7a145430a064989 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 4 Dec 2014 16:18:21 -0500
Subject: [PATCH 0600/1866] zip test builds SolidInts in place

---
 catchtest/test_zip.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/catchtest/test_zip.cpp b/catchtest/test_zip.cpp
index 1374feb1..785f7356 100644
--- a/catchtest/test_zip.cpp
+++ b/catchtest/test_zip.cpp
@@ -86,7 +86,7 @@ TEST_CASE("Can bind ref and move in single zip", "[zip]") {
 }
 
 TEST_CASE("zip doesn't move or copy elements of iterable", "[zip]") {
-    constexpr SolidInt arr[] = {6, 7, 8};
+    constexpr SolidInt arr[] = {{6}, {7}, {8}};
     for (auto&& t : zip(arr)) {
         (void)std::get<0>(t);
     }

From c805865a3fc6ad1ebb6a697420145a52ebd36a35 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 4 Dec 2014 16:31:50 -0500
Subject: [PATCH 0601/1866] tests chain with non-movable

---
 catchtest/test_chain.cpp | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/catchtest/test_chain.cpp b/catchtest/test_chain.cpp
index e01dbed5..d3b2cc94 100644
--- a/catchtest/test_chain.cpp
+++ b/catchtest/test_chain.cpp
@@ -1,3 +1,4 @@
+#include "helpers.hpp"
 #include <chain.hpp>
 
 #include <vector>
@@ -10,6 +11,7 @@
 #include "catch.hpp"
 
 using iter::chain;
+using itertest::SolidInt;
 using Vec = const std::vector<char>;
 
 TEST_CASE("chain three strings", "[chain]") {
@@ -103,3 +105,10 @@ TEST_CASE("chain with only empty containers", "[chain]") {
         REQUIRE_FALSE( std::begin(ch) != std::end(ch) );
     }
 }
+
+TEST_CASE("Chain doesn't move or copy elements of iterable", "[chain]") {
+    constexpr SolidInt arr[] = {{6}, {7}, {8}};
+    for (auto&& i : chain(arr, arr)) {
+        (void)i;
+    }
+}

From 5dc3f014880732f2ddf44445c166d409545a4a89 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 4 Dec 2014 16:44:01 -0500
Subject: [PATCH 0602/1866] tests that chain moves and binds correctly

---
 catchtest/test_chain.cpp | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/catchtest/test_chain.cpp b/catchtest/test_chain.cpp
index d3b2cc94..9d983a7f 100644
--- a/catchtest/test_chain.cpp
+++ b/catchtest/test_chain.cpp
@@ -12,6 +12,7 @@
 
 using iter::chain;
 using itertest::SolidInt;
+using itertest::BasicIterable;
 using Vec = const std::vector<char>;
 
 TEST_CASE("chain three strings", "[chain]") {
@@ -112,3 +113,18 @@ TEST_CASE("Chain doesn't move or copy elements of iterable", "[chain]") {
         (void)i;
     }
 }
+
+TEST_CASE("chain binds reference to lvalue and moves rvalue", "[chain]") {
+    BasicIterable<char> bi{'x', 'y', 'z'};
+    BasicIterable<char> bi2{'a', 'j', 'm'};
+    SECTION("First moved, second ref'd") {
+        chain(std::move(bi), bi2);
+        REQUIRE( bi.was_moved_from() );
+        REQUIRE_FALSE( bi2.was_moved_from() );
+    }
+    SECTION("First ref'd, second moved") {
+        chain(bi, std::move(bi2));
+        REQUIRE_FALSE( bi.was_moved_from() );
+        REQUIRE( bi2.was_moved_from() );
+    }
+}

From f33d563f88ca025b28b399303d876deb0adc63ab Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 4 Dec 2014 23:58:26 -0500
Subject: [PATCH 0603/1866] combination iterator inherits from std::iterator

---
 combinations.hpp | 16 ++++++++++------
 1 file changed, 10 insertions(+), 6 deletions(-)

diff --git a/combinations.hpp b/combinations.hpp
index 2ae69dff..d5b877c1 100644
--- a/combinations.hpp
+++ b/combinations.hpp
@@ -1,5 +1,5 @@
-#ifndef COMBINATIONS_HPP_
-#define COMBINATIONS_HPP_
+#ifndef ITER_COMBINATIONS_HPP_
+#define ITER_COMBINATIONS_HPP_
 
 #include "iterbase.hpp"
 
@@ -35,9 +35,13 @@ namespace iter {
                 length{in_length}
             { }
 
+            using CombIteratorDeref =
+                std::vector<collection_item_type<Container>>;
         public:
 
-        class Iterator {
+        class Iterator :
+            public std::iterator<std::input_iterator_tag, CombIteratorDeref>
+        {
             private:
                 Container& items;
                 std::vector<iterator_type<Container>> indicies;
@@ -66,8 +70,8 @@ namespace iter {
                     }
                 }
 
-                std::vector<collection_item_type<Container>> operator*() {
-                    std::vector<collection_item_type<Container>> values;
+                CombIteratorDeref operator*() {
+                    CombIteratorDeref values;
                     for (auto i : indicies) {
                         values.push_back(*i);
                     }
@@ -141,4 +145,4 @@ namespace iter {
         return {il, length};
     }
 }
-#endif //#ifndef COMBINATIONS_HPP_
+#endif

From a5b60cc6bde696087af3a99eb0c53c674893ddd6 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 4 Dec 2014 23:59:23 -0500
Subject: [PATCH 0604/1866] adds basic combination test

---
 catchtest/test_combinations.cpp | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 catchtest/test_combinations.cpp

diff --git a/catchtest/test_combinations.cpp b/catchtest/test_combinations.cpp
new file mode 100644
index 00000000..e2281d67
--- /dev/null
+++ b/catchtest/test_combinations.cpp
@@ -0,0 +1,27 @@
+#include "helpers.hpp"
+#include <combinations.hpp>
+
+#include <set>
+#include <vector>
+#include <string>
+#include <iterator>
+
+#include "catch.hpp"
+
+
+using iter::combinations;
+using CharCombSet = std::multiset<std::vector<char>>;
+
+TEST_CASE("Simple combination of 4", "[combinations]") {
+    std::string s = "ABCD";
+    CharCombSet sc;
+    for (auto v : combinations(s, 2)) {
+        std::vector<char> vcopy(std::begin(v), std::end(v));
+        sc.insert(vcopy);
+    }
+
+    CharCombSet ans = 
+        {{'A','B'}, {'A','C'}, {'A','D'}, {'B','C'}, {'B','D'}, {'C','D'}};
+    REQUIRE( ans == sc );
+}
+        

From eca7189147afee5c8ea9e3c53194fe7c142b3c8b Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 4 Dec 2014 23:59:32 -0500
Subject: [PATCH 0605/1866] builds combinations test

---
 catchtest/SConstruct | 1 +
 1 file changed, 1 insertion(+)

diff --git a/catchtest/SConstruct b/catchtest/SConstruct
index 22f75cfb..be2907b9 100644
--- a/catchtest/SConstruct
+++ b/catchtest/SConstruct
@@ -20,6 +20,7 @@ progs = Split(
     range
     accumulate
     chain
+    combinations
     '''
 )
 

From a0168f27cd6ad7d7c34ebd06c34ac612a453071a Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 5 Dec 2014 18:52:42 -0500
Subject: [PATCH 0606/1866] tests enum postfix++

---
 catchtest/test_enumerate.cpp | 17 ++++++++++++-----
 1 file changed, 12 insertions(+), 5 deletions(-)

diff --git a/catchtest/test_enumerate.cpp b/catchtest/test_enumerate.cpp
index b1b10474..ed8893e1 100644
--- a/catchtest/test_enumerate.cpp
+++ b/catchtest/test_enumerate.cpp
@@ -25,7 +25,7 @@ using iter::enumerate;
 using itertest::BasicIterable;
 using itertest::SolidInt;
 
-TEST_CASE("Basic Function", "[enumerate]") {
+TEST_CASE("Basic Functioning enumerate", "[enumerate]") {
     std::string str = "abc";
     auto e = enumerate(str);
     Vec v(std::begin(e), std::end(e));
@@ -34,14 +34,21 @@ TEST_CASE("Basic Function", "[enumerate]") {
     REQUIRE( v == vc );
 }
 
-TEST_CASE("Empty", "[enumerate]") {
+TEST_CASE("Empty enumerate", "[enumerate]") {
     std::string emp{};
     auto e = enumerate(emp);
-    Vec v(std::begin(e), std::end(e));
+    REQUIRE( std::begin(e) == std::end(e) );
+}
 
-    REQUIRE( v.empty() );
+TEST_CASE("Postfix ++ enumerate", "[enumerate]") {
+    std::string s{"amz"};
+    auto e = enumerate(s);
+    auto it = std::begin(e);
+    it++;
+    REQUIRE( (*it).first == 2 );
 }
 
+
 TEST_CASE("Modifications through enumerate affect container", "[enumerate]") {
     std::vector<int> v{1, 2, 3, 4};
     std::vector<int> vc(v.size(), -1);
@@ -52,7 +59,7 @@ TEST_CASE("Modifications through enumerate affect container", "[enumerate]") {
     REQUIRE( v == vc );
 }
 
-TEST_CASE("Static array works", "[enumerate]") {
+TEST_CASE("enumerate with static array works", "[enumerate]") {
     char arr[] = {'w', 'x', 'y'};
 
     SECTION("Conversion to vector") {

From 53fdfa86fb94748e8f502d4a7625c1272a2888b3 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 5 Dec 2014 18:53:34 -0500
Subject: [PATCH 0607/1866] adds enumerate == and postfix ++

---
 enumerate.hpp | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/enumerate.hpp b/enumerate.hpp
index 93592838..a3208cda 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -86,9 +86,19 @@ namespace iter {
                         return *this;
                     }
 
+                    Iterator operator++(int) {
+                        auto ret = *this;
+                        ++*this;
+                        return ret;
+                    }
+
                     bool operator!=(const Iterator& other) const {
                         return this->sub_iter != other.sub_iter;
                     }
+
+                    bool operator==(const Iterator& other) const {
+                        return !(*this != other);
+                    }
             };
 
             Iterator begin() {

From f28d2d8e452ad65e04bd85c85c4ce5b9e7307f35 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 5 Dec 2014 19:30:56 -0500
Subject: [PATCH 0608/1866] tests zip postfix++

---
 catchtest/test_zip.cpp | 26 +++++++++++++++++---------
 1 file changed, 17 insertions(+), 9 deletions(-)

diff --git a/catchtest/test_zip.cpp b/catchtest/test_zip.cpp
index 785f7356..ea16877c 100644
--- a/catchtest/test_zip.cpp
+++ b/catchtest/test_zip.cpp
@@ -16,7 +16,7 @@ using iter::zip;
 using itertest::BasicIterable;
 using itertest::SolidInt;
 
-TEST_CASE("Simple case, same length", "[zip]") {
+TEST_CASE("zip: Simple case, same length", "[zip]") {
     using Tu = std::tuple<int, char, double>;
     using ResVec = const std::vector<Tu>;
     std::vector<int> iv {10, 20, 30};
@@ -29,7 +29,7 @@ TEST_CASE("Simple case, same length", "[zip]") {
     REQUIRE( v == vc );
 }
 
-TEST_CASE("One empty, all empty", "[zip]") {
+TEST_CASE("zip: One empty, all empty", "[zip]") {
     std::vector<int> iv = {1,2,3};
     std::string s{};
     auto z = zip(iv, s);
@@ -38,7 +38,7 @@ TEST_CASE("One empty, all empty", "[zip]") {
     REQUIRE_FALSE( std::begin(z2) != std::end(z2) );
 }
 
-TEST_CASE("terminates on shortest sequence", "[zip]") {
+TEST_CASE("zip: terminates on shortest sequence", "[zip]") {
     std::vector<int> iv{1,2,3,4,5};
     std::string s{"hi"};
     auto z = zip(iv, s);
@@ -46,12 +46,12 @@ TEST_CASE("terminates on shortest sequence", "[zip]") {
     REQUIRE( std::distance(std::begin(z), std::end(z)) == 2 );
 }
 
-TEST_CASE("Empty zip()", "[zip]") {
+TEST_CASE("zip: Empty", "[zip]") {
     auto z = zip();
     REQUIRE_FALSE( std::begin(z) != std::end(z) );
 }
 
-TEST_CASE("Modify sequence through zip", "[zip]") {
+TEST_CASE("zip: Modify sequence through zip", "[zip]") {
     std::vector<int> iv{1,2,3};
     std::vector<int> iv2{1,2,3,4};
     for (auto&& t : zip(iv, iv2)) {
@@ -65,19 +65,19 @@ TEST_CASE("Modify sequence through zip", "[zip]") {
     REQUIRE( iv2 == vc2);
 }
 
-TEST_CASE("zip binds reference when it should", "[zip]") {
+TEST_CASE("zip: binds reference when it should", "[zip]") {
     BasicIterable<char> bi{'x', 'y', 'z'};
     zip(bi);
     REQUIRE_FALSE( bi.was_moved_from() );
 }
 
-TEST_CASE("zip moves rvalues", "[zip]") {
+TEST_CASE("zip: moves rvalues", "[zip]") {
     BasicIterable<char> bi{'x', 'y', 'z'};
     zip(std::move(bi));
     REQUIRE( bi.was_moved_from() );
 }
 
-TEST_CASE("Can bind ref and move in single zip", "[zip]") {
+TEST_CASE("zip: Can bind ref and move in single zip", "[zip]") {
     BasicIterable<char> b1{'x', 'y', 'z'};
     BasicIterable<char> b2{'a', 'b'};
     zip(b1, std::move(b2));
@@ -85,9 +85,17 @@ TEST_CASE("Can bind ref and move in single zip", "[zip]") {
     REQUIRE( b2.was_moved_from() );
 }
 
-TEST_CASE("zip doesn't move or copy elements of iterable", "[zip]") {
+TEST_CASE("zip: doesn't move or copy elements of iterable", "[zip]") {
     constexpr SolidInt arr[] = {{6}, {7}, {8}};
     for (auto&& t : zip(arr)) {
         (void)std::get<0>(t);
     }
 }
+
+TEST_CASE("zip: postfix ++", "[zip]") {
+    const std::vector<int> v = {1};
+    auto z = zip(v);
+    auto it = std::begin(z);
+    it++;
+    REQUIRE( !(it != std::end(z)) );
+}

From ac4dd2c7bfc553d6863bf0057edf5f1262fbdf50 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 5 Dec 2014 19:31:07 -0500
Subject: [PATCH 0609/1866] adds zip postfix++

---
 zip.hpp | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/zip.hpp b/zip.hpp
index cda4c5c4..60de9f39 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -59,6 +59,12 @@ namespace iter {
                         return *this;
                     }
 
+                    Iterator operator++(int) {
+                        auto ret = *this;
+                        ++*this;
+                        return ret;
+                    }
+
                     bool operator!=(const Iterator& other) const {
                         return this->iter != other.iter &&
                             (RestIter::is_base_iter ||
@@ -107,6 +113,10 @@ namespace iter {
                         return *this;
                     }
 
+                    Iterator operator++(int) {
+                        return *this;
+                    }
+
                     // if this were to return true, there would be no need
                     // for the is_base_iter static class attribute.
                     // However, returning false causes an empty zip() call

From 98f17875812f382815e579d7003f8d78a045ac77 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 5 Dec 2014 19:34:18 -0500
Subject: [PATCH 0610/1866] uses zip == instead of !(!=)

---
 catchtest/test_zip.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/catchtest/test_zip.cpp b/catchtest/test_zip.cpp
index ea16877c..106c9444 100644
--- a/catchtest/test_zip.cpp
+++ b/catchtest/test_zip.cpp
@@ -97,5 +97,5 @@ TEST_CASE("zip: postfix ++", "[zip]") {
     auto z = zip(v);
     auto it = std::begin(z);
     it++;
-    REQUIRE( !(it != std::end(z)) );
+    REQUIRE( it == std::end(z) );
 }

From 7af01fb49bee4975bf2d8377798710ab0d3d63f4 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 5 Dec 2014 19:34:31 -0500
Subject: [PATCH 0611/1866] adds zip ==

---
 zip.hpp | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/zip.hpp b/zip.hpp
index 60de9f39..1319254a 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -71,6 +71,10 @@ namespace iter {
                                 this->rest_iter != other.rest_iter);
                     }
 
+                    bool operator==(const Iterator& other) const {
+                        return !(*this == other);
+                    }
+
                     auto operator*() ->
                         decltype(std::tuple_cat(
                                     std::tuple<iterator_deref<Container>>{
@@ -126,6 +130,10 @@ namespace iter {
                         return false;
                     }
 
+                    bool operator==(const Iterator& other) const {
+                        return !(*this != other);
+                    }
+
                     std::tuple<> operator*() {
                         return std::tuple<>{};
                     }

From 79f51631af95ae650b038c1ff9f174161c1d1df8 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 5 Dec 2014 19:44:25 -0500
Subject: [PATCH 0612/1866] uses range == in test

---
 catchtest/test_range.cpp | 19 +++++++++----------
 1 file changed, 9 insertions(+), 10 deletions(-)

diff --git a/catchtest/test_range.cpp b/catchtest/test_range.cpp
index 7c853595..94c51270 100644
--- a/catchtest/test_range.cpp
+++ b/catchtest/test_range.cpp
@@ -10,7 +10,7 @@ using Vec = const std::vector<int>;
 using iter::range;
 
 
-TEST_CASE("Range works with only stop", "[range]") {
+TEST_CASE("range: works with only stop", "[range]") {
     auto r = range(5);
     Vec v(std::begin(r), std::end(r));
     Vec vc{0, 1, 2, 3, 4};
@@ -18,7 +18,7 @@ TEST_CASE("Range works with only stop", "[range]") {
     REQUIRE( v == vc );
 }
 
-TEST_CASE("Range works with start and stop", "[range]") {
+TEST_CASE("range: works with start and stop", "[range]") {
     auto r = range(1, 5);
     Vec v(std::begin(r), std::end(r));
     Vec vc {1, 2, 3, 4};
@@ -26,7 +26,7 @@ TEST_CASE("Range works with start and stop", "[range]") {
     REQUIRE( v == vc );
 }
 
-TEST_CASE("Range works with positive step > 1", "[range]") {
+TEST_CASE("range: works with positive step > 1", "[range]") {
     auto r = range(1, 10, 3);
     Vec v(std::begin(r), std::end(r));
     Vec vc{1, 4, 7};
@@ -36,8 +36,7 @@ TEST_CASE("Range works with positive step > 1", "[range]") {
 
 TEST_CASE("range(0) is empty", "[range]") {
     auto r = iter::range(0);
-    Vec v(std::begin(r), std::end(r));
-    REQUIRE( v.empty() );
+    REQUIRE( std::begin(r) == std::end(r) );
 }
 
 TEST_CASE("start > stop produces empty range", "[range]") {
@@ -52,14 +51,14 @@ TEST_CASE("start < stop and step < 0 produces empty range", "[range]") {
     REQUIRE( v.empty() );
 }
 
-TEST_CASE("Range with only a negative stop is empty", "[range]") {
+TEST_CASE("range: with only a negative stop is empty", "[range]") {
     auto r = range(-3);
     Vec v(std::begin(r), std::end(r));
 
     REQUIRE( v.empty() );
 }
 
-TEST_CASE("Range works with negative step", "[range]") {
+TEST_CASE("range: works with negative step", "[range]") {
     auto r = range(5, -5, -3);
     Vec v(std::begin(r), std::end(r));
     Vec vc{5, 2, -1, -4};
@@ -67,7 +66,7 @@ TEST_CASE("Range works with negative step", "[range]") {
     REQUIRE( v == vc );
 }
 
-TEST_CASE("Range stops short when step doesn't divide stop-start", "[range]") {
+TEST_CASE("range: stops short when step doesn't divide stop-start", "[range]") {
     auto r = range(0, 5, 2);
     Vec v(std::begin(r), std::end(r));
     Vec vc{0, 2, 4};
@@ -76,7 +75,7 @@ TEST_CASE("Range stops short when step doesn't divide stop-start", "[range]") {
 
 }
 
-TEST_CASE("Range stops short when step > stop-start", "[range]") {
+TEST_CASE("range: stops short when step > stop-start", "[range]") {
     auto r = range(0, 10, 20);
     Vec v(std::begin(r), std::end(r));
     REQUIRE( v.size() == 1 );
@@ -86,7 +85,7 @@ TEST_CASE("No 0 step ranges allowed", "[range]") {
     REQUIRE_THROWS(range(0, 1, 0));
 }
 
-TEST_CASE("Range works with a variable start, stop, and step", "[range]") {
+TEST_CASE("range: works with a variable start, stop, and step", "[range]") {
     constexpr int a = 10;
     constexpr int b = 100;
     constexpr int c = 50;

From c3e0cde6a81b7e530dc5216ffd6668e382d1ccd2 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 5 Dec 2014 19:44:38 -0500
Subject: [PATCH 0613/1866] adds == to range

---
 range.hpp | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/range.hpp b/range.hpp
index f54de39f..c3cacab2 100644
--- a/range.hpp
+++ b/range.hpp
@@ -111,10 +111,18 @@ namespace iter {
                     // 2) (stop - start) % step != 0.  For
                     // example Range(1, 10, 2).  The iterator will never be
                     // exactly equal to the stop value.
+                    //
+                    // Another way to think about it is that the "end"
+                    // iterator represents the range of values that are invalid
+                    // So, if an iterator is not equal to that, it is valid
                     bool operator!=(const Iterator& other) const { 
                         return not_equal_to(
                                 other, typename std::is_unsigned<T>::type());
                     }
+
+                    bool operator==(const Iterator& other) const {
+                        return !(*this != other);
+                    }
             };
 
             Iterator begin() const {
@@ -140,7 +148,7 @@ namespace iter {
     template <typename T>
     Range<T> range(T start, T stop, T step) {
         if (step == 0) {
-            throw RangeException();
+            throw RangeException{};
         }
         return {start, stop, step};
     }

From 37872c175f2cc0e939173bd2bd4811c31e4e516f Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 5 Dec 2014 19:47:44 -0500
Subject: [PATCH 0614/1866] tests for postfix ++

---
 catchtest/test_range.cpp | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/catchtest/test_range.cpp b/catchtest/test_range.cpp
index 94c51270..9a0bee9e 100644
--- a/catchtest/test_range.cpp
+++ b/catchtest/test_range.cpp
@@ -39,6 +39,13 @@ TEST_CASE("range(0) is empty", "[range]") {
     REQUIRE( std::begin(r) == std::end(r) );
 }
 
+TEST_CASE("range: postfix++", "[range]") {
+    auto r = iter::range(3);
+    auto it = std::begin(r);
+    it++;
+    REQUIRE( *it == 1 );
+}
+
 TEST_CASE("start > stop produces empty range", "[range]") {
     auto r = range(5, 0);
     Vec v(std::begin(r), std::end(r));

From 63c7715c5ea8cec84b78d22982b6567b56ba3da4 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 5 Dec 2014 19:48:29 -0500
Subject: [PATCH 0615/1866] adds range postfix ++

---
 range.hpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/range.hpp b/range.hpp
index c3cacab2..6366e727 100644
--- a/range.hpp
+++ b/range.hpp
@@ -98,6 +98,12 @@ namespace iter {
                         return *this;
                     }
 
+                    Iterator operator++(int) {
+                        auto ret = *this;
+                        ++*this;
+                        return ret;
+                    }
+
                     // This operator would more accurately read as "in bounds"
                     // or "incomplete" because exact comparison with the end
                     // isn't good enough for the purposes of this Iterator.

From 3857d8b8316edaadebe7da2559225d1e38948d80 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 5 Dec 2014 19:57:00 -0500
Subject: [PATCH 0616/1866] fixes enumerate test

---
 catchtest/test_enumerate.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/catchtest/test_enumerate.cpp b/catchtest/test_enumerate.cpp
index ed8893e1..6fb747b8 100644
--- a/catchtest/test_enumerate.cpp
+++ b/catchtest/test_enumerate.cpp
@@ -45,7 +45,7 @@ TEST_CASE("Postfix ++ enumerate", "[enumerate]") {
     auto e = enumerate(s);
     auto it = std::begin(e);
     it++;
-    REQUIRE( (*it).first == 2 );
+    REQUIRE( (*it).first == 1 );
 }
 
 

From 5596909f0004bf2160cb0946d4f6129b13dfa5ff Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 5 Dec 2014 19:57:59 -0500
Subject: [PATCH 0617/1866] tests accumulate ==

---
 catchtest/test_accumulate.cpp | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

diff --git a/catchtest/test_accumulate.cpp b/catchtest/test_accumulate.cpp
index a1cbf92e..00a9cd4e 100644
--- a/catchtest/test_accumulate.cpp
+++ b/catchtest/test_accumulate.cpp
@@ -20,7 +20,7 @@ TEST_CASE("Simple sum", "[accumulate]") {
     REQUIRE( v == vc );
 }
 
-TEST_CASE("With subtraction lambda", "[accumulate]") {
+TEST_CASE("accumulate: With subtraction lambda", "[accumulate]") {
     Vec ns{5,4,3,2,1};
     auto a = accumulate(ns, [](int a, int b){return a - b; });
 
@@ -29,7 +29,7 @@ TEST_CASE("With subtraction lambda", "[accumulate]") {
     REQUIRE( v == vc );
 }
 
-TEST_CASE("accumulate with initializer_list works", "[accumulate]") {
+TEST_CASE("accumulate: with initializer_list works", "[accumulate]") {
     auto a = accumulate({1, 2, 3});
     Vec v(std::begin(a), std::end(a));
     Vec vc{1, 3, 6};
@@ -37,14 +37,20 @@ TEST_CASE("accumulate with initializer_list works", "[accumulate]") {
     REQUIRE( v == vc );
 }
 
-TEST_CASE("accumulate binds reference when it should", "[accumulate]") {
+TEST_CASE("accumulate: binds reference when it should", "[accumulate]") {
     BasicIterable<int> bi{1, 2};
     accumulate(bi);
     REQUIRE_FALSE( bi.was_moved_from() );
 }
 
-TEST_CASE("moves rvalues into accumulator object", "[accumulate]") {
+TEST_CASE("accumulate: moves rvalues when it should", "[accumulate]") {
     BasicIterable<int> bi{1, 2};
     accumulate(std::move(bi));
     REQUIRE( bi.was_moved_from() );
 }
+
+TEST_CASE("accumulate: operator==", "[accumulate]") {
+    std::vector<int> v;
+    auto a = accumulate(v);
+    REQUIRE( std::begin(a) == std::end(a) );
+}

From 60127da7362ee2acaf73b82e53f4b963cb4a7499 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 5 Dec 2014 19:58:08 -0500
Subject: [PATCH 0618/1866] adds == to accumulate

---
 accumulate.hpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/accumulate.hpp b/accumulate.hpp
index 013a6b2e..97619ac2 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -87,6 +87,10 @@ namespace iter {
                     bool operator!=(const Iterator& other) const {
                         return this->sub_iter != other.sub_iter;
                     }
+
+                    bool operator==(const Iterator& other) const {
+                        return !(*this != other);
+                    }
             };
 
             Iterator begin() {

From 86c1d59072ffadd3b8ae7279c3cc0adf9ecf5e81 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 5 Dec 2014 20:00:52 -0500
Subject: [PATCH 0619/1866] tests accumulate postfix ++

---
 catchtest/test_accumulate.cpp | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/catchtest/test_accumulate.cpp b/catchtest/test_accumulate.cpp
index 00a9cd4e..7912d8d5 100644
--- a/catchtest/test_accumulate.cpp
+++ b/catchtest/test_accumulate.cpp
@@ -50,7 +50,16 @@ TEST_CASE("accumulate: moves rvalues when it should", "[accumulate]") {
 }
 
 TEST_CASE("accumulate: operator==", "[accumulate]") {
-    std::vector<int> v;
+    Vec v;
     auto a = accumulate(v);
     REQUIRE( std::begin(a) == std::end(a) );
 }
+
+TEST_CASE("accumulate: postfix ++", "[accumulate]") {
+    Vec ns{2,3};
+    auto a = accumulate(ns);
+    auto it = std::begin(a);
+    it++;
+    REQUIRE( *it == 5 );
+}
+

From 9c32be51c13eb332ada95386a500b07eb384a06e Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 5 Dec 2014 20:01:01 -0500
Subject: [PATCH 0620/1866] adds accumulate postfix ++

---
 accumulate.hpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/accumulate.hpp b/accumulate.hpp
index 97619ac2..218c98cb 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -84,6 +84,12 @@ namespace iter {
                         return *this;
                     }
 
+                    Iterator operator++(int) {
+                        auto ret = *this;
+                        ++*this;
+                        return ret;
+                    }
+
                     bool operator!=(const Iterator& other) const {
                         return this->sub_iter != other.sub_iter;
                     }

From 8dfc5b1f38710ffd5a07fd185a51fe98f2a37e16 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 5 Dec 2014 20:14:08 -0500
Subject: [PATCH 0621/1866] adds chain test for ==

---
 catchtest/test_chain.cpp | 18 ++++++++++++------
 1 file changed, 12 insertions(+), 6 deletions(-)

diff --git a/catchtest/test_chain.cpp b/catchtest/test_chain.cpp
index 9d983a7f..6ed0e365 100644
--- a/catchtest/test_chain.cpp
+++ b/catchtest/test_chain.cpp
@@ -15,7 +15,7 @@ using itertest::SolidInt;
 using itertest::BasicIterable;
 using Vec = const std::vector<char>;
 
-TEST_CASE("chain three strings", "[chain]") {
+TEST_CASE("chain: three strings", "[chain]") {
     std::string s1{"abc"};
     std::string s2{"mno"};
     std::string s3{"xyz"};
@@ -27,7 +27,7 @@ TEST_CASE("chain three strings", "[chain]") {
     REQUIRE( v == vc );
 }
 
-TEST_CASE("chain with different container types", "[chain]") {
+TEST_CASE("chain: with different container types", "[chain]") {
     std::string s1{"abc"};
     std::list<char> li{'m', 'n', 'o'};
     std::vector<char> vec{'x', 'y', 'z'};
@@ -39,7 +39,7 @@ TEST_CASE("chain with different container types", "[chain]") {
     REQUIRE( v == vc );
 }
 
-TEST_CASE("chain handles empty containers", "[chain]") {
+TEST_CASE("chain: handles empty containers", "[chain]") {
     std::string emp;
     std::string a{"a"};
     std::string b{"b"};
@@ -89,7 +89,7 @@ TEST_CASE("chain handles empty containers", "[chain]") {
     }
 }
 
-TEST_CASE("chain with only empty containers", "[chain]") {
+TEST_CASE("chain: with only empty containers", "[chain]") {
     std::string emp{};
     SECTION("one empty container") {
         auto ch = chain(emp);
@@ -107,14 +107,14 @@ TEST_CASE("chain with only empty containers", "[chain]") {
     }
 }
 
-TEST_CASE("Chain doesn't move or copy elements of iterable", "[chain]") {
+TEST_CASE("chain: doesn't move or copy elements of iterable", "[chain]") {
     constexpr SolidInt arr[] = {{6}, {7}, {8}};
     for (auto&& i : chain(arr, arr)) {
         (void)i;
     }
 }
 
-TEST_CASE("chain binds reference to lvalue and moves rvalue", "[chain]") {
+TEST_CASE("chain: binds reference to lvalue and moves rvalue", "[chain]") {
     BasicIterable<char> bi{'x', 'y', 'z'};
     BasicIterable<char> bi2{'a', 'j', 'm'};
     SECTION("First moved, second ref'd") {
@@ -128,3 +128,9 @@ TEST_CASE("chain binds reference to lvalue and moves rvalue", "[chain]") {
         REQUIRE( bi2.was_moved_from() );
     }
 }
+
+TEST_CASE("chain: operator==", "[chain]") {
+    std::string emp{};
+    auto ch = chain(emp);
+    REQUIRE( std::begin(ch) == std::end(ch) );
+}

From 3b381e32dd4fc8dc5349a2e3405aa7653115d177 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 5 Dec 2014 20:14:20 -0500
Subject: [PATCH 0622/1866] adds chain ==

---
 chain.hpp | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/chain.hpp b/chain.hpp
index 5029a9df..ae086782 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -78,6 +78,10 @@ namespace iter {
                             this->rest_iter != other.rest_iter;
                     }
 
+                    bool operator==(const Iterator& other) const {
+                        return !(*this != other);
+                    }
+
                     iterator_deref<Container> operator*() {
                         return this->at_end ?
                             *this->rest_iter : *this->sub_iter;
@@ -136,6 +140,10 @@ namespace iter {
                         return this->sub_iter != other.sub_iter;
                     }
 
+                    bool operator==(const Iterator& other) const {
+                        return !(*this != other);
+                    }
+
                     iterator_deref<Container> operator*() {
                         return *this->sub_iter;
                     }
@@ -206,6 +214,10 @@ namespace iter {
                             *this->sub_iter_p != *other.sub_iter_p);
                    }
 
+                   bool operator==(const Iterator& other) const {
+                       return !(*this != other);
+                   }
+
                    iterator_deref<iterator_deref<Container>> operator*() {
                        return **this->sub_iter_p;
                    }

From 7324e54203355cf82093aa82e1c2638b1e1acd2e Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 5 Dec 2014 20:18:23 -0500
Subject: [PATCH 0623/1866] tests chain postfix ++

---
 catchtest/test_chain.cpp | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/catchtest/test_chain.cpp b/catchtest/test_chain.cpp
index 6ed0e365..05a9b165 100644
--- a/catchtest/test_chain.cpp
+++ b/catchtest/test_chain.cpp
@@ -134,3 +134,12 @@ TEST_CASE("chain: operator==", "[chain]") {
     auto ch = chain(emp);
     REQUIRE( std::begin(ch) == std::end(ch) );
 }
+
+TEST_CASE("chain: postfix ++", "[chain]") {
+    std::string s1{"a"}, s2{"b"};
+    auto ch = chain(s1, s2);
+    auto it = std::begin(ch);
+    it++;
+    REQUIRE( *it == 'b');
+}
+

From 8b629b7aeb1140f3cb6190f4e53276fa9c56357c Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 5 Dec 2014 20:18:35 -0500
Subject: [PATCH 0624/1866] adds chain postfix ++

---
 chain.hpp | 20 +++++++++++++++++++-
 1 file changed, 19 insertions(+), 1 deletion(-)

diff --git a/chain.hpp b/chain.hpp
index ae086782..4e74a95b 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -73,6 +73,12 @@ namespace iter {
                         return *this;
                     }
 
+                    Iterator operator++(int) {
+                        auto ret = *this;
+                        ++*this;
+                        return ret;
+                    }
+
                     bool operator!=(const Iterator& other) const {
                         return this->sub_iter != other.sub_iter ||
                             this->rest_iter != other.rest_iter;
@@ -136,6 +142,12 @@ namespace iter {
                         return *this;
                     }
 
+                    Iterator operator++(int) {
+                        auto ret = *this;
+                        ++*this;
+                        return ret;
+                    }
+
                     bool operator!=(const Iterator& other) const {
                         return this->sub_iter != other.sub_iter;
                     }
@@ -206,7 +218,13 @@ namespace iter {
                        }
                        return *this;
                    }
-                       
+
+
+                   Iterator operator++(int) {
+                       auto ret = *this;
+                       ++*this;
+                       return ret;
+                   }
 
                    bool operator!=(const Iterator& other) const {
                        return this->top_level_iter != other.top_level_iter &&

From 610c7bdd15e15513daced8f81e375b53053499ee Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 5 Dec 2014 21:13:17 -0500
Subject: [PATCH 0625/1866] adds iterator_traits_deref

Gives the type returned from dereferencing an iterator with any
references removed.
---
 iterbase.hpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/iterbase.hpp b/iterbase.hpp
index 3e6f38d5..0ce5d441 100644
--- a/iterbase.hpp
+++ b/iterbase.hpp
@@ -56,6 +56,10 @@ namespace iter {
     using iterator_deref = 
         decltype(*std::declval<iterator_type<Container>&>());
 
+    template <typename Container>
+    using iterator_traits_deref =
+        typename std::remove_reference<iterator_deref<Container>>::type;
+
     // iterator_type<C> is the type of C's iterator
     template <typename Container>
     using reverse_iterator_type =

From 7cae42e3e0e016d316ca75a2584b41e049126d58 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 5 Dec 2014 21:14:12 -0500
Subject: [PATCH 0626/1866] adds chain.from_iterable basic test

---
 catchtest/test_chain.cpp | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/catchtest/test_chain.cpp b/catchtest/test_chain.cpp
index 05a9b165..a5651b6a 100644
--- a/catchtest/test_chain.cpp
+++ b/catchtest/test_chain.cpp
@@ -143,3 +143,12 @@ TEST_CASE("chain: postfix ++", "[chain]") {
     REQUIRE( *it == 'b');
 }
 
+
+TEST_CASE("chain.from_iterable: basic test", "chain.from_iterable") {
+    std::vector<std::string> sv{"abc", "xyz"};
+    auto ch = chain.from_iterable(sv);
+    std::vector<char> v(std::begin(ch), std::end(ch));
+
+    std::vector<char> vc{'a', 'b', 'c', 'x', 'y', 'z'};
+    REQUIRE( v == vc );
+}

From bcb726b9284464366a01520ae6fd4d3748365c29 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 5 Dec 2014 21:14:50 -0500
Subject: [PATCH 0627/1866] Makes chain iterator copy constructible

also uses the iterbase iterator_traits_deref
---
 chain.hpp | 26 +++++++++++++++++---------
 1 file changed, 17 insertions(+), 9 deletions(-)

diff --git a/chain.hpp b/chain.hpp
index 4e74a95b..addb041c 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -27,9 +27,6 @@ namespace iter {
         template <typename C, typename... RC>
         friend class Chained;
         
-        using iter_traits_deref =
-            typename std::remove_reference<iterator_deref<Container>>::type;
-
         private:
             Container container;
             Chained<RestContainers...> rest_chained;
@@ -41,7 +38,8 @@ namespace iter {
         public:
             class Iterator
                 : public std::iterator<
-                      std::input_iterator_tag, iter_traits_deref>
+                      std::input_iterator_tag,
+                      iterator_traits_deref<Container>>
             {
                 private:
                     using RestIter =
@@ -112,9 +110,6 @@ namespace iter {
         template <typename C, typename... RC>
         friend class Chained;
 
-        using iter_traits_deref =
-            typename std::remove_reference<iterator_deref<Container>>::type;
-
         private:
             Container container;
             Chained(Container container)
@@ -124,7 +119,8 @@ namespace iter {
         public:
             class Iterator
                 : public std::iterator<
-                      std::input_iterator_tag, iter_traits_deref>
+                      std::input_iterator_tag,
+                      iterator_traits_deref<Container>>
             {
                 private:
                     iterator_type<Container> sub_iter;
@@ -182,7 +178,10 @@ namespace iter {
             { }
 
         public:
-            class Iterator {
+            class Iterator
+                :public std::iterator<std::input_iterator_tag,
+                    iterator_traits_deref<iterator_deref<Container>>>
+            {
                 private:
                     using SubContainer = iterator_deref<Container>;
                     using SubIter = iterator_type<SubContainer>;
@@ -202,6 +201,15 @@ namespace iter {
                            nullptr : new SubIter{std::end(*top_iter)}}
                    { }
 
+                   Iterator(const Iterator& other)
+                       : top_level_iter{other.top_level_iter},
+                       top_level_end{other.top_level_end},
+                       sub_iter_p{other.sub_iter_p ?
+                           new SubIter{*other.sub_iter_p} : nullptr},
+                       sub_end_p{other.sub_end_p ?
+                           new SubIter{*other.sub_end_p} : nullptr}
+                   { }
+
                    Iterator& operator++() {
                        ++*this->sub_iter_p;
                        if (!(*this->sub_iter_p != *this->sub_end_p)) {

From ebb1cf5bebc7e68e1f01c8add327dfec88ea523a Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 5 Dec 2014 23:19:10 -0500
Subject: [PATCH 0628/1866] tests chain.from_iterable more

---
 catchtest/test_chain.cpp | 43 +++++++++++++++++++++++++++++++++++++++-
 1 file changed, 42 insertions(+), 1 deletion(-)

diff --git a/catchtest/test_chain.cpp b/catchtest/test_chain.cpp
index a5651b6a..19655c81 100644
--- a/catchtest/test_chain.cpp
+++ b/catchtest/test_chain.cpp
@@ -144,7 +144,7 @@ TEST_CASE("chain: postfix ++", "[chain]") {
 }
 
 
-TEST_CASE("chain.from_iterable: basic test", "chain.from_iterable") {
+TEST_CASE("chain.from_iterable: basic test", "[chain.from_iterable]") {
     std::vector<std::string> sv{"abc", "xyz"};
     auto ch = chain.from_iterable(sv);
     std::vector<char> v(std::begin(ch), std::end(ch));
@@ -152,3 +152,44 @@ TEST_CASE("chain.from_iterable: basic test", "chain.from_iterable") {
     std::vector<char> vc{'a', 'b', 'c', 'x', 'y', 'z'};
     REQUIRE( v == vc );
 }
+
+TEST_CASE("chain.from_iterable: iterators cant be copy constructed "
+        "and assigned", "[chain.from_iterable]") {
+    std::vector<std::string> sv{"abc", "xyz"};
+    auto ch = chain.from_iterable(sv);
+    auto it = std::begin(ch);
+
+    SECTION("Copy constructed") {
+        auto it2 = it;
+        ++it;
+        REQUIRE( it != it2 );
+    }
+
+    SECTION("Copy assigned") {
+        auto it2 = std::end(ch);
+        it2 = it;
+        REQUIRE( it == it2 );
+    }
+}
+
+TEST_CASE("chain.from_iterable: postfix ++", "[chain.from_iterable]") {
+    std::vector<std::string> sv{"a", "n"};
+    auto ch = chain.from_iterable(sv);
+    auto it = std::begin(ch);
+    it++;
+    REQUIRE( *it == 'n' );
+}
+
+
+TEST_CASE("chain.from_iterable: moves rvalues and binds ref to lvalues",
+        "[chain.from_iterable]") {
+    BasicIterable<std::string> bi{"abc", "xyz"};
+    SECTION("Moves rvalue") {
+        chain.from_iterable(std::move(bi));
+        REQUIRE( bi.was_moved_from() );
+    }
+    SECTION("Binds ref to lvalue") {
+        chain.from_iterable(bi);
+        REQUIRE_FALSE( bi.was_moved_from() );
+    }
+}

From 29e89e4689ae033058ab6ce12bdfe694d92bfcc5 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 5 Dec 2014 23:19:17 -0500
Subject: [PATCH 0629/1866] completes chain.from_iterable iterators

---
 chain.hpp | 50 ++++++++++++++++++++++++++++++++++++++++++--------
 1 file changed, 42 insertions(+), 8 deletions(-)

diff --git a/chain.hpp b/chain.hpp
index addb041c..399ea3e9 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -187,9 +187,29 @@ namespace iter {
                     using SubIter = iterator_type<SubContainer>;
 
                    iterator_type<Container> top_level_iter;
-                   const iterator_type<Container> top_level_end;
+                   iterator_type<Container> top_level_end;
                    std::unique_ptr<SubIter> sub_iter_p;
                    std::unique_ptr<SubIter> sub_end_p;
+
+                   static std::unique_ptr<SubIter> clone_sub_pointer(
+                           const SubIter* sub_iter) {
+                       return std::unique_ptr<SubIter>{ sub_iter ?
+                           new SubIter{*sub_iter} : nullptr};
+                   }
+
+                   bool sub_iters_differ(const Iterator& other) const {
+                       if (this->sub_iter_p == other.sub_iter_p) {
+                           return false;
+                       }
+                       if (this->sub_iter_p == nullptr
+                               || other.sub_iter_p == nullptr) {
+                           // since the first check tests if they're the same,
+                           // this will return if only one is nullptr
+                           return true;
+                       }
+                       return *this->sub_iter_p != *other.sub_iter_p;
+                   }
+
                 public:
                    Iterator(iterator_type<Container> top_iter,
                            iterator_type<Container> top_end)
@@ -204,12 +224,27 @@ namespace iter {
                    Iterator(const Iterator& other)
                        : top_level_iter{other.top_level_iter},
                        top_level_end{other.top_level_end},
-                       sub_iter_p{other.sub_iter_p ?
-                           new SubIter{*other.sub_iter_p} : nullptr},
-                       sub_end_p{other.sub_end_p ?
-                           new SubIter{*other.sub_end_p} : nullptr}
+                       sub_iter_p{clone_sub_pointer(other.sub_iter_p.get())},
+                       sub_end_p{clone_sub_pointer(other.sub_end_p.get())}
                    { }
 
+                   Iterator& operator=(const Iterator& other) {
+                       if (this == &other) return *this;
+
+                       this->top_level_iter = other.top_level_iter;
+                       this->top_level_end = other.top_level_end;
+                       this->sub_iter_p =
+                               clone_sub_pointer(other.sub_iter_p.get());
+                       this->sub_end_p =
+                               clone_sub_pointer(other.sub_end_p.get());
+
+                       return *this;
+                   }
+
+                   Iterator(Iterator&&) = default;
+                   Iterator& operator=(Iterator&&) = default;
+                   ~Iterator() = default;
+
                    Iterator& operator++() {
                        ++*this->sub_iter_p;
                        if (!(*this->sub_iter_p != *this->sub_end_p)) {
@@ -235,9 +270,8 @@ namespace iter {
                    }
 
                    bool operator!=(const Iterator& other) const {
-                       return this->top_level_iter != other.top_level_iter &&
-                           (this->sub_iter_p != other.sub_iter_p ||
-                            *this->sub_iter_p != *other.sub_iter_p);
+                       return this->top_level_iter != other.top_level_iter
+                            || this->sub_iters_differ(other);
                    }
 
                    bool operator==(const Iterator& other) const {

From b0a34e8ec402b1ce1389c26a7b56dd07c807f9a9 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 6 Dec 2014 01:02:26 -0500
Subject: [PATCH 0630/1866] tests chain with empty chain

---
 catchtest/test_chain.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/catchtest/test_chain.cpp b/catchtest/test_chain.cpp
index 19655c81..23aa98f4 100644
--- a/catchtest/test_chain.cpp
+++ b/catchtest/test_chain.cpp
@@ -193,3 +193,9 @@ TEST_CASE("chain.from_iterable: moves rvalues and binds ref to lvalues",
         REQUIRE_FALSE( bi.was_moved_from() );
     }
 }
+
+TEST_CASE("chain.from_iterable: empty", "[empty]") {
+    const std::vector<std::string> v{};
+    auto ch = chain.from_iterable(v);
+    REQUIRE( std::begin(ch) == std::end(ch) );
+}

From 3302daca1a9a285c1ce4994dd50b7483f063f746 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 6 Dec 2014 01:04:02 -0500
Subject: [PATCH 0631/1866] fixes recursive == in zip

---
 zip.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/zip.hpp b/zip.hpp
index 1319254a..a77061bf 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -72,7 +72,7 @@ namespace iter {
                     }
 
                     bool operator==(const Iterator& other) const {
-                        return !(*this == other);
+                        return !(*this != other);
                     }
 
                     auto operator*() ->

From 38121285798f169c2a3b264712bac8740ebbc248 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 6 Dec 2014 01:11:50 -0500
Subject: [PATCH 0632/1866] Adds combinations test where length is too big

---
 catchtest/test_combinations.cpp | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/catchtest/test_combinations.cpp b/catchtest/test_combinations.cpp
index e2281d67..5f0b7b7d 100644
--- a/catchtest/test_combinations.cpp
+++ b/catchtest/test_combinations.cpp
@@ -12,8 +12,8 @@
 using iter::combinations;
 using CharCombSet = std::multiset<std::vector<char>>;
 
-TEST_CASE("Simple combination of 4", "[combinations]") {
-    std::string s = "ABCD";
+TEST_CASE("combinations: Simple combination of 4", "[combinations]") {
+    std::string s{"ABCD"};
     CharCombSet sc;
     for (auto v : combinations(s, 2)) {
         std::vector<char> vcopy(std::begin(v), std::end(v));
@@ -24,4 +24,9 @@ TEST_CASE("Simple combination of 4", "[combinations]") {
         {{'A','B'}, {'A','C'}, {'A','D'}, {'B','C'}, {'B','D'}, {'C','D'}};
     REQUIRE( ans == sc );
 }
-        
+
+TEST_CASE("combinations: size too large gives no results", "[combinations]") {
+    std::string s{"ABCD"};
+    auto c = combinations(s, 5);
+    REQUIRE( !(std::begin(c) != std::end(c)) );
+}

From 3402bd19cc2fa366f1413db6fd953c3a6461f5b5 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 6 Dec 2014 18:15:52 -0500
Subject: [PATCH 0633/1866] marks combinations operator!= as const

---
 combinations.hpp | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/combinations.hpp b/combinations.hpp
index d5b877c1..c828a4ed 100644
--- a/combinations.hpp
+++ b/combinations.hpp
@@ -114,8 +114,7 @@ namespace iter {
                     return *this;
                 }
 
-                bool operator !=(const Iterator&)
-                {
+                bool operator!=(const Iterator&) const {
                     //because of the way this is done you have to start from
                     //the begining of the range and end at the end, you could
                     //break in the middle of the loop though, it's not

From 810cb0796e6523b69daa96dd3d02a93e57a73a72 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 6 Dec 2014 18:18:53 -0500
Subject: [PATCH 0634/1866] adds combinations operator==

---
 combinations.hpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/combinations.hpp b/combinations.hpp
index c828a4ed..c9f65587 100644
--- a/combinations.hpp
+++ b/combinations.hpp
@@ -121,6 +121,10 @@ namespace iter {
                     //different from the way that python's works
                     return not_done;
                 }
+
+                bool operator==(const Iterator& other) const {
+                    return !(*this != other);
+                }
         };
 
         Iterator begin() {

From 2307e4e3090fa3a09d369a52a2f382e644c2ef07 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 6 Dec 2014 18:19:16 -0500
Subject: [PATCH 0635/1866] uses == for combinations instead of !(!=)

---
 catchtest/test_combinations.cpp | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/catchtest/test_combinations.cpp b/catchtest/test_combinations.cpp
index 5f0b7b7d..11f8cbb3 100644
--- a/catchtest/test_combinations.cpp
+++ b/catchtest/test_combinations.cpp
@@ -28,5 +28,11 @@ TEST_CASE("combinations: Simple combination of 4", "[combinations]") {
 TEST_CASE("combinations: size too large gives no results", "[combinations]") {
     std::string s{"ABCD"};
     auto c = combinations(s, 5);
-    REQUIRE( !(std::begin(c) != std::end(c)) );
+    REQUIRE( std::begin(c) == std::end(c) );
+}
+
+TEST_CASE("combinations: size 0 gives nothing", "[combinations]") {
+    std::string s{"ABCD"};
+    auto c = combinations(s, 0);
+    REQUIRE( std::begin(c) == std::end(c) );
 }

From 5f2dcae76a7ee944b01f145a9c4e5c2fb034b360 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 6 Dec 2014 18:23:56 -0500
Subject: [PATCH 0636/1866] adds combinations postfix ++

---
 combinations.hpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/combinations.hpp b/combinations.hpp
index c9f65587..e05fb957 100644
--- a/combinations.hpp
+++ b/combinations.hpp
@@ -114,6 +114,12 @@ namespace iter {
                     return *this;
                 }
 
+                Iterator operator++(int) {
+                    auto ret = *this;
+                    ++*this;
+                    return ret;
+                }
+
                 bool operator!=(const Iterator&) const {
                     //because of the way this is done you have to start from
                     //the begining of the range and end at the end, you could

From 73b12b21b1fd40de7cb0e61226f455457899994e Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 9 Dec 2014 20:18:17 -0500
Subject: [PATCH 0637/1866] tests correct movement and bind

---
 catchtest/test_combinations.cpp | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/catchtest/test_combinations.cpp b/catchtest/test_combinations.cpp
index 11f8cbb3..d22db349 100644
--- a/catchtest/test_combinations.cpp
+++ b/catchtest/test_combinations.cpp
@@ -10,6 +10,7 @@
 
 
 using iter::combinations;
+using itertest::BasicIterable;
 using CharCombSet = std::multiset<std::vector<char>>;
 
 TEST_CASE("combinations: Simple combination of 4", "[combinations]") {
@@ -36,3 +37,16 @@ TEST_CASE("combinations: size 0 gives nothing", "[combinations]") {
     auto c = combinations(s, 0);
     REQUIRE( std::begin(c) == std::end(c) );
 }
+
+TEST_CASE("combinations: binds to lvalues, moves rvalues", "[combinations]") {
+    BasicIterable<char> bi{'x', 'y', 'z'};
+    SECTION("binds to lvalues") {
+        combinations(bi, 1);
+        REQUIRE_FALSE( bi.was_moved_from() );
+    }
+    SECTION("moves rvalues") {
+        combinations(std::move(bi), 1);
+        REQUIRE( bi.was_moved_from() );
+    }
+}
+

From 3cd170a7d3a0e58636d68f97c24b7b097169f512 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 9 Dec 2014 21:19:41 -0500
Subject: [PATCH 0638/1866] Adds test for combinations with replacement

---
 .../test_combinations_with_replacement.cpp    | 42 +++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 catchtest/test_combinations_with_replacement.cpp

diff --git a/catchtest/test_combinations_with_replacement.cpp b/catchtest/test_combinations_with_replacement.cpp
new file mode 100644
index 00000000..bc5cd9ef
--- /dev/null
+++ b/catchtest/test_combinations_with_replacement.cpp
@@ -0,0 +1,42 @@
+#include <combinations_with_replacement.hpp>
+
+#include <iterator>
+#include <string>
+#include <set>
+#include <vector>
+
+#include "helpers.hpp"
+#include "catch.hpp"
+
+using iter::combinations_with_replacement;
+using itertest::BasicIterable;
+using CharCombSet = std::multiset<std::vector<char>>;
+
+TEST_CASE("combinations_with_replacement: Simple combination",
+        "[combinations_with_replacement]") {
+    std::string s{"ABC"};
+    CharCombSet sc;
+    for (auto v : combinations_with_replacement(s, 2)) {
+        std::vector<char> vcopy(std::begin(v), std::end(v));
+        sc.insert(vcopy);
+    }
+    CharCombSet ans =
+        {{'A','A'}, {'A','B'}, {'A','C'}, {'B','B'}, {'B','C'}, {'C','C'}};
+    REQUIRE( ans == sc );
+}
+
+
+
+TEST_CASE("combinations_with_replacement: big size is no problem",
+        "[combinations_with_replacement]") {
+    std::string s{"AB"};
+    CharCombSet sc;
+    for (auto v : combinations_with_replacement(s, 3)) {
+        std::vector<char> vcopy(std::begin(v), std::end(v));
+        sc.insert(vcopy);
+    }
+    CharCombSet ans =
+        {{'A', 'A', 'A'}, {'A', 'A', 'B'}, {'A', 'B', 'B'}, {'B', 'B', 'B'}};
+    REQUIRE( ans == sc );
+}
+    

From 10ebc700c0cb1de70e3d7efef967dfae194508c5 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 9 Dec 2014 21:19:55 -0500
Subject: [PATCH 0639/1866] comb w/ repl iterator interits from std::iterator

---
 combinations_with_replacement.hpp | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/combinations_with_replacement.hpp b/combinations_with_replacement.hpp
index ead4319a..57f55bc7 100644
--- a/combinations_with_replacement.hpp
+++ b/combinations_with_replacement.hpp
@@ -41,8 +41,14 @@ namespace iter {
                length{n}
            { }
 
+            using CombIteratorDeref =
+                std::vector<collection_item_type<Container>>;
+
         public:
-           class Iterator {
+            class Iterator :
+                public std::iterator<std::input_iterator_tag,
+                    CombIteratorDeref>
+            {
                private:
                    Container& items;
                    std::vector<iterator_type<Container>> indicies;
@@ -56,7 +62,7 @@ namespace iter {
                        not_done{n != 0}
                    { }
 
-                   std::vector<collection_item_type<Container>> operator*() {
+                   CombIteratorDeref operator*() {
                        std::vector<collection_item_type<Container>> values;
                        for (auto i : indicies) {
                            values.push_back(*i);

From 702797c7d1f53acf8922edfd74a0945cee31cfdc Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 9 Dec 2014 21:20:44 -0500
Subject: [PATCH 0640/1866] tells scons to build comb w/ replacement test

---
 catchtest/SConstruct | 1 +
 1 file changed, 1 insertion(+)

diff --git a/catchtest/SConstruct b/catchtest/SConstruct
index be2907b9..bb00e117 100644
--- a/catchtest/SConstruct
+++ b/catchtest/SConstruct
@@ -21,6 +21,7 @@ progs = Split(
     accumulate
     chain
     combinations
+    combinations_with_replacement
     '''
 )
 

From eed3c11764082aaf6cb1aa1c2cd491523c0ef630 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 9 Dec 2014 21:33:48 -0500
Subject: [PATCH 0641/1866] Tests odd sizes in comb w/ repl

---
 catchtest/test_combinations_with_replacement.cpp | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/catchtest/test_combinations_with_replacement.cpp b/catchtest/test_combinations_with_replacement.cpp
index bc5cd9ef..1896d19e 100644
--- a/catchtest/test_combinations_with_replacement.cpp
+++ b/catchtest/test_combinations_with_replacement.cpp
@@ -40,3 +40,10 @@ TEST_CASE("combinations_with_replacement: big size is no problem",
     REQUIRE( ans == sc );
 }
     
+TEST_CASE("combinations_with_replacement: 0 size is empty",
+        "[combinations_with_replacement]") {
+    std::string s{"A"};
+    auto cwr = combinations_with_replacement(s, 0);
+    REQUIRE( std::begin(cwr) == std::end(cwr) );
+}
+

From 585b130fb065380c33db95a933526dd9701f414e Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 9 Dec 2014 21:34:06 -0500
Subject: [PATCH 0642/1866] Adds ++ and == to comb w/ repl iterator

---
 combinations_with_replacement.hpp | 22 +++++++++++++++++-----
 1 file changed, 17 insertions(+), 5 deletions(-)

diff --git a/combinations_with_replacement.hpp b/combinations_with_replacement.hpp
index 57f55bc7..615da8b8 100644
--- a/combinations_with_replacement.hpp
+++ b/combinations_with_replacement.hpp
@@ -1,5 +1,5 @@
-#ifndef COMBINATIONS_WITH_REPLACEMENT_HPP_
-#define COMBINATIONS_WITH_REPLACEMENT_HPP_
+#ifndef ITER_COMBINATIONS_WITH_REPLACEMENT_HPP_
+#define ITER_COMBINATIONS_WITH_REPLACEMENT_HPP_
 
 #include "iterbase.hpp"
 
@@ -96,13 +96,25 @@ namespace iter {
                        return *this;
                    }
 
-                   bool operator !=(const Iterator&) const {
+
+                   Iterator operator++(int) {
+                       auto ret = *this;
+                       ++*this;
+                       return ret;
+                   }
+
+                   bool operator!=(const Iterator&) const {
                        //because of the way this is done you have to start from
                        //the begining of the range and end at the end, you
                        //could break in the middle of the loop though, it's not
-                       //different from the waythat python's works
+                       //different from the way that python's works
                        return not_done;
                    }
+
+                   bool operator==(const Iterator& other) const {
+                       return !(*this != other);
+                   }
+
            };
 
            Iterator begin() {
@@ -128,4 +140,4 @@ namespace iter {
     }
 }
 
-#endif // #ifndef COMBINATIONS_WITH_REPLACEMENT_HPP_
+#endif

From 49669cb41c31312b5048409fb82c12b133f5f778 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 11 Dec 2014 19:53:18 -0500
Subject: [PATCH 0643/1866] adds solidint test for combinations

---
 catchtest/test_combinations.cpp | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/catchtest/test_combinations.cpp b/catchtest/test_combinations.cpp
index d22db349..c366cdba 100644
--- a/catchtest/test_combinations.cpp
+++ b/catchtest/test_combinations.cpp
@@ -11,6 +11,7 @@
 
 using iter::combinations;
 using itertest::BasicIterable;
+using itertest::SolidInt;
 using CharCombSet = std::multiset<std::vector<char>>;
 
 TEST_CASE("combinations: Simple combination of 4", "[combinations]") {
@@ -50,3 +51,10 @@ TEST_CASE("combinations: binds to lvalues, moves rvalues", "[combinations]") {
     }
 }
 
+TEST_CASE("combinations: doesn't move or copy elements of iterable",
+        "[combinations]") {
+    constexpr SolidInt arr[] = {{6}, {7}, {8}};
+    for (auto&& i : combinations(arr, 1)) {
+        (void)i;
+    }
+}

From 3177132b5c3d5b49f353121ac65123bb426fa956 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 11 Dec 2014 19:56:47 -0500
Subject: [PATCH 0644/1866] tests comb w/ repl with solidint

---
 catchtest/test_combinations_with_replacement.cpp | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/catchtest/test_combinations_with_replacement.cpp b/catchtest/test_combinations_with_replacement.cpp
index 1896d19e..6677009e 100644
--- a/catchtest/test_combinations_with_replacement.cpp
+++ b/catchtest/test_combinations_with_replacement.cpp
@@ -47,3 +47,11 @@ TEST_CASE("combinations_with_replacement: 0 size is empty",
     REQUIRE( std::begin(cwr) == std::end(cwr) );
 }
 
+
+TEST_CASE("combinations_with_replacement: doesn't move or copy elements of iterable",
+        "[combinations_with_replacement]") {
+    constexpr itertest::SolidInt arr[] = {{6}, {7}, {8}};
+    for (auto&& i : combinations_with_replacement(arr, 1)) {
+        (void)i;
+    }
+}

From 8df4eb77b08e24a284ea817a4396691499efca1b Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 11 Dec 2014 20:50:04 -0500
Subject: [PATCH 0645/1866] adds basic compress test

---
 catchtest/test_compress.cpp | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 catchtest/test_compress.cpp

diff --git a/catchtest/test_compress.cpp b/catchtest/test_compress.cpp
new file mode 100644
index 00000000..78c45a17
--- /dev/null
+++ b/catchtest/test_compress.cpp
@@ -0,0 +1,26 @@
+#include "helpers.hpp"
+#include <compress.hpp>
+
+#include <vector>
+#include <list>
+#include <string>
+#include <vector>
+#include <iterator>
+#include <utility>
+
+#include "catch.hpp"
+
+using iter::compress;
+using itertest::SolidInt;
+using itertest::BasicIterable;
+using Vec = const std::vector<char>;
+
+TEST_CASE("compress: alternating", "[compress]") {
+    std::vector<int> ivec{1, 2, 3, 4, 5, 6};
+    std::vector<bool> bvec{true, false, true, false, true, false};
+    auto c = compress(ivec, bvec);
+    Vec v(std::begin(c), std::end(c));
+    Vec vc = {1,3,5};
+
+    REQUIRE( v  == vc );
+}

From 996154aa4f87165586362fb4923c048aa4ffa9c9 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 11 Dec 2014 20:50:41 -0500
Subject: [PATCH 0646/1866] compress iter derives std iterator

---
 compress.hpp | 20 ++++++++++++--------
 1 file changed, 12 insertions(+), 8 deletions(-)

diff --git a/compress.hpp b/compress.hpp
index 94dff629..fe5e0ea7 100644
--- a/compress.hpp
+++ b/compress.hpp
@@ -1,9 +1,10 @@
-#ifndef COMPRESS__H__
-#define COMPRESS__H__
+#ifndef ITER_COMPRESS_H_
+#define ITER_COMPRESS_H_
 
 #include "iterbase.hpp"
 
 #include <utility>
+#include <iterator>
 #include <initializer_list>
 
 namespace iter {
@@ -65,7 +66,10 @@ namespace iter {
         public:
             Compressed(const Compressed&) = default;
 
-            class Iterator {
+            class Iterator 
+                : public std::iterator<std::input_iterator_tag,
+                        iterator_traits_deref<Container>>
+            {
                 private:
                     iterator_type<Container> sub_iter;
                     const iterator_type<Container> sub_end;
@@ -87,10 +91,10 @@ namespace iter {
                     }
 
                 public:
-                    Iterator (iterator_type<Container> cont_iter,
-                              iterator_type<Container> cont_end,
-                              selector_iter_type sel_iter,
-                              selector_iter_type sel_end)
+                    Iterator(iterator_type<Container> cont_iter,
+                            iterator_type<Container> cont_end,
+                            selector_iter_type sel_iter,
+                            selector_iter_type sel_end)
                         : sub_iter{cont_iter},
                         sub_end{cont_end},
                         selector_iter{sel_iter},
@@ -158,4 +162,4 @@ namespace iter {
     }
 }
 
-#endif //ifndef COMPRESS__H__
+#endif

From 552901063b31d85993ea415bdd3014d795550a76 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 11 Dec 2014 20:50:57 -0500
Subject: [PATCH 0647/1866] adds true and false run tests for compress

---
 catchtest/SConstruct        |  1 +
 catchtest/test_compress.cpp | 20 ++++++++++++++++++++
 2 files changed, 21 insertions(+)

diff --git a/catchtest/SConstruct b/catchtest/SConstruct
index bb00e117..4e5637e7 100644
--- a/catchtest/SConstruct
+++ b/catchtest/SConstruct
@@ -22,6 +22,7 @@ progs = Split(
     chain
     combinations
     combinations_with_replacement
+    compress
     '''
 )
 
diff --git a/catchtest/test_compress.cpp b/catchtest/test_compress.cpp
index 78c45a17..aac35c7b 100644
--- a/catchtest/test_compress.cpp
+++ b/catchtest/test_compress.cpp
@@ -24,3 +24,23 @@ TEST_CASE("compress: alternating", "[compress]") {
 
     REQUIRE( v  == vc );
 }
+
+TEST_CASE("compress: consecutive falses", "[compress]") {
+    std::vector<int> ivec{1, 2, 3, 4, 5};
+    std::vector<bool> bvec{true, false, false, false, true};
+    auto c = compress(ivec, bvec);
+    Vec v(std::begin(c), std::end(c));
+    Vec vc = {1,5};
+
+    REQUIRE( v == vc );
+}
+
+TEST_CASE("compress: consecutive trues", "[compress]") {
+    std::vector<int> ivec{1, 2, 3, 4, 5};
+    std::vector<bool> bvec{false, true, true, true, false};
+    auto c = compress(ivec, bvec);
+    Vec v(std::begin(c), std::end(c));
+    Vec vc = {2,3,4}
+
+    REQUIRE( v == vc );
+}

From abc71e39f2fcfce47f43f1239ecd30fe31e59605 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 11 Dec 2014 21:39:55 -0500
Subject: [PATCH 0648/1866] tests compress with all true

---
 catchtest/test_compress.cpp | 15 +++++++++++++--
 1 file changed, 13 insertions(+), 2 deletions(-)

diff --git a/catchtest/test_compress.cpp b/catchtest/test_compress.cpp
index aac35c7b..468fd65d 100644
--- a/catchtest/test_compress.cpp
+++ b/catchtest/test_compress.cpp
@@ -13,7 +13,7 @@
 using iter::compress;
 using itertest::SolidInt;
 using itertest::BasicIterable;
-using Vec = const std::vector<char>;
+using Vec = const std::vector<int>;
 
 TEST_CASE("compress: alternating", "[compress]") {
     std::vector<int> ivec{1, 2, 3, 4, 5, 6};
@@ -40,7 +40,18 @@ TEST_CASE("compress: consecutive trues", "[compress]") {
     std::vector<bool> bvec{false, true, true, true, false};
     auto c = compress(ivec, bvec);
     Vec v(std::begin(c), std::end(c));
-    Vec vc = {2,3,4}
+    Vec vc = {2,3,4};
 
     REQUIRE( v == vc );
 }
+
+TEST_CASE("compress: all true", "[compress]") {
+    std::vector<int> ivec{1, 2, 3, 4, 5};
+    std::vector<bool> bvec(ivec.size(), true);
+    auto c = compress(ivec, bvec);
+    Vec v(std::begin(c), std::end(c));
+
+    REQUIRE( v == ivec );
+}
+
+

From 0ef255d023c41cfa474920097b1a883ecd30d0bd Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 11 Dec 2014 21:48:32 -0500
Subject: [PATCH 0649/1866] compress with all false

---
 catchtest/test_compress.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/catchtest/test_compress.cpp b/catchtest/test_compress.cpp
index 468fd65d..7dfdedc8 100644
--- a/catchtest/test_compress.cpp
+++ b/catchtest/test_compress.cpp
@@ -54,4 +54,10 @@ TEST_CASE("compress: all true", "[compress]") {
     REQUIRE( v == ivec );
 }
 
+TEST_CASE("compress: all false", "[compress]") {
+    std::vector<int> ivec{1, 2, 3, 4, 5};
+    std::vector<bool> bvec(ivec.size(), false);
+    auto c = compress(ivec, bvec);
+    REQUIRE( std::begin(c) == std::end(c) );
+}
 

From c88a2b778822988321779c2bd2a6aada2c3ef04c Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 11 Dec 2014 21:48:38 -0500
Subject: [PATCH 0650/1866] adds == for compress iter

---
 compress.hpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/compress.hpp b/compress.hpp
index fe5e0ea7..2af0668a 100644
--- a/compress.hpp
+++ b/compress.hpp
@@ -117,6 +117,10 @@ namespace iter {
                         return this->sub_iter != other.sub_iter &&
                             this->selector_iter != other.selector_iter;
                     }
+
+                    bool operator==(const Iterator& other) const {
+                        return !(*this != other);
+                    }
             };
 
             Iterator begin() {

From b4a9bb8a03ee65fdb1af8a85323dc70f63981a5a Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 11 Dec 2014 21:49:43 -0500
Subject: [PATCH 0651/1866] adds compress iter ++ and removes ctor specs

I needn't specify the deletes and defaults, it doesn't gain me anything
---
 compress.hpp | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/compress.hpp b/compress.hpp
index 2af0668a..9d3ff7d0 100644
--- a/compress.hpp
+++ b/compress.hpp
@@ -60,11 +60,8 @@ namespace iter {
                 : container(std::forward<Container>(container)),
                 selectors(std::forward<Selector>(selectors))
             { }
-            Compressed() = delete;
-            Compressed& operator=(const Compressed&) = delete;
 
         public:
-            Compressed(const Compressed&) = default;
 
             class Iterator 
                 : public std::iterator<std::input_iterator_tag,
@@ -113,6 +110,12 @@ namespace iter {
                         return *this;
                     }
 
+                    Iterator operator++(int) {
+                        auto ret = *this;
+                        ++*this;
+                        return ret;
+                    }
+
                     bool operator!=(const Iterator& other) const {
                         return this->sub_iter != other.sub_iter &&
                             this->selector_iter != other.selector_iter;

From 17cd4b6c5fb6eb1626c7891f28fdecdb5151a954 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 11 Dec 2014 21:52:01 -0500
Subject: [PATCH 0652/1866] tests that compress moves and binds correctly

---
 catchtest/test_compress.cpp | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/catchtest/test_compress.cpp b/catchtest/test_compress.cpp
index 7dfdedc8..6050ca05 100644
--- a/catchtest/test_compress.cpp
+++ b/catchtest/test_compress.cpp
@@ -61,3 +61,15 @@ TEST_CASE("compress: all false", "[compress]") {
     REQUIRE( std::begin(c) == std::end(c) );
 }
 
+TEST_CASE("compress: binds to lvalues, moves rvalues", "[compress]") {
+    BasicIterable<char> bi{'x', 'y', 'z'};
+    std::vector<bool> bl{true, true, true};
+    SECTION("binds to lvalues") {
+        compress(bi, bl);
+        REQUIRE_FALSE( bi.was_moved_from() );
+    }
+    SECTION("moves rvalues") {
+        compress(std::move(bi), bl);
+        REQUIRE( bi.was_moved_from() );
+    }
+}

From f36f405bbc79e0d2c57269699a5fa90796fbea29 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 11 Dec 2014 22:03:01 -0500
Subject: [PATCH 0653/1866] tests compress with truth-y value

---
 catchtest/test_compress.cpp | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/catchtest/test_compress.cpp b/catchtest/test_compress.cpp
index 6050ca05..f2003852 100644
--- a/catchtest/test_compress.cpp
+++ b/catchtest/test_compress.cpp
@@ -73,3 +73,23 @@ TEST_CASE("compress: binds to lvalues, moves rvalues", "[compress]") {
         REQUIRE( bi.was_moved_from() );
     }
 }
+
+struct BoolLike {
+    public:
+        bool state;
+        explicit operator bool() const {
+            return this->state;
+        }
+};
+
+TEST_CASE("compress: workds with truthy and falsey values", "[compress]") {
+    std::vector<BoolLike> bvec{{true}, {false}, {true}, {false}};
+
+    Vec ivec{1,2,3,4};
+
+    auto c = compress(ivec, bvec);
+    Vec v(std::begin(c), std::end(c));
+
+    Vec vc = {1,3};
+    REQUIRE( v == vc );
+}

From 9d8b2f8781edb104bb436fdb11fc58321630c46f Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 11 Dec 2014 22:11:45 -0500
Subject: [PATCH 0654/1866] tests compress withs shorter selector list

---
 catchtest/test_compress.cpp | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/catchtest/test_compress.cpp b/catchtest/test_compress.cpp
index f2003852..1bcb6c59 100644
--- a/catchtest/test_compress.cpp
+++ b/catchtest/test_compress.cpp
@@ -93,3 +93,10 @@ TEST_CASE("compress: workds with truthy and falsey values", "[compress]") {
     Vec vc = {1,3};
     REQUIRE( v == vc );
 }
+
+TEST_CASE("compress: terminates on shorter selectors", "[compress]") {
+    std::vector<int> ivec{1, 2, 3, 4, 5};
+    std::vector<bool> bvec{true};
+    auto c = compress(ivec, bvec);
+    REQUIRE( std::distance(std::begin(c), std::end(c)) == 1 );
+}

From 4abcb93dd21a71f0372448e1cb74f20a88460602 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 11 Dec 2014 22:13:49 -0500
Subject: [PATCH 0655/1866] tests compress with shorter data list

---
 catchtest/test_compress.cpp | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/catchtest/test_compress.cpp b/catchtest/test_compress.cpp
index 1bcb6c59..1311997a 100644
--- a/catchtest/test_compress.cpp
+++ b/catchtest/test_compress.cpp
@@ -100,3 +100,10 @@ TEST_CASE("compress: terminates on shorter selectors", "[compress]") {
     auto c = compress(ivec, bvec);
     REQUIRE( std::distance(std::begin(c), std::end(c)) == 1 );
 }
+
+TEST_CASE("compress: terminates on shorter data", "[compress]") {
+    std::vector<int> ivec{1};
+    std::vector<bool> bvec{true, true, true, true, true};
+    auto c = compress(ivec, bvec);
+    REQUIRE( std::distance(std::begin(c), std::end(c)) == 1 );
+}

From 923b97d4158b689d78ee67009e5cc98cec690caa Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 12 Dec 2014 10:02:49 -0500
Subject: [PATCH 0656/1866] tests compress with empty selectors

---
 catchtest/test_compress.cpp | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/catchtest/test_compress.cpp b/catchtest/test_compress.cpp
index 1311997a..e46f3e93 100644
--- a/catchtest/test_compress.cpp
+++ b/catchtest/test_compress.cpp
@@ -107,3 +107,10 @@ TEST_CASE("compress: terminates on shorter data", "[compress]") {
     auto c = compress(ivec, bvec);
     REQUIRE( std::distance(std::begin(c), std::end(c)) == 1 );
 }
+
+TEST_CASE("compress: nothing on empty selectors", "[compress]") {
+    std::vector<int> ivec{1,2,3};
+    std::vector<bool> bvec{};
+    auto c = compress(ivec, bvec);
+    REQUIRE( std::begin(c) == std::end(c) );
+}

From 2f49ae1164fc989e193e3ed690a3b952cc7e0755 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 12 Dec 2014 10:06:04 -0500
Subject: [PATCH 0657/1866] tests compress with empty data

---
 catchtest/test_compress.cpp | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/catchtest/test_compress.cpp b/catchtest/test_compress.cpp
index e46f3e93..4a970814 100644
--- a/catchtest/test_compress.cpp
+++ b/catchtest/test_compress.cpp
@@ -114,3 +114,10 @@ TEST_CASE("compress: nothing on empty selectors", "[compress]") {
     auto c = compress(ivec, bvec);
     REQUIRE( std::begin(c) == std::end(c) );
 }
+
+TEST_CASE("compress: nothing on empty data", "[compress]") {
+    std::vector<int> ivec{};
+    std::vector<bool> bvec{true, true, true};
+    auto c = compress(ivec, bvec);
+    REQUIRE( std::begin(c) == std::end(c) );
+}

From c9aa31c90b9aa68351cfd5f8879881181996dc38 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 12 Dec 2014 10:33:13 -0500
Subject: [PATCH 0658/1866] fixes count includes

---
 count.hpp | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/count.hpp b/count.hpp
index 4945d88f..491d7b2d 100644
--- a/count.hpp
+++ b/count.hpp
@@ -1,5 +1,5 @@
-#ifndef COUNT__H__
-#define COUNT__H__
+#ifndef ITER_COUNT_H_
+#define ITER_COUNT_H_
 
 #include "range.hpp"
 
@@ -29,5 +29,4 @@ namespace iter {
 }
 
 
-#endif //define COUNT__H__
-
+#endif

From e96fe1f90debec5cce1c949cb291571205bfdbc4 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 12 Dec 2014 10:34:37 -0500
Subject: [PATCH 0659/1866] removes unnecessary include of <list>

---
 catchtest/test_compress.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/catchtest/test_compress.cpp b/catchtest/test_compress.cpp
index 4a970814..137f69c9 100644
--- a/catchtest/test_compress.cpp
+++ b/catchtest/test_compress.cpp
@@ -2,7 +2,6 @@
 #include <compress.hpp>
 
 #include <vector>
-#include <list>
 #include <string>
 #include <vector>
 #include <iterator>

From 97e8e3ae98fda2dcb77ccd65a3b9969e907427dc Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 12 Dec 2014 10:44:22 -0500
Subject: [PATCH 0660/1866] adds basic count test

---
 catchtest/test_count.cpp | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 catchtest/test_count.cpp

diff --git a/catchtest/test_count.cpp b/catchtest/test_count.cpp
new file mode 100644
index 00000000..ae7f35b0
--- /dev/null
+++ b/catchtest/test_count.cpp
@@ -0,0 +1,21 @@
+#include "helpers.hpp"
+#include <count.hpp>
+
+#include <vector>
+#include <iterator>
+#include <utility>
+
+#include "catch.hpp"
+
+using iter::count;
+
+TEST_CASE("count: watch for 10 elements", "[count]") {
+    std::vector<int> v{};
+    for (auto i : count()) {
+        v.push_back(i);
+        if (i == 9) break;
+    }
+
+    const std::vector<int> vc{0,1,2,3,4,5,6,7,8,9};
+    REQUIRE( v == vc );
+}

From a4075c6eab831a944832a13c8418092ac6a1c238 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 12 Dec 2014 10:46:41 -0500
Subject: [PATCH 0661/1866] adds count with starting value test

---
 catchtest/test_count.cpp | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/catchtest/test_count.cpp b/catchtest/test_count.cpp
index ae7f35b0..9c7b23b7 100644
--- a/catchtest/test_count.cpp
+++ b/catchtest/test_count.cpp
@@ -19,3 +19,14 @@ TEST_CASE("count: watch for 10 elements", "[count]") {
     const std::vector<int> vc{0,1,2,3,4,5,6,7,8,9};
     REQUIRE( v == vc );
 }
+
+TEST_CASE("count: start at 10", "[count]") {
+    std::vector<int> v{};
+    for (auto i : count(10)) {
+        v.push_back(i);
+        if (i == 14) break;
+    }
+
+    const std::vector<int> vc{10,11,12,13,14,15};
+    REQUIRE( v == vc );
+}

From 9f60d8c6831eff9cc32ffa9b1912897c30d4bc9c Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 12 Dec 2014 10:50:52 -0500
Subject: [PATCH 0662/1866] fixes count recursive call with start

---
 count.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/count.hpp b/count.hpp
index 491d7b2d..579edceb 100644
--- a/count.hpp
+++ b/count.hpp
@@ -24,7 +24,7 @@ namespace iter {
 
     template <typename T>
     Range<T> count(T start) {
-        return range(start, T(1));
+        return count(start, T(1));
     }
 }
 

From e9e8845e83150b17916dc14b7b10e6f8f11e2a8d Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 12 Dec 2014 11:03:16 -0500
Subject: [PATCH 0663/1866] tests count with negative step

---
 catchtest/test_count.cpp | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/catchtest/test_count.cpp b/catchtest/test_count.cpp
index 9c7b23b7..0e5b660e 100644
--- a/catchtest/test_count.cpp
+++ b/catchtest/test_count.cpp
@@ -27,6 +27,17 @@ TEST_CASE("count: start at 10", "[count]") {
         if (i == 14) break;
     }
 
-    const std::vector<int> vc{10,11,12,13,14,15};
+    const std::vector<int> vc{10,11,12,13,14};
     REQUIRE( v == vc );
 }
+
+TEST_CASE("count with step", "[count]") {
+    std::vector<int> v{};
+    for (auto i : count(2, -1)) {
+        v.push_back(i);
+        if (i == -3) break;
+    }
+
+    const std::vector<int> vc{2,1,0,-1,-2,-3};
+    REQUIRE( v == vc);
+}

From 7eee264f14a1b648792e1b368de52a9224049434 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 12 Dec 2014 12:02:23 -0500
Subject: [PATCH 0664/1866] adds count test with step >1

---
 catchtest/test_count.cpp | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/catchtest/test_count.cpp b/catchtest/test_count.cpp
index 0e5b660e..05134724 100644
--- a/catchtest/test_count.cpp
+++ b/catchtest/test_count.cpp
@@ -31,7 +31,7 @@ TEST_CASE("count: start at 10", "[count]") {
     REQUIRE( v == vc );
 }
 
-TEST_CASE("count with step", "[count]") {
+TEST_CASE("count: with step", "[count]") {
     std::vector<int> v{};
     for (auto i : count(2, -1)) {
         v.push_back(i);
@@ -41,3 +41,14 @@ TEST_CASE("count with step", "[count]") {
     const std::vector<int> vc{2,1,0,-1,-2,-3};
     REQUIRE( v == vc);
 }
+
+TEST_CASE("count: with step > 1", "[count]") {
+    std::vector<int> v{};
+    for (auto i : count(10, 2)) {
+        v.push_back(i);
+        if (i == 16) break;
+    }
+
+    const std::vector<int> vc{10, 12, 14, 16};
+    REQUIRE( v == vc );
+}

From 1ef8cc7f65157722fe719942b79a50cbdd1308dc Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 12 Dec 2014 12:56:16 -0500
Subject: [PATCH 0665/1866] builds count test

---
 catchtest/SConstruct | 1 +
 1 file changed, 1 insertion(+)

diff --git a/catchtest/SConstruct b/catchtest/SConstruct
index 4e5637e7..355e0139 100644
--- a/catchtest/SConstruct
+++ b/catchtest/SConstruct
@@ -23,6 +23,7 @@ progs = Split(
     combinations
     combinations_with_replacement
     compress
+    count
     '''
 )
 

From 812aaa37db3ffae36c5677711c19e7728ac8241d Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 12 Dec 2014 13:03:54 -0500
Subject: [PATCH 0666/1866] adds basic cycle test

---
 catchtest/test_cycle.cpp | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 catchtest/test_cycle.cpp

diff --git a/catchtest/test_cycle.cpp b/catchtest/test_cycle.cpp
new file mode 100644
index 00000000..35dcc10a
--- /dev/null
+++ b/catchtest/test_cycle.cpp
@@ -0,0 +1,26 @@
+#include <cycle.hpp>
+
+#include "helpers.hpp"
+
+#include <vector>
+#include <string>
+#include <iterator>
+
+#include "catch.hpp"
+
+using iter::cycle;
+
+TEST_CASE("cycle: iterate twice", "[cycle]") {
+    std::vector<int> ns {2,4,6};
+    std::vector<int> v{};
+    std::size_t count = 0;
+    for (auto i : cycle(ns)) {
+        v.push_back(i);
+        ++count;
+        if (count == ns.size() * 2) break;
+    }
+
+    auto vc = ns;
+    vc.insert(std::end(vc), std::begin(ns), std::end(ns));
+    REQUIRE( v == vc );
+}

From 79753f66ba795ad53c8cb0f82b477ebf4c7c6ef4 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 12 Dec 2014 13:04:41 -0500
Subject: [PATCH 0667/1866] fixes include guards in cycle

---
 cycle.hpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/cycle.hpp b/cycle.hpp
index d683b8da..421876f8 100644
--- a/cycle.hpp
+++ b/cycle.hpp
@@ -1,5 +1,5 @@
-#ifndef CYCLE__H__
-#define CYCLE__H__
+#ifndef ITER_CYCLE_H_
+#define ITER_CYCLE_H_
 
 #include "iterbase.hpp"
 
@@ -100,4 +100,4 @@ namespace iter {
     }
 }
 
-#endif //ifndef CYCLE__H__
+#endif

From a5fa8272d47652515e202be6f059b2c5d35f2251 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 12 Dec 2014 13:10:31 -0500
Subject: [PATCH 0668/1866] cycle iter inherits from std::iterator

---
 cycle.hpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/cycle.hpp b/cycle.hpp
index 421876f8..ac8ab827 100644
--- a/cycle.hpp
+++ b/cycle.hpp
@@ -34,12 +34,12 @@ namespace iter {
             Cycle(Container container)
                 : container(std::forward<Container>(container))
             { }
-            Cycle() = delete;
-            Cycle& operator=(const Cycle&) = delete;
 
         public:
-            Cycle(const Cycle&) = default;
-            class Iterator {
+            class Iterator 
+                : public std::iterator<std::input_iterator_tag,
+                            iterator_traits_deref<Container>>
+            {
                 private:
                     using iter_type = iterator_type<Container>;
                     iterator_type<Container> sub_iter;

From 4e044ea43bf37a83f2144d2eb75358ac508dc8e8 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 12 Dec 2014 13:11:41 -0500
Subject: [PATCH 0669/1866] adds cycle iter ==

---
 cycle.hpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/cycle.hpp b/cycle.hpp
index ac8ab827..7c801578 100644
--- a/cycle.hpp
+++ b/cycle.hpp
@@ -73,6 +73,10 @@ namespace iter {
                     constexpr bool operator!=(const Iterator&) const {
                         return true;
                     }
+
+                    bool operator==(const Iterator& other) const {
+                        return !(*this != other);
+                    }
             };
 
             Iterator begin() {

From 8e41b405c4d8346d2c5cd181fde422fa1eaf0a78 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 12 Dec 2014 13:12:07 -0500
Subject: [PATCH 0670/1866] adds cycle iter postfix ++

---
 cycle.hpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/cycle.hpp b/cycle.hpp
index 7c801578..b5e8ec64 100644
--- a/cycle.hpp
+++ b/cycle.hpp
@@ -70,6 +70,12 @@ namespace iter {
                         return *this;
                     }
 
+                    Iterator operator++(int) {
+                        auto ret = *this;
+                        ++*this;
+                        return ret;
+                    }
+
                     constexpr bool operator!=(const Iterator&) const {
                         return true;
                     }

From 42bcf378c4b16398dfa1416daf18c43bfd89496d Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 12 Dec 2014 13:12:45 -0500
Subject: [PATCH 0671/1866] makes cycle iter assignable

---
 cycle.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/cycle.hpp b/cycle.hpp
index b5e8ec64..8a3f7d9c 100644
--- a/cycle.hpp
+++ b/cycle.hpp
@@ -43,8 +43,8 @@ namespace iter {
                 private:
                     using iter_type = iterator_type<Container>;
                     iterator_type<Container> sub_iter;
-                    const iterator_type<Container> begin;
-                    const iterator_type<Container> end;
+                    iterator_type<Container> begin;
+                    iterator_type<Container> end;
                 public:
                     Iterator (iterator_type<Container> iter,
                             iterator_type<Container> end)

From bcd44bbfea122e5b400a295b070223005f237702 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 12 Dec 2014 13:14:14 -0500
Subject: [PATCH 0672/1866] cycle iterators actually compare

It turns out there actually is a case where begin() and end() compare
equal, and thats a cycle over an empty list.  This is the same behavior
as pythons cycle([]) which raises stop iteration right away
---
 cycle.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/cycle.hpp b/cycle.hpp
index 8a3f7d9c..adb2d58f 100644
--- a/cycle.hpp
+++ b/cycle.hpp
@@ -76,8 +76,8 @@ namespace iter {
                         return ret;
                     }
 
-                    constexpr bool operator!=(const Iterator&) const {
-                        return true;
+                    bool operator!=(const Iterator& other) const {
+                        return this->sub_iter != other.sub_iter;
                     }
 
                     bool operator==(const Iterator& other) const {

From 3bedbd307f85cbcd12e65641e415b50a62f37a06 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 12 Dec 2014 13:15:57 -0500
Subject: [PATCH 0673/1866] Removes placement new in favor of assignment

I'm dont with that idea.  It felt like dark magic to begin with
---
 cycle.hpp | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/cycle.hpp b/cycle.hpp
index adb2d58f..8c8962e1 100644
--- a/cycle.hpp
+++ b/cycle.hpp
@@ -61,11 +61,7 @@ namespace iter {
                         ++this->sub_iter;
                         // reset to beginning upon reaching the end
                         if (!(this->sub_iter != this->end)) {
-                            // explicit destruction with placement new in order
-                            // to support iterators with no operator=
-                            this->sub_iter.~iter_type();
-                            new(&this->sub_iter) iterator_type<Container>(
-                                    this->begin);
+                            this->sub_iter = this->begin;
                         }
                         return *this;
                     }

From 5c81b9b9f328b93f3c535db31a1e5b8f99c69bd0 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 12 Dec 2014 13:18:39 -0500
Subject: [PATCH 0674/1866] makes sure cycle binds and moves correctly

---
 catchtest/test_cycle.cpp | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/catchtest/test_cycle.cpp b/catchtest/test_cycle.cpp
index 35dcc10a..1c729877 100644
--- a/catchtest/test_cycle.cpp
+++ b/catchtest/test_cycle.cpp
@@ -24,3 +24,22 @@ TEST_CASE("cycle: iterate twice", "[cycle]") {
     vc.insert(std::end(vc), std::begin(ns), std::end(ns));
     REQUIRE( v == vc );
 }
+
+TEST_CASE("cycle: empty cycle terminates", "[cycle]") {
+    std::vector<int> ns;
+    auto c = cycle(ns);
+    std::vector<int> v(std::begin(c), std::end(c)); 
+    REQUIRE( v.empty() );
+}
+
+TEST_CASE("cycle: binds to lvalues, moves rvalues", "[cycle]") {
+    itertest::BasicIterable<char> bi{'x', 'y', 'z'};
+    SECTION("binds to lvalues") {
+        cycle(bi);
+        REQUIRE_FALSE( bi.was_moved_from() );
+    }
+    SECTION("moves rvalues") {
+        cycle(std::move(bi));
+        REQUIRE( bi.was_moved_from() );
+    }
+}

From 9fcf5a5b0a0f4c28d782bb33514875d5e3781354 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 12 Dec 2014 13:27:45 -0500
Subject: [PATCH 0675/1866] makes sure cycle doesn't copy or move elements

---
 catchtest/test_cycle.cpp | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/catchtest/test_cycle.cpp b/catchtest/test_cycle.cpp
index 1c729877..7f3d4203 100644
--- a/catchtest/test_cycle.cpp
+++ b/catchtest/test_cycle.cpp
@@ -43,3 +43,10 @@ TEST_CASE("cycle: binds to lvalues, moves rvalues", "[cycle]") {
         REQUIRE( bi.was_moved_from() );
     }
 }
+
+TEST_CASE("cycle: doesn't move or copy elements of iterable",
+        "[cycle]") {
+    constexpr itertest::SolidInt arr[] = {{6}, {7}, {8}};
+    auto c = cycle(arr);
+    *std::begin(c);
+}

From ccd67f2b768af47e27865ff2a31b299f1903ba10 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 12 Dec 2014 13:28:19 -0500
Subject: [PATCH 0676/1866] builds cycle test

---
 catchtest/SConstruct | 1 +
 1 file changed, 1 insertion(+)

diff --git a/catchtest/SConstruct b/catchtest/SConstruct
index 355e0139..d9dc90da 100644
--- a/catchtest/SConstruct
+++ b/catchtest/SConstruct
@@ -24,6 +24,7 @@ progs = Split(
     combinations_with_replacement
     compress
     count
+    cycle
     '''
 )
 

From 554ee53a42e51417f4c4eb10f359a59f1897ceb5 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 12 Dec 2014 13:52:04 -0500
Subject: [PATCH 0677/1866] ignores better

---
 tests/.gitignore | 33 ++-------------------------------
 1 file changed, 2 insertions(+), 31 deletions(-)

diff --git a/tests/.gitignore b/tests/.gitignore
index 7daa7f9d..a77d502e 100644
--- a/tests/.gitignore
+++ b/tests/.gitignore
@@ -1,34 +1,5 @@
 *.o
 *.swp
-testaccumulate
-testchain
-testchainfromiterable
-testcycle
-testenumerate
-testrange
-testslice
-testzip
-testreversed
-testrepeat
-testfilter
-testzip_longest
-testdropwhile
-testproduct
-testpermutations
-testcompress
-testcombinations_with_replacement
-testtakewhile
-testcombinations
-testpowerset
-testsliding_window
-testimap
-testfilterfalse
-testcount
-testgrouper
-testcommand_chains
-testgroupby
-testsorted
-testunique_justseen
-testunique_everseen
+test*
+!test*.cpp
 .sconsign.dblite
-

From 327cd45f3fd51d8dedea93c908e0a7df768bfc40 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 12 Dec 2014 16:22:45 -0500
Subject: [PATCH 0678/1866] adds basic dropwhile test

---
 catchtest/test_dropwhile.cpp | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 catchtest/test_dropwhile.cpp

diff --git a/catchtest/test_dropwhile.cpp b/catchtest/test_dropwhile.cpp
new file mode 100644
index 00000000..93f99050
--- /dev/null
+++ b/catchtest/test_dropwhile.cpp
@@ -0,0 +1,21 @@
+#include <dropwhile.hpp>
+
+#include "helpers.hpp"
+
+#include <vector>
+#include <string>
+#include <iterator>
+
+#include "catch.hpp"
+
+using iter::dropwhile;
+
+using Vec = const std::vector<int>;
+
+TEST_CASE("dropwhile: skips initial elements", "[dropwhile]") {
+    Vec ns{1,2,3,4,5,6,7,8};
+    auto d = dropwhile([](int i){return i < 5; }, ns);
+    Vec v(std::begin(d), std::end(d));
+    Vec vc = {5,6,7,8};
+    REQUIRE( v == vc );
+}

From a6c8fa3757d378495965c98fef19efa8bcc81fec Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 12 Dec 2014 16:22:57 -0500
Subject: [PATCH 0679/1866] dropwhile iter inherits from std::iterator

---
 dropwhile.hpp | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/dropwhile.hpp b/dropwhile.hpp
index fe727916..b24d14f6 100644
--- a/dropwhile.hpp
+++ b/dropwhile.hpp
@@ -1,5 +1,5 @@
-#ifndef DROPWHILE__H__
-#define DROPWHILE__H__
+#ifndef ITER_DROPWHILE_H_
+#define ITER_DROPWHILE_H_
 
 #include <iterbase.hpp>
 
@@ -43,7 +43,10 @@ namespace iter {
 
         public:
             DropWhile(const DropWhile&) = default;
-            class Iterator {
+            class Iterator 
+                : public std::iterator<std::input_iterator_tag,
+                    iterator_traits_deref<Container>>
+            {
                 private:
                     iterator_type<Container> sub_iter;
                     const iterator_type<Container> sub_end;
@@ -111,4 +114,4 @@ namespace iter {
     }
 }
 
-#endif //ifndef DROPWHILE__H__
+#endif

From 52f91cb7488bae116b6239faefe78db26a1df507 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 12 Dec 2014 16:23:05 -0500
Subject: [PATCH 0680/1866] builds dropwhile catch test

---
 catchtest/SConstruct | 1 +
 1 file changed, 1 insertion(+)

diff --git a/catchtest/SConstruct b/catchtest/SConstruct
index d9dc90da..5bc85a89 100644
--- a/catchtest/SConstruct
+++ b/catchtest/SConstruct
@@ -25,6 +25,7 @@ progs = Split(
     compress
     count
     cycle
+    dropwhile
     '''
 )
 

From 041daef2b41d11ecc1f27f8c9adedf14e02bc079 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 12 Dec 2014 16:28:44 -0500
Subject: [PATCH 0681/1866] adds == and postfix ++ to dropwhile iter

---
 dropwhile.hpp | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/dropwhile.hpp b/dropwhile.hpp
index b24d14f6..28e823eb 100644
--- a/dropwhile.hpp
+++ b/dropwhile.hpp
@@ -80,9 +80,19 @@ namespace iter {
                         return *this;
                     }
 
+                    Iterator operator++(int) {
+                        auto ret = *this;
+                        ++*this;
+                        return ret;
+                    }
+
                     bool operator!=(const Iterator& other) const {
                         return this->sub_iter != other.sub_iter;
                     }
+
+                    bool operator==(const Iterator& other) const {
+                        return !(*this != other);
+                    }
             };
 
             Iterator begin() {

From c2cd81566ca5ad69a2ef36cd1e861565f58768af Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 12 Dec 2014 17:07:16 -0500
Subject: [PATCH 0682/1866] tests dropwhile when all elements pass predicate

---
 catchtest/test_dropwhile.cpp | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/catchtest/test_dropwhile.cpp b/catchtest/test_dropwhile.cpp
index 93f99050..e2c7e6d8 100644
--- a/catchtest/test_dropwhile.cpp
+++ b/catchtest/test_dropwhile.cpp
@@ -19,3 +19,11 @@ TEST_CASE("dropwhile: skips initial elements", "[dropwhile]") {
     Vec vc = {5,6,7,8};
     REQUIRE( v == vc );
 }
+
+TEST_CASE("dropwhile: doesn't skip anything if it shouldn't", "[dropwhile]") {
+    Vec ns {3,4,5,6};
+    auto d = dropwhile([](int i){return i < 3; }, ns);
+    Vec v(std::begin(d), std::end(d));
+    Vec vc = {3,4,5,6};
+    REQUIRE( v == vc );
+}

From ff3eba52c90f7ac9d472c4426a685d02caab2086 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 12 Dec 2014 17:09:07 -0500
Subject: [PATCH 0683/1866] dropwhile skips everything test

---
 catchtest/test_dropwhile.cpp | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/catchtest/test_dropwhile.cpp b/catchtest/test_dropwhile.cpp
index e2c7e6d8..c0453a2c 100644
--- a/catchtest/test_dropwhile.cpp
+++ b/catchtest/test_dropwhile.cpp
@@ -27,3 +27,11 @@ TEST_CASE("dropwhile: doesn't skip anything if it shouldn't", "[dropwhile]") {
     Vec vc = {3,4,5,6};
     REQUIRE( v == vc );
 }
+
+TEST_CASE("dropwhile: skips all elements when all are true under predicate",
+        "[dropwhile]") {
+    Vec ns {3,4,5,6};
+    auto d = dropwhile([](int i){return i != 0; }, ns);
+    REQUIRE( std::begin(d) == std::end(d) );
+}
+

From 7ea60f7aad934a7abb6aa72fe23dd15b8cf19f48 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 12 Dec 2014 17:10:41 -0500
Subject: [PATCH 0684/1866] adds dropwhile empty test

---
 catchtest/test_dropwhile.cpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/catchtest/test_dropwhile.cpp b/catchtest/test_dropwhile.cpp
index c0453a2c..61542230 100644
--- a/catchtest/test_dropwhile.cpp
+++ b/catchtest/test_dropwhile.cpp
@@ -35,3 +35,8 @@ TEST_CASE("dropwhile: skips all elements when all are true under predicate",
     REQUIRE( std::begin(d) == std::end(d) );
 }
 
+TEST_CASE("dropwhile: empty case is empty", "[dropwhile]") {
+    Vec ns{};
+    auto d = dropwhile([](int i){return i != 0; }, ns);
+    REQUIRE( std::begin(d) == std::end(d) );
+}

From ac591509b85080f1b0825bb2bb5ff1a48a8b8cca Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 12 Dec 2014 17:11:40 -0500
Subject: [PATCH 0685/1866] tests that dropwhile only drops from front

---
 catchtest/test_dropwhile.cpp | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/catchtest/test_dropwhile.cpp b/catchtest/test_dropwhile.cpp
index 61542230..e9f3cc06 100644
--- a/catchtest/test_dropwhile.cpp
+++ b/catchtest/test_dropwhile.cpp
@@ -40,3 +40,11 @@ TEST_CASE("dropwhile: empty case is empty", "[dropwhile]") {
     auto d = dropwhile([](int i){return i != 0; }, ns);
     REQUIRE( std::begin(d) == std::end(d) );
 }
+
+TEST_CASE("dropwhile: only drops from beginning", "[dropwhile]") {
+    Vec ns {1,2,3,4,5,6,5,4,3,2,1};
+    auto d = dropwhile([](int i){return i < 5; }, ns);
+    Vec v(std::begin(d), std::end(d));
+    Vec vc = {5,6,5,4,3,2,1};
+    REQUIRE( v == vc );
+}

From 8982da1f234161064e0296d61a37d503226adacc Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 12 Dec 2014 17:37:29 -0500
Subject: [PATCH 0686/1866] tests that dropwhile binds and moves correctly

---
 catchtest/test_dropwhile.cpp | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/catchtest/test_dropwhile.cpp b/catchtest/test_dropwhile.cpp
index e9f3cc06..3fe6e7ab 100644
--- a/catchtest/test_dropwhile.cpp
+++ b/catchtest/test_dropwhile.cpp
@@ -48,3 +48,29 @@ TEST_CASE("dropwhile: only drops from beginning", "[dropwhile]") {
     Vec vc = {5,6,5,4,3,2,1};
     REQUIRE( v == vc );
 }
+
+namespace {
+    int less_than_five(int i) {
+        return i < 5;
+    }
+}
+
+TEST_CASE("dropwhile: works with function pointer", "[dropwhile]") {
+    Vec ns{1,2,3,4,5,6,7,8};
+    auto d = dropwhile(less_than_five, ns);
+    Vec v(std::begin(d), std::end(d));
+    Vec vc = {5,6,7,8};
+    REQUIRE( v == vc );
+}
+
+TEST_CASE("dropwhile: binds to lvalues, moves rvalues", "[dropwhile]") {
+    itertest::BasicIterable<int> bi{1,2,3,4};
+    SECTION("binds to lvalues") {
+        dropwhile(less_than_five, bi);
+        REQUIRE_FALSE( bi.was_moved_from() );
+    }
+    SECTION("moves rvalues") {
+        dropwhile(less_than_five, std::move(bi));
+        REQUIRE( bi.was_moved_from() );
+    }
+}

From aaa7cd52fec77b230ffb2eac58086f23eedf8a67 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 12 Dec 2014 17:40:42 -0500
Subject: [PATCH 0687/1866] tests dropwhile with solidint

---
 catchtest/test_dropwhile.cpp | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/catchtest/test_dropwhile.cpp b/catchtest/test_dropwhile.cpp
index 3fe6e7ab..07b6b907 100644
--- a/catchtest/test_dropwhile.cpp
+++ b/catchtest/test_dropwhile.cpp
@@ -74,3 +74,12 @@ TEST_CASE("dropwhile: binds to lvalues, moves rvalues", "[dropwhile]") {
         REQUIRE( bi.was_moved_from() );
     }
 }
+
+TEST_CASE("dropwhile: doesn't move or copy elements of iterable",
+        "[dropwhile]") {
+    constexpr itertest::SolidInt arr[] = {{6}, {7}, {8}};
+    for (auto&& i : dropwhile(
+                [](const itertest::SolidInt&){return false;} , arr)) {
+        (void)i;
+    }
+}

From e219b44fd3f5807a137e7278acb2a5ba495498f7 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 13 Dec 2014 14:11:57 -0500
Subject: [PATCH 0688/1866] adds filter catch tests

---
 catchtest/test_filter.cpp | 54 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 54 insertions(+)
 create mode 100644 catchtest/test_filter.cpp

diff --git a/catchtest/test_filter.cpp b/catchtest/test_filter.cpp
new file mode 100644
index 00000000..23313b61
--- /dev/null
+++ b/catchtest/test_filter.cpp
@@ -0,0 +1,54 @@
+#include <filter.hpp>
+
+#include "helpers.hpp"
+
+#include <vector>
+#include <string>
+#include <iterator>
+
+#include "catch.hpp"
+
+using iter::filter;
+
+using Vec = const std::vector<int>;
+
+namespace {
+    bool less_than_five(int i) {
+        return i < 5;
+    }
+
+    class LessThanValue {
+        private:
+            int compare_val;
+
+        public:
+            LessThanValue(int v) : compare_val(v) { }
+
+            bool operator() (int i) {
+                return i < this->compare_val;
+            }
+    };
+}
+
+TEST_CASE("filter: handles different functor types", "[filter]") {
+    Vec ns = {1,2, 5,6, 3,1, 7, -1, 5};
+    Vec vc = {1,2,3,1,-1};
+    SECTION("with function pointer") {
+        auto f = filter(less_than_five, ns);
+        Vec v(std::begin(f), std::end(f));
+        REQUIRE( v == vc );
+    }
+
+    SECTION("with callable object") {
+        auto f = filter(LessThanValue{5}, ns);
+        Vec v(std::begin(f), std::end(f));
+        REQUIRE( v == vc );
+    }
+
+    SECTION("with lambda") {
+        auto ltf = [](int i) {return i < 5;};
+        auto f = filter(ltf, ns);
+        Vec v(std::begin(f), std::end(f));
+        REQUIRE( v == vc );
+    }
+}

From b051431b843082800c2effacb043053589983918 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 13 Dec 2014 14:12:21 -0500
Subject: [PATCH 0689/1866] filter iter inherits from std iterator

---
 filter.hpp | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/filter.hpp b/filter.hpp
index 50871be9..a5459540 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -45,7 +45,10 @@ namespace iter {
         public:
             Filter(const Filter&) = default;
 
-            class Iterator {
+            class Iterator 
+                : public std::iterator<std::input_iterator_tag,
+                        iterator_traits_deref<Container>>
+            {
                 protected:
                     iterator_type<Container> sub_iter;
                     const iterator_type<Container> sub_end;

From 1a95d8d03ff56e9fdf10c41aef769f1f7fe598c1 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 13 Dec 2014 14:12:55 -0500
Subject: [PATCH 0690/1866] adds filter iter postfix ++

---
 filter.hpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/filter.hpp b/filter.hpp
index a5459540..ebd47a32 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -84,6 +84,12 @@ namespace iter {
                         return *this;
                     }
 
+                    Iterator operator++(int) {
+                        auto ret = *this;
+                        ++*this;
+                        return ret;
+                    }
+
                     bool operator!=(const Iterator& other) const {
                         return this->sub_iter != other.sub_iter;
                     }

From bc4b1235bfe833c1fa3b7ad8e69d30d6a31e337a Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 13 Dec 2014 14:14:17 -0500
Subject: [PATCH 0691/1866] adds filter iter ==

---
 filter.hpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/filter.hpp b/filter.hpp
index ebd47a32..b2a26bb5 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -93,6 +93,10 @@ namespace iter {
                     bool operator!=(const Iterator& other) const {
                         return this->sub_iter != other.sub_iter;
                     }
+
+                    bool operator==(const Iterator& other) const {
+                        return !(*this != other);
+                    }
             };
 
             Iterator begin() {

From 35eaa25c1ed5101a42da10f6c24b005a00e6f83e Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 13 Dec 2014 14:14:34 -0500
Subject: [PATCH 0692/1866] makes filter iterators assignable

---
 filter.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/filter.hpp b/filter.hpp
index b2a26bb5..7d5e8f4e 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -51,7 +51,7 @@ namespace iter {
             {
                 protected:
                     iterator_type<Container> sub_iter;
-                    const iterator_type<Container> sub_end;
+                    iterator_type<Container> sub_end;
                     FilterFunc filter_func;
 
                     // increment until the iterator points to is true on the 

From b712013f7f80bfae735daec932f479dd5999ac6a Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 13 Dec 2014 14:18:25 -0500
Subject: [PATCH 0693/1866] tests 1 argument version of filter

---
 catchtest/test_filter.cpp | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/catchtest/test_filter.cpp b/catchtest/test_filter.cpp
index 23313b61..24f7d19d 100644
--- a/catchtest/test_filter.cpp
+++ b/catchtest/test_filter.cpp
@@ -52,3 +52,11 @@ TEST_CASE("filter: handles different functor types", "[filter]") {
         REQUIRE( v == vc );
     }
 }
+
+TEST_CASE("filter: using identity", "[filter]") {
+    Vec ns{0, 1, 2, 0, 3, 0, 0, 0, 4, 5, 0};
+    Vec vc = {1,2,3,4,5};
+    auto f = filter(ns);
+    Vec v(std::begin(f), std::end(f));
+    REQUIRE( v == vc );
+}

From 82a8ce834bf1c9b0381e2f2f8332546b27c2543d Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 13 Dec 2014 14:18:34 -0500
Subject: [PATCH 0694/1866] builds filter test

---
 catchtest/SConstruct | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/catchtest/SConstruct b/catchtest/SConstruct
index 5bc85a89..7125b925 100644
--- a/catchtest/SConstruct
+++ b/catchtest/SConstruct
@@ -15,7 +15,6 @@ env['ENV']['TERM'] = os.environ['TERM']
 
 progs = Split(
     '''
-    enumerate
     zip
     range
     accumulate
@@ -26,6 +25,8 @@ progs = Split(
     count
     cycle
     dropwhile
+    enumerate
+    filter
     '''
 )
 

From 3f93775c947a59aa1f0c283a053e433976d8a703 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 13 Dec 2014 14:18:55 -0500
Subject: [PATCH 0695/1866] removes trailing filter comment

---
 filter.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/filter.hpp b/filter.hpp
index 7d5e8f4e..25a6950a 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -167,4 +167,4 @@ namespace iter {
 
 }
 
-#endif // #ifndef ITER_FILTER_H_
+#endif

From e46591e9ba2af417106b7e0f8ead91fe57ab22f5 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 13 Dec 2014 14:25:34 -0500
Subject: [PATCH 0696/1866] makes Filter copyable and movable (when it can)

Actually let's the compiler figure it out
---
 filter.hpp | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/filter.hpp b/filter.hpp
index 25a6950a..28ab60b7 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -39,11 +39,8 @@ namespace iter {
                 : container(std::forward<Container>(container)),
                 filter_func(filter_func)
             { }
-            Filter() = delete;
-            Filter& operator=(const Filter&) = delete;
 
         public:
-            Filter(const Filter&) = default;
 
             class Iterator 
                 : public std::iterator<std::input_iterator_tag,

From 2617835fe0e54162bd645796a38faf52f9efd155 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 13 Dec 2014 14:28:08 -0500
Subject: [PATCH 0697/1866] tests than filter moves and binds correctly

---
 catchtest/test_filter.cpp | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/catchtest/test_filter.cpp b/catchtest/test_filter.cpp
index 24f7d19d..3975960f 100644
--- a/catchtest/test_filter.cpp
+++ b/catchtest/test_filter.cpp
@@ -60,3 +60,27 @@ TEST_CASE("filter: using identity", "[filter]") {
     Vec v(std::begin(f), std::end(f));
     REQUIRE( v == vc );
 }
+
+TEST_CASE("filter: binds to lvalues, moves rvales", "[filter]") {
+    itertest::BasicIterable<int> bi{1,2,3,4};
+
+    SECTION("one-arg binds to lvalues") {
+        filter(bi);
+        REQUIRE_FALSE(bi.was_moved_from());
+    }
+
+    SECTION("two-arg binds to lvalues") {
+        filter(less_than_five, bi);
+        REQUIRE_FALSE(bi.was_moved_from());
+    }
+
+    SECTION("one-arg moves rvalues") {
+        filter(std::move(bi));
+        REQUIRE(bi.was_moved_from());
+    }
+
+    SECTION("two-arg moves rvalues") {
+        filter(less_than_five, std::move(bi));
+        REQUIRE(bi.was_moved_from());
+    }
+}

From 6ed205d57bda1121ca5516c9343f66bacddff902 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 13 Dec 2014 14:29:07 -0500
Subject: [PATCH 0698/1866] ignores .swp files

---
 catchtest/.gitignore | 1 +
 1 file changed, 1 insertion(+)

diff --git a/catchtest/.gitignore b/catchtest/.gitignore
index 427dd64a..c686c757 100644
--- a/catchtest/.gitignore
+++ b/catchtest/.gitignore
@@ -1,4 +1,5 @@
 *.o
+*.swp
 test_*
 !test_*.cpp
 .sconsign.dblite

From 53db4ac2b60ed7a963eb74fa73c2bd464535f1cf Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 13 Dec 2014 14:33:41 -0500
Subject: [PATCH 0699/1866] tests filter with solidint

---
 catchtest/test_filter.cpp | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/catchtest/test_filter.cpp b/catchtest/test_filter.cpp
index 3975960f..31fe2fba 100644
--- a/catchtest/test_filter.cpp
+++ b/catchtest/test_filter.cpp
@@ -84,3 +84,11 @@ TEST_CASE("filter: binds to lvalues, moves rvales", "[filter]") {
         REQUIRE(bi.was_moved_from());
     }
 }
+
+TEST_CASE("filter: doesn't move or copy elements of iterable", "[filter]") {
+    constexpr itertest::SolidInt arr[] = {{1}, {0}, {2}};
+    for (auto&& i : filter(
+                [](const itertest::SolidInt& si) {return si.getint();},arr)) {
+        (void)i;
+    }
+}

From b345a8a66a721886d660384cd336c780b8665e94 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 13 Dec 2014 19:07:24 -0500
Subject: [PATCH 0700/1866] uniform initialization in enumerate *

---
 enumerate.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index a3208cda..845b0412 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -77,7 +77,7 @@ namespace iter {
                     { } 
 
                     IterYield operator*() {
-                        return IterYield(this->index, *this->sub_iter);
+                        return {this->index, *this->sub_iter};
                     }
 
                     Iterator& operator++() { 

From 16962081276d47a098ee33aa14358b95b00b2283 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 13 Dec 2014 19:11:04 -0500
Subject: [PATCH 0701/1866] tests filter when all elements fail

---
 catchtest/test_filter.cpp | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/catchtest/test_filter.cpp b/catchtest/test_filter.cpp
index 31fe2fba..eb21b2c2 100644
--- a/catchtest/test_filter.cpp
+++ b/catchtest/test_filter.cpp
@@ -55,9 +55,10 @@ TEST_CASE("filter: handles different functor types", "[filter]") {
 
 TEST_CASE("filter: using identity", "[filter]") {
     Vec ns{0, 1, 2, 0, 3, 0, 0, 0, 4, 5, 0};
-    Vec vc = {1,2,3,4,5};
     auto f = filter(ns);
     Vec v(std::begin(f), std::end(f));
+
+    Vec vc = {1,2,3,4,5};
     REQUIRE( v == vc );
 }
 
@@ -85,6 +86,14 @@ TEST_CASE("filter: binds to lvalues, moves rvales", "[filter]") {
     }
 }
 
+
+TEST_CASE("filter: all elements fail predicate", "[filter]") {
+    Vec ns{10,20,30,40,50};
+    auto f = filter(less_than_five, ns);
+
+    REQUIRE( std::begin(f) == std::end(f) );
+}
+
 TEST_CASE("filter: doesn't move or copy elements of iterable", "[filter]") {
     constexpr itertest::SolidInt arr[] = {{1}, {0}, {2}};
     for (auto&& i : filter(

From f4705aa47d101223e1826f6e4a477a28c0f33e0e Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 13 Dec 2014 19:38:13 -0500
Subject: [PATCH 0702/1866] tests filterfalse with different callables

---
 catchtest/test_filterfalse.cpp | 54 ++++++++++++++++++++++++++++++++++
 1 file changed, 54 insertions(+)
 create mode 100644 catchtest/test_filterfalse.cpp

diff --git a/catchtest/test_filterfalse.cpp b/catchtest/test_filterfalse.cpp
new file mode 100644
index 00000000..9ee1dc69
--- /dev/null
+++ b/catchtest/test_filterfalse.cpp
@@ -0,0 +1,54 @@
+#include <filterfalse.hpp>
+
+#include "helpers.hpp"
+
+#include <vector>
+#include <string>
+#include <iterator>
+
+#include "catch.hpp"
+
+using iter::filterfalse;
+
+using Vec = const std::vector<int>;
+
+namespace {
+    bool less_than_five(int i) {
+        return i < 5;
+    }
+
+    class LessThanValue {
+        private:
+            int compare_val;
+
+        public:
+            LessThanValue(int v) : compare_val(v) { }
+
+            bool operator() (int i) {
+                return i < this->compare_val;
+            }
+    };
+}
+
+TEST_CASE("filterfalse: handles different functor types", "[filterfalse]") {
+    Vec ns = {1,2, 5,6, 3,1, 7, -1, 5};
+    Vec vc = {5,6,7,5};
+    SECTION("with function pointer") {
+        auto f = filterfalse(less_than_five, ns);
+        Vec v(std::begin(f), std::end(f));
+        REQUIRE( v == vc );
+    }
+
+    SECTION("with callable object") {
+        auto f = filterfalse(LessThanValue{5}, ns);
+        Vec v(std::begin(f), std::end(f));
+        REQUIRE( v == vc );
+    }
+
+    SECTION("with lambda") {
+        auto ltf = [](int i) {return i < 5;};
+        auto f = filterfalse(ltf, ns);
+        Vec v(std::begin(f), std::end(f));
+        REQUIRE( v == vc );
+    }
+}

From cefc86658985387c47079c09d559a7ea152f2348 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 13 Dec 2014 19:38:27 -0500
Subject: [PATCH 0703/1866] Adds non-const operator() to filter false

If the incoming callable doesn't have an operator() const; then I need
the PredicateFlipper to have a non-const operator() as well
---
 filterfalse.hpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/filterfalse.hpp b/filterfalse.hpp
index 27e8cf03..38ded919 100644
--- a/filterfalse.hpp
+++ b/filterfalse.hpp
@@ -29,6 +29,11 @@ namespace iter {
                 bool operator() (const iterator_deref<Container> item) const {
                     return !bool(filter_func(item));
                 }
+
+                // with non-const incase FilterFunc::operator() is non-const
+                bool operator() (const iterator_deref<Container> item) {
+                    return !bool(filter_func(item));
+                }
         };
 
         // Reverses the bool() conversion result of anything that supports a

From d2b56065d1d47b8058f05c4bc11dc2cc1b6fcbb0 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 13 Dec 2014 19:39:48 -0500
Subject: [PATCH 0704/1866] builds filterfalse catchtest

---
 catchtest/SConstruct | 1 +
 1 file changed, 1 insertion(+)

diff --git a/catchtest/SConstruct b/catchtest/SConstruct
index 7125b925..46606e89 100644
--- a/catchtest/SConstruct
+++ b/catchtest/SConstruct
@@ -27,6 +27,7 @@ progs = Split(
     dropwhile
     enumerate
     filter
+    filterfalse
     '''
 )
 

From 677ddda4965ce39478d3c0660075d9cfd7fc3343 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 13 Dec 2014 19:41:12 -0500
Subject: [PATCH 0705/1866] Tests one-arg filter false

---
 catchtest/test_filterfalse.cpp | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/catchtest/test_filterfalse.cpp b/catchtest/test_filterfalse.cpp
index 9ee1dc69..1bd505d9 100644
--- a/catchtest/test_filterfalse.cpp
+++ b/catchtest/test_filterfalse.cpp
@@ -52,3 +52,12 @@ TEST_CASE("filterfalse: handles different functor types", "[filterfalse]") {
         REQUIRE( v == vc );
     }
 }
+
+TEST_CASE("filterfalse: using identity", "[filterfalse]") {
+    Vec ns{0, 1, 2, 0, 3, 0, 0, 0, 4, 5, 0};
+    auto f = filterfalse(ns);
+    Vec v(std::begin(f), std::end(f));
+
+    Vec vc = {0, 0, 0, 0, 0, 0};
+    REQUIRE( v == vc );
+}

From 5df09b9052257f297209f232422fad9a0abf19d2 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 13 Dec 2014 19:45:17 -0500
Subject: [PATCH 0706/1866] makes sure filterfalse moves and binds correctly

---
 catchtest/test_filterfalse.cpp | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/catchtest/test_filterfalse.cpp b/catchtest/test_filterfalse.cpp
index 1bd505d9..5ee8ea03 100644
--- a/catchtest/test_filterfalse.cpp
+++ b/catchtest/test_filterfalse.cpp
@@ -61,3 +61,27 @@ TEST_CASE("filterfalse: using identity", "[filterfalse]") {
     Vec vc = {0, 0, 0, 0, 0, 0};
     REQUIRE( v == vc );
 }
+
+TEST_CASE("filterfalse: binds to lvalues, moves rvales", "[filterfalse]") {
+    itertest::BasicIterable<int> bi{1,2,3,4};
+
+    SECTION("one-arg binds to lvalues") {
+        filterfalse(bi);
+        REQUIRE_FALSE(bi.was_moved_from());
+    }
+
+    SECTION("two-arg binds to lvalues") {
+        filterfalse(less_than_five, bi);
+        REQUIRE_FALSE(bi.was_moved_from());
+    }
+
+    SECTION("one-arg moves rvalues") {
+        filterfalse(std::move(bi));
+        REQUIRE(bi.was_moved_from());
+    }
+
+    SECTION("two-arg moves rvalues") {
+        filterfalse(less_than_five, std::move(bi));
+        REQUIRE(bi.was_moved_from());
+    }
+}

From e911bec91e8d6e8231ed709b6fdda81e2d9d8f51 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 13 Dec 2014 19:49:46 -0500
Subject: [PATCH 0707/1866] tests filterfalse when all elements fail predicate

---
 catchtest/test_filterfalse.cpp | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/catchtest/test_filterfalse.cpp b/catchtest/test_filterfalse.cpp
index 5ee8ea03..ca6ec915 100644
--- a/catchtest/test_filterfalse.cpp
+++ b/catchtest/test_filterfalse.cpp
@@ -85,3 +85,10 @@ TEST_CASE("filterfalse: binds to lvalues, moves rvales", "[filterfalse]") {
         REQUIRE(bi.was_moved_from());
     }
 }
+
+TEST_CASE("filterfalse: all elements pass predicate", "[filterfalse]") {
+    Vec ns{0,1,2,3,4};
+    auto f = filterfalse(less_than_five, ns);
+
+    REQUIRE( std::begin(f) == std::end(f) );
+}

From 7565b8438805bee5078b184fec76c20df823600d Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 14 Dec 2014 18:28:33 -0500
Subject: [PATCH 0708/1866] adds basic groupby test

---
 catchtest/test_groupby.cpp | 43 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)
 create mode 100644 catchtest/test_groupby.cpp

diff --git a/catchtest/test_groupby.cpp b/catchtest/test_groupby.cpp
new file mode 100644
index 00000000..83de6577
--- /dev/null
+++ b/catchtest/test_groupby.cpp
@@ -0,0 +1,43 @@
+#include <groupby.hpp>
+
+#include "helpers.hpp"
+
+#include <vector>
+#include <string>
+#include <iterator>
+
+#include "catch.hpp"
+
+using iter::groupby;
+
+namespace {
+    int length(const std::string& s) {
+        return s.size();
+    }
+}
+
+TEST_CASE("groupby: groups words by length") {
+    const std::vector<std::string> vec = {
+        "hi", "ab", "ho",
+        "abc", "def",
+        "abcde", "efghi"
+    };
+
+    std::vector<int> keys;
+    std::vector<std::vector<std::string>> groups;
+    for (auto gb : groupby(vec, &length)) {
+        keys.push_back(gb.first);
+        groups.emplace_back(std::begin(gb.second), std::end(gb.second));
+    }
+
+    const std::vector<int> kc = {2, 3, 5};
+    REQUIRE( keys == kc );
+
+    const std::vector<std::vector<std::string>> gc = {
+        {"hi", "ab", "ho"},
+        {"abc", "def"},
+        {"abcde", "efghi"},
+    };
+
+    REQUIRE( groups == gc );
+}

From 22663f097bcb93101be7ad0b761d35d9244ad754 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 14 Dec 2014 18:28:46 -0500
Subject: [PATCH 0709/1866] GroupIterator inherits from std::iterator

---
 groupby.hpp | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/groupby.hpp b/groupby.hpp
index e26a7e04..4febf64e 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -151,7 +151,10 @@ namespace iter {
                         other.completed = true;
                     }
 
-                    class GroupIterator {
+                    class GroupIterator 
+                        : public std::iterator<std::input_iterator_tag,
+                                iterator_traits_deref<Container>>
+                    {
                         private:
                             const key_func_ret key;
                             const Group& group;

From f0eddb4ade840a8fb98d7cfe58dca221da1ef873 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 14 Dec 2014 18:29:21 -0500
Subject: [PATCH 0710/1866] builds groupby test

---
 catchtest/SConstruct | 1 +
 1 file changed, 1 insertion(+)

diff --git a/catchtest/SConstruct b/catchtest/SConstruct
index 46606e89..30ac43d8 100644
--- a/catchtest/SConstruct
+++ b/catchtest/SConstruct
@@ -28,6 +28,7 @@ progs = Split(
     enumerate
     filter
     filterfalse
+    groupby
     '''
 )
 

From 81f22a889d429608c045913874790e418547dccc Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 14 Dec 2014 18:34:58 -0500
Subject: [PATCH 0711/1866] add GroupIterator == and postfix ++

---
 groupby.hpp | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/groupby.hpp b/groupby.hpp
index 4febf64e..a2c4639c 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -182,11 +182,21 @@ namespace iter {
                                 }
                             }
 
+                            bool operator==(const GroupIterator& other) const {
+                                return !(*this != other);
+                            }
+
                             GroupIterator& operator++() {
                                 this->group.owner.increment_iterator();
                                 return *this;
                             }
 
+                            GroupIterator operator++(int) {
+                                auto ret = *this;
+                                ++*this;
+                                return ret;
+                            }
+
                             iterator_deref<Container> operator*() {
                                 return this->group.owner.current();
                             }

From 3e8de5bc81dd6f011d4ac2d1b205ad7c42f1d411 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 14 Dec 2014 21:34:01 -0500
Subject: [PATCH 0712/1866] groupby iterator inherits from std iterator

---
 groupby.hpp | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/groupby.hpp b/groupby.hpp
index a2c4639c..fc3fc743 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -51,16 +51,20 @@ namespace iter {
             class Iterator;
             class Group;
 
-            class Iterator {
+        private:
+            using KeyGroupPair =
+                std::pair<key_func_ret, Group>;
+        public:
+
+            class Iterator 
+                : public std::iterator<std::input_iterator_tag, KeyGroupPair>
+            {
                 private:
                     iterator_type<Container> sub_iter;
                     iterator_type<Container> sub_iter_peek;
                     const iterator_type<Container> sub_end;
                     KeyFunc key_func;
 
-                    using KeyGroupPair =
-                        std::pair<key_func_ret, Group>;
-
                 public:
                     Iterator (iterator_type<Container> si,
                               iterator_type<Container> end,

From c26959f5b1fe9437a9e27c79b0f09ae8321b935a Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 14 Dec 2014 21:35:55 -0500
Subject: [PATCH 0713/1866] adds groupby iterator ==

---
 groupby.hpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/groupby.hpp b/groupby.hpp
index fc3fc743..175b4728 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -90,6 +90,10 @@ namespace iter {
                         return !this->exhausted();
                     }
 
+                    bool operator==(const Iterator& other) const {
+                        return !(*this != other);
+                    }
+
                     void increment_iterator() {
                         if (this->sub_iter != this->sub_end) {
                             ++this->sub_iter;

From 4cf5e9cf2a0c3ad234ba6a00ec60f411d58d6495 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 14 Dec 2014 21:38:09 -0500
Subject: [PATCH 0714/1866] adds groupby iterator postfix++

I don't feel too good about this one, let it be known
---
 groupby.hpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/groupby.hpp b/groupby.hpp
index 175b4728..79960c8b 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -86,6 +86,12 @@ namespace iter {
                         return *this;
                     }
 
+                    Iterator operator++(int) {
+                        auto ret = *this;
+                        ++*this;
+                        return ret;
+                    }
+
                     bool operator!=(const Iterator&) const {
                         return !this->exhausted();
                     }

From d6a119c018321685d554576616a8e094c92daccf Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 14 Dec 2014 22:29:59 -0500
Subject: [PATCH 0715/1866] tests that groups may be skipped

---
 catchtest/test_groupby.cpp | 52 ++++++++++++++++++++++++++++++++++++--
 1 file changed, 50 insertions(+), 2 deletions(-)

diff --git a/catchtest/test_groupby.cpp b/catchtest/test_groupby.cpp
index 83de6577..3540a950 100644
--- a/catchtest/test_groupby.cpp
+++ b/catchtest/test_groupby.cpp
@@ -14,15 +14,16 @@ namespace {
     int length(const std::string& s) {
         return s.size();
     }
-}
 
-TEST_CASE("groupby: groups words by length") {
     const std::vector<std::string> vec = {
         "hi", "ab", "ho",
         "abc", "def",
         "abcde", "efghi"
     };
 
+}
+
+TEST_CASE("groupby: groups words by length") {
     std::vector<int> keys;
     std::vector<std::vector<std::string>> groups;
     for (auto gb : groupby(vec, &length)) {
@@ -41,3 +42,50 @@ TEST_CASE("groupby: groups words by length") {
 
     REQUIRE( groups == gc );
 }
+
+TEST_CASE("groupby: groups can be skipped completely", "[groupby]") {
+    std::vector<int> keys;
+    std::vector<std::vector<std::string>> groups;
+    for (auto gb : groupby(vec, &length)) {
+        if (gb.first == 3) {
+            continue;
+        }
+        keys.push_back(gb.first);
+        groups.emplace_back(std::begin(gb.second), std::end(gb.second));
+    }
+
+    const std::vector<int> kc = {2, 5};
+    REQUIRE( keys == kc );
+
+    const std::vector<std::vector<std::string>> gc = {
+        {"hi", "ab", "ho"},
+        {"abcde", "efghi"},
+    };
+
+    REQUIRE( groups == gc );
+}
+
+TEST_CASE("groupby: groups can be skipped partially", "[groupby]") {
+    std::vector<int> keys;
+    std::vector<std::vector<std::string>> groups;
+    for (auto gb : groupby(vec, &length)) {
+        keys.push_back(gb.first);
+        if (gb.first == 3) {
+            std::vector<std::string> cut_short = {*std::begin(gb.second)};
+            groups.push_back(cut_short);
+        } else {
+            groups.emplace_back(std::begin(gb.second), std::end(gb.second));
+        }
+    }
+
+    const std::vector<int> kc = {2, 3, 5};
+    REQUIRE( keys == kc );
+
+    const std::vector<std::vector<std::string>> gc = {
+        {"hi", "ab", "ho"},
+        {"abc"},
+        {"abcde", "efghi"},
+    };
+
+    REQUIRE( groups == gc );
+}

From b0b1c92f82249b54ec960fb9ecd601625b915c97 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 14 Dec 2014 22:38:10 -0500
Subject: [PATCH 0716/1866] tests single argument groupby

---
 catchtest/test_groupby.cpp | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/catchtest/test_groupby.cpp b/catchtest/test_groupby.cpp
index 3540a950..f2fd484e 100644
--- a/catchtest/test_groupby.cpp
+++ b/catchtest/test_groupby.cpp
@@ -89,3 +89,27 @@ TEST_CASE("groupby: groups can be skipped partially", "[groupby]") {
 
     REQUIRE( groups == gc );
 }
+
+TEST_CASE("groupby: single argument uses elements as keys", "[groupby]") {
+    std::vector<int> ivec = {5, 5, 6, 6, 19, 19, 19, 19, 69, 0, 10, 10};
+    std::vector<int> keys;
+    std::vector<std::vector<int>> groups;
+    for (auto gb : groupby(ivec)) {
+        keys.push_back(gb.first);
+        groups.emplace_back(std::begin(gb.second), std::end(gb.second));
+    }
+
+    const std::vector<int> kc = {5, 6, 19, 69, 0, 10};
+    REQUIRE( keys == kc );
+
+    std::vector<std::vector<int>> gc = {
+        {5, 5},
+        {6, 6},
+        {19, 19, 19, 19},
+        {69},
+        {0},
+        {10, 10},
+    };
+
+    REQUIRE( groups == gc );
+}

From e1ca5b32f61b32abd40c64746d467675084cca73 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 14 Dec 2014 22:45:33 -0500
Subject: [PATCH 0717/1866] tests groupby with empty iterable

---
 catchtest/test_groupby.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/catchtest/test_groupby.cpp b/catchtest/test_groupby.cpp
index f2fd484e..d27da643 100644
--- a/catchtest/test_groupby.cpp
+++ b/catchtest/test_groupby.cpp
@@ -113,3 +113,9 @@ TEST_CASE("groupby: single argument uses elements as keys", "[groupby]") {
 
     REQUIRE( groups == gc );
 }
+
+TEST_CASE("groupby: empty iterable yields nothing", "[groupby]") {
+    std::vector<int> ivec{};
+    auto g = groupby(ivec);
+    REQUIRE( std::begin(g) == std::end(g) );
+}

From b111fcdc2861a916d7bff11a7203e1b18eb99e89 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 15 Dec 2014 00:55:04 -0500
Subject: [PATCH 0718/1866] tests groupby without iterating through groups

---
 catchtest/test_groupby.cpp | 18 ++++++++++++++----
 1 file changed, 14 insertions(+), 4 deletions(-)

diff --git a/catchtest/test_groupby.cpp b/catchtest/test_groupby.cpp
index d27da643..a1fbae32 100644
--- a/catchtest/test_groupby.cpp
+++ b/catchtest/test_groupby.cpp
@@ -26,7 +26,7 @@ namespace {
 TEST_CASE("groupby: groups words by length") {
     std::vector<int> keys;
     std::vector<std::vector<std::string>> groups;
-    for (auto gb : groupby(vec, &length)) {
+    for (auto&& gb : groupby(vec, &length)) {
         keys.push_back(gb.first);
         groups.emplace_back(std::begin(gb.second), std::end(gb.second));
     }
@@ -46,7 +46,7 @@ TEST_CASE("groupby: groups words by length") {
 TEST_CASE("groupby: groups can be skipped completely", "[groupby]") {
     std::vector<int> keys;
     std::vector<std::vector<std::string>> groups;
-    for (auto gb : groupby(vec, &length)) {
+    for (auto&& gb : groupby(vec, &length)) {
         if (gb.first == 3) {
             continue;
         }
@@ -68,7 +68,7 @@ TEST_CASE("groupby: groups can be skipped completely", "[groupby]") {
 TEST_CASE("groupby: groups can be skipped partially", "[groupby]") {
     std::vector<int> keys;
     std::vector<std::vector<std::string>> groups;
-    for (auto gb : groupby(vec, &length)) {
+    for (auto&& gb : groupby(vec, &length)) {
         keys.push_back(gb.first);
         if (gb.first == 3) {
             std::vector<std::string> cut_short = {*std::begin(gb.second)};
@@ -94,7 +94,7 @@ TEST_CASE("groupby: single argument uses elements as keys", "[groupby]") {
     std::vector<int> ivec = {5, 5, 6, 6, 19, 19, 19, 19, 69, 0, 10, 10};
     std::vector<int> keys;
     std::vector<std::vector<int>> groups;
-    for (auto gb : groupby(ivec)) {
+    for (auto&& gb : groupby(ivec)) {
         keys.push_back(gb.first);
         groups.emplace_back(std::begin(gb.second), std::end(gb.second));
     }
@@ -119,3 +119,13 @@ TEST_CASE("groupby: empty iterable yields nothing", "[groupby]") {
     auto g = groupby(ivec);
     REQUIRE( std::begin(g) == std::end(g) );
 }
+
+TEST_CASE("groupby: inner iterator (group) not used", "[groupby]") {
+    std::vector<int> keys;
+    for (auto&& gb : groupby(vec, length)) {
+        keys.push_back(gb.first);
+    }
+    
+    std::vector<int> kc = {2, 3, 5};
+    REQUIRE( keys == kc );
+}

From 1cb217cf4ecd6813e5abcfcc5e154fabb14b131a Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 8 Jan 2015 17:13:58 -0500
Subject: [PATCH 0719/1866] tests imap with different callables

---
 catchtest/test_imap.cpp | 50 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 50 insertions(+)
 create mode 100644 catchtest/test_imap.cpp

diff --git a/catchtest/test_imap.cpp b/catchtest/test_imap.cpp
new file mode 100644
index 00000000..e104164a
--- /dev/null
+++ b/catchtest/test_imap.cpp
@@ -0,0 +1,50 @@
+#include <imap.hpp>
+
+#include "helpers.hpp"
+
+#include <vector>
+#include <string>
+#include <iterator>
+
+#include "catch.hpp"
+
+using iter::imap;
+using Vec = const std::vector<int>;
+
+namespace {
+    int plusone(int i) {
+        return i + 1;
+    }
+
+    class PlusOner {
+        public:
+            int operator()(int i) {
+                return i + 1;
+            }
+    };
+}
+
+TEST_CASE("imap: works with lambda, callable, and function", "[imap]") {
+    std::vector<int> ns = {10, 20, 30};
+    SECTION("with lambda") {
+        auto im = imap([](int i) { return i + 1; }, ns);
+        Vec v(std::begin(im), std::end(im));
+        Vec vc = {11, 21, 31};
+        REQUIRE(v == vc);
+    }
+
+    SECTION("with function") {
+        auto im = imap(plusone, ns);
+        Vec v(std::begin(im), std::end(im));
+        Vec vc = {11, 21, 31};
+        REQUIRE(v == vc);
+    }
+
+    SECTION("with function") {
+        auto im = imap(PlusOner{}, ns);
+        Vec v(std::begin(im), std::end(im));
+        Vec vc = {11, 21, 31};
+        REQUIRE(v == vc);
+    }
+
+}

From 0cde291c19fe89c0971867fd9759d368214eeb8d Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 8 Jan 2015 17:14:28 -0500
Subject: [PATCH 0720/1866] imap iter inherits from std::iterator

---
 imap.hpp | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/imap.hpp b/imap.hpp
index fd6f0ecc..0f9bc485 100644
--- a/imap.hpp
+++ b/imap.hpp
@@ -78,6 +78,9 @@ namespace iter {
         private:
             MapFunc map_func;
             ZippedType zipped;
+
+            using IMapIterDeref = decltype(detail::call_with_tuple(
+                        map_func, *std::begin(zipped)));
             
             // Value constructor for use only in the imap function
             IMap(MapFunc map_func, Containers&& ... containers) :
@@ -91,7 +94,9 @@ namespace iter {
             IMap(const IMap&) = default;
             IMap(IMap&&) = default;
 
-            class Iterator {
+            class Iterator 
+                : public std::iterator<std::input_iterator_tag, IMapIterDeref>
+            {
                 private:
                     MapFunc map_func;
                     ZippedIterType zipiter;
@@ -102,10 +107,7 @@ namespace iter {
                         zipiter(zipiter)
                     { } 
 
-                    auto operator*() -> 
-                        decltype(detail::call_with_tuple(
-                                    this->map_func, *(this->zipiter)))
-                    {
+                    IMapIterDeref operator*() {
                         return detail::call_with_tuple(
                                 this->map_func, *(this->zipiter));
                     }

From 2ae589345603ede5ff88f3c446431d95bc66898b Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 8 Jan 2015 17:21:38 -0500
Subject: [PATCH 0721/1866] SConstruct builds imap test

---
 catchtest/SConstruct | 1 +
 1 file changed, 1 insertion(+)

diff --git a/catchtest/SConstruct b/catchtest/SConstruct
index 30ac43d8..8e4b799b 100644
--- a/catchtest/SConstruct
+++ b/catchtest/SConstruct
@@ -29,6 +29,7 @@ progs = Split(
     filter
     filterfalse
     groupby
+    imap
     '''
 )
 

From a1ea801b42a283f816d5eeb4ce5634978ef1ba19 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 8 Jan 2015 17:28:55 -0500
Subject: [PATCH 0722/1866] tests imap with multiple sequences

---
 catchtest/test_imap.cpp | 25 ++++++++++++++++++++++---
 1 file changed, 22 insertions(+), 3 deletions(-)

diff --git a/catchtest/test_imap.cpp b/catchtest/test_imap.cpp
index e104164a..7532e93e 100644
--- a/catchtest/test_imap.cpp
+++ b/catchtest/test_imap.cpp
@@ -22,6 +22,14 @@ namespace {
                 return i + 1;
             }
     };
+
+    int power(int b, int e) {
+        int acc = 1;
+        for (int i = 0; i < e; ++i) {
+            acc *= b;
+        }
+        return acc;
+    }
 }
 
 TEST_CASE("imap: works with lambda, callable, and function", "[imap]") {
@@ -30,21 +38,32 @@ TEST_CASE("imap: works with lambda, callable, and function", "[imap]") {
         auto im = imap([](int i) { return i + 1; }, ns);
         Vec v(std::begin(im), std::end(im));
         Vec vc = {11, 21, 31};
-        REQUIRE(v == vc);
+        REQUIRE( v == vc );
     }
 
     SECTION("with function") {
         auto im = imap(plusone, ns);
         Vec v(std::begin(im), std::end(im));
         Vec vc = {11, 21, 31};
-        REQUIRE(v == vc);
+        REQUIRE( v == vc );
     }
 
     SECTION("with function") {
         auto im = imap(PlusOner{}, ns);
         Vec v(std::begin(im), std::end(im));
         Vec vc = {11, 21, 31};
-        REQUIRE(v == vc);
+        REQUIRE( v == vc );
     }
 
 }
+
+TEST_CASE("imap: works with multiple sequences", "[imap]") {
+    Vec bases = {0, 1, 2, 3};
+    Vec exps = {1, 2, 3, 4};
+
+    auto im = imap(power, bases, exps);
+    Vec v(std::begin(im), std::end(im));
+    Vec vc = {0, 1, 8, 81};
+
+    REQUIRE( v == vc );
+}

From 162889670fae9a39ae38b1e4dad9fe7699d85286 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 8 Jan 2015 17:35:08 -0500
Subject: [PATCH 0723/1866] tests imap with uneven sequences

---
 catchtest/test_imap.cpp | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/catchtest/test_imap.cpp b/catchtest/test_imap.cpp
index 7532e93e..4749d1f2 100644
--- a/catchtest/test_imap.cpp
+++ b/catchtest/test_imap.cpp
@@ -67,3 +67,19 @@ TEST_CASE("imap: works with multiple sequences", "[imap]") {
 
     REQUIRE( v == vc );
 }
+
+TEST_CASE("imap: terminates on shortest squence", "[imap]") {
+    Vec ns1 = {1, 2, 3, 4};
+    Vec ns2 = {2, 4, 6, 8, 10};
+    Vec vc = {3, 6, 9, 12};
+    SECTION("shortest sequence first") {
+        auto im = imap([](int a, int b){ return a + b; }, ns1, ns2);
+        Vec v(std::begin(im), std::end(im));
+        REQUIRE( v == vc );
+    }
+    SECTION("shortest sequence second") {
+        auto im = imap([](int a, int b){ return a + b; }, ns2, ns1);
+        Vec v(std::begin(im), std::end(im));
+        REQUIRE( v == vc );
+    }
+}

From 7c0b37425c011d6ac882522ff4e04d6737b11b6e Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 8 Jan 2015 20:15:25 -0500
Subject: [PATCH 0724/1866] imap correctness tests (copy/move/++)

---
 catchtest/test_imap.cpp | 33 ++++++++++++++++++++++++++++++++-
 1 file changed, 32 insertions(+), 1 deletion(-)

diff --git a/catchtest/test_imap.cpp b/catchtest/test_imap.cpp
index 4749d1f2..71ae6c5a 100644
--- a/catchtest/test_imap.cpp
+++ b/catchtest/test_imap.cpp
@@ -33,7 +33,7 @@ namespace {
 }
 
 TEST_CASE("imap: works with lambda, callable, and function", "[imap]") {
-    std::vector<int> ns = {10, 20, 30};
+    Vec ns = {10, 20, 30};
     SECTION("with lambda") {
         auto im = imap([](int i) { return i + 1; }, ns);
         Vec v(std::begin(im), std::end(im));
@@ -83,3 +83,34 @@ TEST_CASE("imap: terminates on shortest squence", "[imap]") {
         REQUIRE( v == vc );
     }
 }
+
+TEST_CASE("imap: binds to lvalues, moves rvalues", "[imap]") {
+    itertest::BasicIterable<int> bi{1, 2};
+    SECTION("binds to lvalues") {
+        imap(plusone, bi);
+        REQUIRE_FALSE(bi.was_moved_from());
+    }
+
+    SECTION("moves rvalues") {
+        imap(plusone, std::move(bi));
+        REQUIRE(bi.was_moved_from());
+    }
+}
+
+TEST_CASE("imap: doesn't move or copy elements of iterable", "[imap]") {
+    constexpr itertest::SolidInt arr[] = {{1}, {0}, {2}};
+    for (auto&& i : imap([](const itertest::SolidInt& si){return si.getint();},
+                arr)) {
+        (void)i;
+    }
+}
+
+TEST_CASE("imap: postfix ++", "[imap]") {
+    Vec ns = {10, 20};
+    auto im = imap(plusone, ns);
+    auto it = std::begin(im);
+    it++;
+    REQUIRE( (*it) == 21 );
+    it++;
+    REQUIRE( it == std::end(im) );
+}

From 86c833b9a8db2685a421b07abbda0a840727ee6e Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 8 Jan 2015 20:16:04 -0500
Subject: [PATCH 0725/1866] adds imap iter == and postfix ++

---
 imap.hpp | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/imap.hpp b/imap.hpp
index 0f9bc485..ef0727fd 100644
--- a/imap.hpp
+++ b/imap.hpp
@@ -116,10 +116,20 @@ namespace iter {
                         ++this->zipiter;
                         return *this;
                     }
+ 
+                    Iterator operator++(int) {
+                        auto ret = *this;
+                        ++*this;
+                        return ret;
+                    }
 
                     bool operator!=(const Iterator& other) const {
                         return this->zipiter != other.zipiter;
                     }
+
+                    bool operator==(const Iterator& other) const {
+                        return !(*this != other);
+                    }
             };
 
             Iterator begin() {

From 5ab451d2f63d18620f10e46d8853b23c54ca8d0c Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 8 Jan 2015 20:18:45 -0500
Subject: [PATCH 0726/1866] tests imap with empty sequence

---
 catchtest/test_imap.cpp | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/catchtest/test_imap.cpp b/catchtest/test_imap.cpp
index 71ae6c5a..ba9ae171 100644
--- a/catchtest/test_imap.cpp
+++ b/catchtest/test_imap.cpp
@@ -84,6 +84,12 @@ TEST_CASE("imap: terminates on shortest squence", "[imap]") {
     }
 }
 
+TEST_CASE("imap: empty sequence gives nothing", "[imap]") {
+    Vec v{};
+    auto im = imap(plusone, v);
+    REQUIRE( std::begin(im) == std::end(im) );
+}
+
 TEST_CASE("imap: binds to lvalues, moves rvalues", "[imap]") {
     itertest::BasicIterable<int> bi{1, 2};
     SECTION("binds to lvalues") {
@@ -114,3 +120,4 @@ TEST_CASE("imap: postfix ++", "[imap]") {
     it++;
     REQUIRE( it == std::end(im) );
 }
+

From 72b735c626703c4de6c89b0c4e3708501a7b3540 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 8 Jan 2015 20:21:22 -0500
Subject: [PATCH 0727/1866] fixes typo

---
 repeat.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/repeat.hpp b/repeat.hpp
index 29991c9c..9753675d 100644
--- a/repeat.hpp
+++ b/repeat.hpp
@@ -6,7 +6,7 @@
 
 namespace iter {
 
-    // must me negative
+    // must be negative
     constexpr int INFINITE_REPEAT = -1;
 
     template <typename T>

From 3daeff55e67e8404deccb028f25467c41a1b8884 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 8 Jan 2015 20:42:30 -0500
Subject: [PATCH 0728/1866] permutations iter inherits from std iterator

---
 permutations.hpp | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/permutations.hpp b/permutations.hpp
index 08b24ef0..9785343a 100644
--- a/permutations.hpp
+++ b/permutations.hpp
@@ -6,7 +6,7 @@
 #include <initializer_list>
 #include <vector>
 #include <utility>
-
+#include <iterator>
 
 namespace iter {
 
@@ -15,15 +15,18 @@ namespace iter {
         private:
             Container container;
 
+            using Permutable =
+                std::vector<collection_item_type<Container>>;
+
         public:
             Permuter(Container in_container)
                 : container(in_container)
             { }
 
-            class Iterator {
+            class Iterator 
+                : public std::iterator<std::input_iterator_tag, Permutable>
+            {
                 private:
-                    using Permutable =
-                        std::vector<collection_item_type<Container>>;
                     Permutable working_set;
                     bool is_not_last = true;
 

From aefdddaa480e13171d4d3ff40e4859ce4ebea7f9 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 8 Jan 2015 20:42:47 -0500
Subject: [PATCH 0729/1866] tests permutations basic functionality

---
 catchtest/test_permutations.cpp | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 catchtest/test_permutations.cpp

diff --git a/catchtest/test_permutations.cpp b/catchtest/test_permutations.cpp
new file mode 100644
index 00000000..35c5f9d8
--- /dev/null
+++ b/catchtest/test_permutations.cpp
@@ -0,0 +1,26 @@
+#include <permutations.hpp>
+
+#include "helpers.hpp"
+
+#include <vector>
+#include <string>
+#include <iterator>
+
+#include "catch.hpp"
+
+using iter::permutations;
+using IntPermSet = std::multiset<std::vector<int>>;
+
+TEST_CASE("permutations: basic test, 3 element sequence", "[permutations]") {
+    const std::vector<int> ns = {1, 7, 9};
+    auto p = permutations(ns);
+
+    IntPermSet v;
+    for (auto&& st : p) {
+        v.emplace(std::begin(st), std::end(st));
+    }
+
+    const IntPermSet vc =
+        {{1, 7, 9}, {1, 9, 7}, {7, 1, 9}, {7, 9, 1}, {9, 1, 7}, {9, 7, 1}};
+    REQUIRE( v == vc );
+}

From eb74d12e6192ea27c236b551a8717570f52195db Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 8 Jan 2015 20:43:19 -0500
Subject: [PATCH 0730/1866] builds permutations test

---
 catchtest/SConstruct | 1 +
 1 file changed, 1 insertion(+)

diff --git a/catchtest/SConstruct b/catchtest/SConstruct
index 8e4b799b..daae60a4 100644
--- a/catchtest/SConstruct
+++ b/catchtest/SConstruct
@@ -30,6 +30,7 @@ progs = Split(
     filterfalse
     groupby
     imap
+    permutations
     '''
 )
 

From 080e9da5e1a061e95d431839613b4d60af0d989a Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 8 Jan 2015 20:50:35 -0500
Subject: [PATCH 0731/1866] tests permutations with empy sequence

---
 catchtest/test_permutations.cpp | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/catchtest/test_permutations.cpp b/catchtest/test_permutations.cpp
index 35c5f9d8..8a55df64 100644
--- a/catchtest/test_permutations.cpp
+++ b/catchtest/test_permutations.cpp
@@ -24,3 +24,13 @@ TEST_CASE("permutations: basic test, 3 element sequence", "[permutations]") {
         {{1, 7, 9}, {1, 9, 7}, {7, 1, 9}, {7, 9, 1}, {9, 1, 7}, {9, 7, 1}};
     REQUIRE( v == vc );
 }
+
+TEST_CASE("permutations: empty sequence has one empy permutation",
+        "[permutations]") {
+    const std::vector<int> ns{};
+    auto p = permutations(ns);
+    auto it = std::begin(p);
+    REQUIRE( (*it).empty() );
+    it++;
+    REQUIRE( it == std::end(p) );
+}

From 9465324b65ae0f16d06e9f04a1d5d641047ae3b8 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 8 Jan 2015 21:10:57 -0500
Subject: [PATCH 0732/1866] adds == and postfix ++ to permutations iter

---
 permutations.hpp | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/permutations.hpp b/permutations.hpp
index 9785343a..d39b1433 100644
--- a/permutations.hpp
+++ b/permutations.hpp
@@ -54,9 +54,19 @@ namespace iter {
                         return *this;
                     }
 
+                    Iterator operator++(int) {
+                        auto ret = *this;
+                        ++*this;
+                        return ret;
+                    }
+
                     bool operator!=(const Iterator&) const {
                         return is_not_last;
                     }
+
+                    bool operator==(const Iterator& other) const {
+                        return !(*this != other);
+                    }
             };
 
             Iterator begin() {

From 420f670e03835573d7fe206036243f0a6eea3d38 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 8 Jan 2015 21:29:21 -0500
Subject: [PATCH 0733/1866] adds missing forward() in permutations ctor

---
 permutations.hpp | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/permutations.hpp b/permutations.hpp
index d39b1433..bb383ac7 100644
--- a/permutations.hpp
+++ b/permutations.hpp
@@ -20,7 +20,7 @@ namespace iter {
 
         public:
             Permuter(Container in_container)
-                : container(in_container)
+                : container(std::forward<Container>(in_container))
             { }
 
             class Iterator 
@@ -93,5 +93,4 @@ namespace iter {
 
 }
 
-#endif // ITER_PERMUTATIONS_HPP_
-
+#endif

From ffd66f2e2ab14d2a00681698c8f9e83f25770e5d Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 8 Jan 2015 21:29:45 -0500
Subject: [PATCH 0734/1866] tests that permutations binds and moves correctly

---
 catchtest/test_permutations.cpp | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/catchtest/test_permutations.cpp b/catchtest/test_permutations.cpp
index 8a55df64..0c2cac0b 100644
--- a/catchtest/test_permutations.cpp
+++ b/catchtest/test_permutations.cpp
@@ -34,3 +34,16 @@ TEST_CASE("permutations: empty sequence has one empy permutation",
     it++;
     REQUIRE( it == std::end(p) );
 }
+
+TEST_CASE("permutations: binds to lvalues, moves rvalues", "[permutations]") {
+    itertest::BasicIterable<int> bi{1, 2};
+    SECTION("binds to lvalues") {
+        permutations(bi);
+        REQUIRE_FALSE(bi.was_moved_from());
+    }
+
+    SECTION("moves rvalues") {
+        permutations(std::move(bi));
+        REQUIRE(bi.was_moved_from());
+    }
+}

From dc4a0a10a66d542b032653aa28e5b5182ab391c5 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 8 Jan 2015 22:07:31 -0500
Subject: [PATCH 0735/1866] tests that permutations doesn't copy/move elems

which is worth paying attention to since it has to make
referenc_wrappers
---
 catchtest/test_permutations.cpp | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/catchtest/test_permutations.cpp b/catchtest/test_permutations.cpp
index 0c2cac0b..d6af74fb 100644
--- a/catchtest/test_permutations.cpp
+++ b/catchtest/test_permutations.cpp
@@ -47,3 +47,17 @@ TEST_CASE("permutations: binds to lvalues, moves rvalues", "[permutations]") {
         REQUIRE(bi.was_moved_from());
     }
 }
+
+namespace itertest {
+    bool operator<(const SolidInt& lhs, const SolidInt& rhs) {
+        return lhs.getint() < rhs.getint();
+    }
+}
+
+TEST_CASE("permutations doesn't move or copy elements of iterable",
+        "[permutations]") {
+    constexpr itertest::SolidInt arr[] = {{1}, {0}, {2}};
+    for (auto&& st : permutations(arr)) {
+        (void)st;
+    }
+}

From fac55bf7f5fa6e6a759670b816993d9d98db6523 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 8 Jan 2015 22:46:24 -0500
Subject: [PATCH 0736/1866] powerset iter inherits from std iterator

---
 powerset.hpp | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/powerset.hpp b/powerset.hpp
index be8e60a8..b8f7bbae 100644
--- a/powerset.hpp
+++ b/powerset.hpp
@@ -34,7 +34,10 @@ namespace iter {
                 }
             }
 
-            class Iterator {
+            class Iterator 
+                : public std::iterator<
+                      std::input_iterator_tag, iterator_deref<CombinatorType>>
+            {
                 private:
                     std::size_t container_size;
                     std::size_t list_size = 0;
@@ -64,7 +67,7 @@ namespace iter {
                         return *this;
                     }
 
-                    auto operator*() -> decltype(*inner_iters[0]) {
+                    iterator_deref<CombinatorType> operator*() {
                         return *(inner_iters[list_size]);
                     }
 

From 42ed54e3c6b7339b77960f46a31d62a126696647 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 8 Jan 2015 22:46:47 -0500
Subject: [PATCH 0737/1866] powerset test with small test case

---
 catchtest/test_powerset.cpp | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 catchtest/test_powerset.cpp

diff --git a/catchtest/test_powerset.cpp b/catchtest/test_powerset.cpp
new file mode 100644
index 00000000..18408ba6
--- /dev/null
+++ b/catchtest/test_powerset.cpp
@@ -0,0 +1,23 @@
+#include <powerset.hpp>
+
+#include "helpers.hpp"
+
+#include <vector>
+#include <string>
+#include <iterator>
+
+#include "catch.hpp"
+
+using iter::powerset;
+using IntPermSet = std::multiset<std::multiset<int>>;
+
+TEST_CASE("powerset: basic test, [1, 2, 3]", "[powerset]") {
+    const std::vector<int> ns = {1, 2, 3};
+    IntPermSet v;
+    for (auto&& st : powerset(ns)) {
+        v.emplace(std::begin(st), std::end(st));
+    }
+
+    const IntPermSet vc = { {}, {1}, {2}, {3,}, {1,2}, {1,3}, {2,3}, {1,2,3} };
+    REQUIRE( v == vc );
+}

From 4dc1948342861cab0ab38380df6de9fd09ea1221 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 8 Jan 2015 22:47:12 -0500
Subject: [PATCH 0738/1866] builds powerset test

---
 catchtest/SConstruct | 1 +
 1 file changed, 1 insertion(+)

diff --git a/catchtest/SConstruct b/catchtest/SConstruct
index daae60a4..3ce37300 100644
--- a/catchtest/SConstruct
+++ b/catchtest/SConstruct
@@ -31,6 +31,7 @@ progs = Split(
     groupby
     imap
     permutations
+    powerset
     '''
 )
 

From f572c761e5b843d347c82e84d56c0f8634aae7eb Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 8 Jan 2015 22:47:45 -0500
Subject: [PATCH 0739/1866] adds powerset postfix ++

---
 powerset.hpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/powerset.hpp b/powerset.hpp
index b8f7bbae..c6658526 100644
--- a/powerset.hpp
+++ b/powerset.hpp
@@ -67,6 +67,12 @@ namespace iter {
                         return *this;
                     }
 
+                    Iterator operator++(int) {
+                        auto ret = *this;
+                        ++*this;
+                        return ret;
+                    }
+
                     iterator_deref<CombinatorType> operator*() {
                         return *(inner_iters[list_size]);
                     }

From aea4229d723e3a419265a296dc34e73b4d4e8847 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 8 Jan 2015 22:47:59 -0500
Subject: [PATCH 0740/1866] adds powerset iter ==

---
 powerset.hpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/powerset.hpp b/powerset.hpp
index c6658526..49ab9d3d 100644
--- a/powerset.hpp
+++ b/powerset.hpp
@@ -80,6 +80,10 @@ namespace iter {
                     bool operator != (const Iterator&) {
                         return not_done;
                     }
+
+                    bool operator==(const Iterator& other) const {
+                        return !(*this != other);
+                    }
             }; 
 
             Iterator begin() {

From e03bddcd7c2817cd32910a9ed3dea9ffa7a51c04 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 8 Jan 2015 22:49:28 -0500
Subject: [PATCH 0741/1866] moves CombinatorType into PowerSetter as typealias

---
 powerset.hpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/powerset.hpp b/powerset.hpp
index 49ab9d3d..8a39cbfa 100644
--- a/powerset.hpp
+++ b/powerset.hpp
@@ -12,12 +12,12 @@
 #include <iterator>
 
 namespace iter {
-    template <typename Container,
-              typename CombinatorType=
-                  decltype(combinations(std::declval<Container&>(), 0))>
+    template <typename Container>
     class Powersetter {
         private:
             Container container;
+            using CombinatorType =
+                decltype(combinations(std::declval<Container&>(), 0));
 
             std::vector<CombinatorType> combinators;
         public:

From e489e350e5fb0ec95b2ee1ffe86559a68190034f Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 10 Jan 2015 17:01:26 -0500
Subject: [PATCH 0742/1866] marks powerset iter != as const

---
 powerset.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/powerset.hpp b/powerset.hpp
index 8a39cbfa..5ad8afc2 100644
--- a/powerset.hpp
+++ b/powerset.hpp
@@ -77,7 +77,7 @@ namespace iter {
                         return *(inner_iters[list_size]);
                     }
 
-                    bool operator != (const Iterator&) {
+                    bool operator != (const Iterator&) const {
                         return not_done;
                     }
 

From 78f61e5859380d5d2fa8d23232d19794977eed27 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 10 Jan 2015 17:10:20 -0500
Subject: [PATCH 0743/1866] adds missing return *this to BasicIterable's ++

---
 catchtest/helpers.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/catchtest/helpers.hpp b/catchtest/helpers.hpp
index bb034e16..d3dacfa6 100644
--- a/catchtest/helpers.hpp
+++ b/catchtest/helpers.hpp
@@ -100,6 +100,7 @@ class BasicIterable {
 
                 Iterator& operator++() {
                     ++this->p;
+                    return *this;
                 }
 
                 T& operator*() {

From aa5a5c478f7b7b5f767e6008189d52ab52f26d09 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 10 Jan 2015 17:14:24 -0500
Subject: [PATCH 0744/1866] tests powerset with empy iterable

---
 catchtest/test_powerset.cpp | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/catchtest/test_powerset.cpp b/catchtest/test_powerset.cpp
index 18408ba6..99eeea06 100644
--- a/catchtest/test_powerset.cpp
+++ b/catchtest/test_powerset.cpp
@@ -21,3 +21,12 @@ TEST_CASE("powerset: basic test, [1, 2, 3]", "[powerset]") {
     const IntPermSet vc = { {}, {1}, {2}, {3,}, {1,2}, {1,3}, {2,3}, {1,2,3} };
     REQUIRE( v == vc );
 }
+
+TEST_CASE("powerset: empty sequence gives only empty set", "[powerset]") {
+    const std::vector<int> ns = {};
+    auto ps = powerset(ns);
+    auto it = std::begin(ps);
+    REQUIRE( std::begin(*it) == std::end(*it) ); // it's empty
+    ++it;
+    REQUIRE( it == std::end(ps) );
+}

From dc58fce738833a6e70e5c2d5c3b819897a60b555 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 10 Jan 2015 17:14:43 -0500
Subject: [PATCH 0745/1866] tests powerset for move/bind correctness

---
 catchtest/test_powerset.cpp | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/catchtest/test_powerset.cpp b/catchtest/test_powerset.cpp
index 99eeea06..7c22d558 100644
--- a/catchtest/test_powerset.cpp
+++ b/catchtest/test_powerset.cpp
@@ -30,3 +30,24 @@ TEST_CASE("powerset: empty sequence gives only empty set", "[powerset]") {
     ++it;
     REQUIRE( it == std::end(ps) );
 }
+
+TEST_CASE("powerset: binds to lvalues, moves rvalues", "[powerset]") {
+    itertest::BasicIterable<int> bi{1, 2};
+    SECTION("binds to lvalues") {
+        powerset(bi);
+        REQUIRE_FALSE(bi.was_moved_from());
+    }
+    SECTION("moves rvalues") {
+        powerset(std::move(bi));
+        REQUIRE(bi.was_moved_from());
+    }
+}
+
+TEST_CASE("powerset: doesn't move or copy elements of iterable", "[powerset]"){
+    constexpr itertest::SolidInt arr[] = {{1}, {0}, {2}};
+    for (auto&& st : powerset(arr)) {
+        for (auto&& i : st) {
+            (void)i;
+        }
+    }
+}

From 401d9a03edf0ff394e073707ca0780d373943d9f Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 10 Jan 2015 21:59:12 -0500
Subject: [PATCH 0746/1866] make combinations iterators assignable

uses pointers instead of references
---
 combinations.hpp | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/combinations.hpp b/combinations.hpp
index e05fb957..089d0abc 100644
--- a/combinations.hpp
+++ b/combinations.hpp
@@ -43,14 +43,14 @@ namespace iter {
             public std::iterator<std::input_iterator_tag, CombIteratorDeref>
         {
             private:
-                Container& items;
+                typename std::remove_reference<Container>::type *container_p;
                 std::vector<iterator_type<Container>> indicies;
                 bool not_done = true;
 
             public:
-                Iterator(Container& i, std::size_t n)
-                    : items(i),
-                    indicies(n)
+                Iterator(Container& in_container, std::size_t n)
+                    : container_p{&in_container},
+                    indicies{n}
                 {
                     if (n == 0) {
                         not_done = false;
@@ -58,9 +58,9 @@ namespace iter {
                     }
                     size_t inc = 0;
                     for (auto& iter : this->indicies) {
-                        auto it = std::begin(this->items);
-                        dumb_advance(it, std::end(this->items), inc);
-                        if (it != std::end(this->items)) {
+                        auto it = std::begin(*this->container_p);
+                        dumb_advance(it, std::end(*this->container_p), inc);
+                        if (it != std::end(*this->container_p)) {
                             iter = it;
                             ++inc;
                         } else {
@@ -92,7 +92,7 @@ namespace iter {
                                 this->indicies.rbegin(),iter);
 
                         if (!(dumb_next(*iter, dist) !=
-                                std::end(this->items))) {
+                                std::end(*this->container_p))) {
                             if ( (iter + 1) != indicies.rend()) {
                                 size_t inc = 1;
                                 for (auto down = iter;

From 0e335cfb07a4fc3cec160b98aa854e5a5aab8a82 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 10 Jan 2015 22:09:54 -0500
Subject: [PATCH 0747/1866] make comb_w_repl iterators assignable

same as combinations(), uses a pointer to the container instead of
binding a reference to it.
---
 combinations_with_replacement.hpp | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/combinations_with_replacement.hpp b/combinations_with_replacement.hpp
index 615da8b8..4b521e76 100644
--- a/combinations_with_replacement.hpp
+++ b/combinations_with_replacement.hpp
@@ -50,15 +50,14 @@ namespace iter {
                     CombIteratorDeref>
             {
                private:
-                   Container& items;
+                   typename std::remove_reference<Container>::type *container_p;
                    std::vector<iterator_type<Container>> indicies;
                    bool not_done;
 
                public:
-                   Iterator(
-                           Container& container, std::size_t n)
-                       : items(container),
-                       indicies(n, std::begin(items)),
+                   Iterator(Container& in_container, std::size_t n)
+                       : container_p{&in_container},
+                       indicies(n, std::begin(in_container)),
                        not_done{n != 0}
                    { }
 
@@ -76,7 +75,7 @@ namespace iter {
                                iter != indicies.rend();
                                ++iter) {
                            ++(*iter);
-                           if (!(*iter != std::end(items))) {
+                           if (!(*iter != std::end(*this->container_p))) {
                                if ( (iter + 1) != indicies.rend()) {
                                    for (auto down = iter;
                                            down != indicies.rbegin()-1;

From bfdef91d40bf69737bb48e9a6046338245d48d94 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 10 Jan 2015 22:11:40 -0500
Subject: [PATCH 0748/1866] powerset lazily make combinators

the previous implementation created a vector of combinators up front.
This approach isn't terrible, but this version has less code and only
allocates one Combinator at a time.
---
 iterbase.hpp | 11 ++++++++
 powerset.hpp | 78 ++++++++++++++++++++++------------------------------
 2 files changed, 44 insertions(+), 45 deletions(-)

diff --git a/iterbase.hpp b/iterbase.hpp
index 0ce5d441..d426af91 100644
--- a/iterbase.hpp
+++ b/iterbase.hpp
@@ -45,6 +45,17 @@ namespace iter {
         return it;
     }
 
+    template <typename Container, typename Distance =std::size_t>
+    Distance dumb_size(Container&& container) {
+        Distance d{0};
+        for (auto it = std::begin(container), end = std::end(container);
+                it != end;
+                ++it) {
+            ++d;
+        }
+        return d;
+    }
+
     // iterator_type<C> is the type of C's iterator
     template <typename Container>
     using iterator_type =
diff --git a/powerset.hpp b/powerset.hpp
index 5ad8afc2..8e3b310c 100644
--- a/powerset.hpp
+++ b/powerset.hpp
@@ -1,12 +1,11 @@
-#ifndef POWERSET_HPP_
-#define POWERSET_HPP_
+#ifndef ITER_POWERSET_HPP_
+#define ITER_POWERSET_HPP_
 
 #include "iterbase.hpp"
 #include "combinations.hpp"
-#include "enumerate.hpp"
 
 #include <cassert>
-#include <vector>
+#include <memory>
 #include <initializer_list>
 #include <utility>
 #include <iterator>
@@ -19,51 +18,40 @@ namespace iter {
             using CombinatorType =
                 decltype(combinations(std::declval<Container&>(), 0));
 
-            std::vector<CombinatorType> combinators;
         public:
             Powersetter(Container in_container)
                 : container(std::forward<Container>(in_container))
-            {
-                combinators.push_back(combinations(this->container, 0));
-                std::size_t i = 1;
-                for (auto iter = std::begin(this->container),
-                            end = std::end(this->container);
-                        iter != end;
-                        ++iter, ++i) {
-                    combinators.push_back(combinations(this->container, i));
-                }
-            }
+            { }
 
-            class Iterator 
+            class Iterator
                 : public std::iterator<
-                      std::input_iterator_tag, iterator_deref<CombinatorType>>
+                      std::input_iterator_tag, CombinatorType>
             {
                 private:
-                    std::size_t container_size;
-                    std::size_t list_size = 0;
-                    bool not_done = true;
+                    Container& container;
+                    std::size_t set_size;
+                    std::unique_ptr<CombinatorType> comb;
+                    iterator_type<CombinatorType> comb_iter;
+                    iterator_type<CombinatorType> comb_end;
 
-                    std::vector<CombinatorType>& combinators;
-                    std::vector<iterator_type<CombinatorType>> inner_iters;
                 public:
-                    Iterator(std::vector<CombinatorType>& combs)
-                        : container_size{combs.size() - 1},
-                        combinators(combs)
-                    {
-                        for (auto& comb : combinators) {
-                            inner_iters.push_back(std::begin(comb));
-                        }
-                    }
+                    Iterator(Container& in_container, std::size_t sz)
+                        : container{in_container},
+                        set_size{sz},
+                        comb{new CombinatorType(combinations(in_container, sz))},
+                        comb_iter{std::begin(*comb)},
+                        comb_end{std::end(*comb)}
+                    { }
 
                     Iterator& operator++() {
-                        ++inner_iters[list_size];
-                        if (!(inner_iters[list_size] != inner_iters[list_size])) {
-                            ++list_size;
-                        }
-                        if (container_size < list_size) {
-                            not_done = false;
+                        ++this->comb_iter;
+                        if (this->comb_iter == this->comb_end) {
+                            ++this->set_size;
+                            this->comb.reset(new CombinatorType(combinations(
+                                            this->container, this->set_size)));
+                            this->comb_iter = std::begin(*this->comb);
+                            this->comb_end = std::end(*this->comb);
                         }
-
                         return *this;
                     }
 
@@ -74,24 +62,24 @@ namespace iter {
                     }
 
                     iterator_deref<CombinatorType> operator*() {
-                        return *(inner_iters[list_size]);
+                        return *this->comb_iter;
                     }
 
-                    bool operator != (const Iterator&) const {
-                        return not_done;
+                    bool operator != (const Iterator& other) const {
+                        return !(*this == other);
                     }
 
                     bool operator==(const Iterator& other) const {
-                        return !(*this != other);
+                        return this->set_size == other.set_size;
                     }
-            }; 
+            };
 
             Iterator begin() {
-                return {this->combinators};
+                return {this->container, 0};
             }
 
             Iterator end() {
-                return {this->combinators};
+                return {this->container, dumb_size(this->container) + 1};
             }
     };
 
@@ -106,4 +94,4 @@ namespace iter {
         return {il};
     }
 }
-#endif // #ifndef POWERSET_HPP_
+#endif

From cd447fe6ad38a27ef00924aa7931f55131531392 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 10 Jan 2015 22:26:24 -0500
Subject: [PATCH 0749/1866] make powerset iterators assignable

pointer to container instead of reference
---
 powerset.hpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/powerset.hpp b/powerset.hpp
index 8e3b310c..69abf4fa 100644
--- a/powerset.hpp
+++ b/powerset.hpp
@@ -9,6 +9,7 @@
 #include <initializer_list>
 #include <utility>
 #include <iterator>
+#include <type_traits>
 
 namespace iter {
     template <typename Container>
@@ -28,7 +29,7 @@ namespace iter {
                       std::input_iterator_tag, CombinatorType>
             {
                 private:
-                    Container& container;
+                    typename std::remove_reference<Container>::type *container_p;
                     std::size_t set_size;
                     std::unique_ptr<CombinatorType> comb;
                     iterator_type<CombinatorType> comb_iter;
@@ -36,7 +37,7 @@ namespace iter {
 
                 public:
                     Iterator(Container& in_container, std::size_t sz)
-                        : container{in_container},
+                        : container_p{&in_container},
                         set_size{sz},
                         comb{new CombinatorType(combinations(in_container, sz))},
                         comb_iter{std::begin(*comb)},
@@ -48,7 +49,7 @@ namespace iter {
                         if (this->comb_iter == this->comb_end) {
                             ++this->set_size;
                             this->comb.reset(new CombinatorType(combinations(
-                                            this->container, this->set_size)));
+                                            *this->container_p, this->set_size)));
                             this->comb_iter = std::begin(*this->comb);
                             this->comb_end = std::end(*this->comb);
                         }

From dcfe1ea141c95c425f4d4875a73d3ddef411d4e4 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 19 Jan 2015 14:17:49 -0500
Subject: [PATCH 0750/1866] product iterator inherits from std::iterator

---
 product.hpp | 19 ++++++++++---------
 1 file changed, 10 insertions(+), 9 deletions(-)

diff --git a/product.hpp b/product.hpp
index 4b14353d..2aceda83 100644
--- a/product.hpp
+++ b/product.hpp
@@ -7,7 +7,6 @@
 #include <tuple>
 #include <utility>
 
-
 namespace iter {
     template <typename... RestContainers>
     class Productor;
@@ -27,6 +26,9 @@ namespace iter {
         template <typename... RC>
         friend class Productor;
 
+        using ProdIterDeref = std::tuple<
+            iterator_deref<Container>, iterator_deref<RestContainers>...>;
+
         private:
             Container container;
             Productor<RestContainers...> rest_products;
@@ -36,7 +38,9 @@ namespace iter {
             { }
 
         public:
-            class Iterator {
+            class Iterator
+                : public std::iterator<std::input_iterator_tag, ProdIterDeref>
+            {
                 private:
                     using RestIter =
                         typename Productor<RestContainers...>::Iterator;
@@ -76,12 +80,7 @@ namespace iter {
                                 this->rest_iter != other.rest_iter);
                     }
 
-                    auto operator*() ->
-                        decltype(std::tuple_cat(
-                                    std::tuple<iterator_deref<Container>>{
-                                        *this->iter},
-                                    *this->rest_iter))
-                    {
+                    ProdIterDeref operator*() {
                         return std::tuple_cat(
                                 std::tuple<iterator_deref<Container>>{
                                     *this->iter},
@@ -106,7 +105,9 @@ namespace iter {
     template <>
     class Productor<> {
         public:
-            class Iterator {
+            class Iterator
+                : public std::iterator<std::input_iterator_tag, std::tuple<>>
+            {
                 public:
                     constexpr static const bool is_base_iter = true;
 

From bec181eae5347a623ed5fce909a1a800a2f74706 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 19 Jan 2015 14:18:08 -0500
Subject: [PATCH 0751/1866] adds basic product test

---
 catchtest/test_product.cpp | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 catchtest/test_product.cpp

diff --git a/catchtest/test_product.cpp b/catchtest/test_product.cpp
new file mode 100644
index 00000000..91e57c63
--- /dev/null
+++ b/catchtest/test_product.cpp
@@ -0,0 +1,27 @@
+#include <product.hpp>
+
+#include "helpers.hpp"
+
+#include <vector>
+#include <string>
+#include <iterator>
+
+#include "catch.hpp"
+
+using iter::product;
+using Vec = const std::vector<int>;
+
+TEST_CASE("product: basic test, two vectors", "[product]") {
+    using ResType = std::vector<std::tuple<int, int>>;
+    using TP = std::tuple<int, int>;
+
+    Vec n1 = {0, 1};
+    Vec n2 = {0, 1, 2};
+
+    auto p = product(n1, n2);
+    ResType v(std::begin(p), std::end(p));
+    ResType vc = {TP{0,0}, TP{0,1}, TP{0,2}, TP{1,0}, TP{1,1}, TP{1,2}};
+
+    REQUIRE( v == vc );
+}
+

From 8114a5a518dc2586f42e2a15f81803c24b7c0955 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 19 Jan 2015 14:25:30 -0500
Subject: [PATCH 0752/1866] adds == and postfix ++ to product iter

---
 product.hpp | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/product.hpp b/product.hpp
index 2aceda83..b966d581 100644
--- a/product.hpp
+++ b/product.hpp
@@ -74,12 +74,23 @@ namespace iter {
                         return *this;
                     }
 
+                    Iterator operator++(int) {
+                        auto ret = *this;
+                        ++*this;
+                        return ret;
+                    }
+
                     bool operator!=(const Iterator& other) const {
                         return this->iter != other.iter &&
                             (RestIter::is_base_iter ||
                                 this->rest_iter != other.rest_iter);
                     }
 
+                    bool operator==(const Iterator& other) const {
+                        return !(*this != other);
+                    }
+
+
                     ProdIterDeref operator*() {
                         return std::tuple_cat(
                                 std::tuple<iterator_deref<Container>>{
@@ -121,11 +132,21 @@ namespace iter {
                         return *this;
                     }
 
+                    Iterator operator++(int) {
+                        auto ret = *this;
+                        ++*this;
+                        return ret;
+                    }
+
                     // see note in zip about base case operator!=
                     bool operator!=(const Iterator&) const {
                         return false;
                     }
 
+                    bool operator==(const Iterator& other) const {
+                        return !(*this != other);
+                    }
+
                     std::tuple<> operator*() const {
                         return std::tuple<>{};
                     }

From 21461ad662b887d45ccbc799e8cfe1526de1c63f Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 19 Jan 2015 14:26:44 -0500
Subject: [PATCH 0753/1866] tests product with empty sequences

---
 catchtest/test_product.cpp | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/catchtest/test_product.cpp b/catchtest/test_product.cpp
index 91e57c63..074b1d85 100644
--- a/catchtest/test_product.cpp
+++ b/catchtest/test_product.cpp
@@ -25,3 +25,23 @@ TEST_CASE("product: basic test, two vectors", "[product]") {
     REQUIRE( v == vc );
 }
 
+TEST_CASE("product: empty when any iterable is empty", "[product]") {
+    Vec n1 = {0, 1};
+    Vec n2 = {0, 1, 2};
+    Vec emp = {};
+
+    SECTION("first iterable is empty") {
+        auto p = product(emp, n1, n2);
+        REQUIRE( std::begin(p) == std::end(p) );
+    }
+
+    SECTION("middle iterable is empty") {
+        auto p = product(n1, emp, n2);
+        REQUIRE( std::begin(p) == std::end(p) );
+    }
+
+    SECTION("last iterable is empty") {
+        auto p = product(n1, n2, emp);
+        REQUIRE( std::begin(p) == std::end(p) );
+    }
+}

From e9832207c5def75942adc59f82f1fa2f76508d50 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 19 Jan 2015 14:27:14 -0500
Subject: [PATCH 0754/1866] builds product catch test

---
 catchtest/SConstruct | 1 +
 1 file changed, 1 insertion(+)

diff --git a/catchtest/SConstruct b/catchtest/SConstruct
index 3ce37300..ce88d2a3 100644
--- a/catchtest/SConstruct
+++ b/catchtest/SConstruct
@@ -32,6 +32,7 @@ progs = Split(
     imap
     permutations
     powerset
+    product
     '''
 )
 

From 2d8416ede6762dd51a645ee7290fe8a02346e560 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 19 Jan 2015 18:05:34 -0500
Subject: [PATCH 0755/1866] Adds test with a single iterable

---
 catchtest/test_product.cpp | 25 +++++++++++++++++++------
 1 file changed, 19 insertions(+), 6 deletions(-)

diff --git a/catchtest/test_product.cpp b/catchtest/test_product.cpp
index 074b1d85..e968369d 100644
--- a/catchtest/test_product.cpp
+++ b/catchtest/test_product.cpp
@@ -11,16 +11,17 @@
 using iter::product;
 using Vec = const std::vector<int>;
 
-TEST_CASE("product: basic test, two vectors", "[product]") {
-    using ResType = std::vector<std::tuple<int, int>>;
-    using TP = std::tuple<int, int>;
+TEST_CASE("product: basic test, two sequences", "[product]") {
+    using TP = std::tuple<int, char>;
+    using ResType = std::vector<TP>;
 
     Vec n1 = {0, 1};
-    Vec n2 = {0, 1, 2};
+    const std::string s{"abc"};
 
-    auto p = product(n1, n2);
+    auto p = product(n1, s);
     ResType v(std::begin(p), std::end(p));
-    ResType vc = {TP{0,0}, TP{0,1}, TP{0,2}, TP{1,0}, TP{1,1}, TP{1,2}};
+    ResType vc = {TP{0,'a'}, TP{0,'b'}, TP{0,'c'},
+                  TP{1,'a'}, TP{1,'b'}, TP{1,'c'}};
 
     REQUIRE( v == vc );
 }
@@ -45,3 +46,15 @@ TEST_CASE("product: empty when any iterable is empty", "[product]") {
         REQUIRE( std::begin(p) == std::end(p) );
     }
 }
+
+TEST_CASE("product: single iterable", "[product]") {
+    const std::string s{"ab"};
+    using TP = std::tuple<char>;
+    using ResType = const std::vector<TP>;
+
+    auto p = product(s);
+    ResType v(std::begin(p), std::end(p));
+    ResType vc = {TP{'a'}, TP{'b'}};
+
+    REQUIRE( v == vc );
+}

From a3ebb61327e0f283fb20527ff2be261c1fa6f464 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 19 Jan 2015 18:10:04 -0500
Subject: [PATCH 0756/1866] tests product with three iterables

---
 catchtest/test_product.cpp | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/catchtest/test_product.cpp b/catchtest/test_product.cpp
index e968369d..e10e4a23 100644
--- a/catchtest/test_product.cpp
+++ b/catchtest/test_product.cpp
@@ -26,6 +26,28 @@ TEST_CASE("product: basic test, two sequences", "[product]") {
     REQUIRE( v == vc );
 }
 
+TEST_CASE("product: three sequences", "[product]") {
+    using TP = std::tuple <int, char, int>;
+    using ResType = const std::vector<TP>;
+
+    Vec n1 = {0, 1};
+    const std::string s{"ab"};
+    Vec n2 = {2};
+
+    auto p = product(n1, s, n2);
+    ResType v(std::begin(p), std::end(p));
+
+    ResType vc = {
+        TP{0, 'a', 2},
+        TP{0, 'b', 2},
+        TP{1, 'a', 2},
+        TP{1, 'b', 2}
+    };
+
+    REQUIRE( v == vc );
+}
+
+
 TEST_CASE("product: empty when any iterable is empty", "[product]") {
     Vec n1 = {0, 1};
     Vec n2 = {0, 1, 2};

From 0d654b3c0ecca945e6ed9f3ef62b2136dfb0060b Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 19 Jan 2015 18:14:58 -0500
Subject: [PATCH 0757/1866] tests that product doesn't move or copy elements

---
 catchtest/test_product.cpp | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/catchtest/test_product.cpp b/catchtest/test_product.cpp
index e10e4a23..94ce4906 100644
--- a/catchtest/test_product.cpp
+++ b/catchtest/test_product.cpp
@@ -80,3 +80,10 @@ TEST_CASE("product: single iterable", "[product]") {
 
     REQUIRE( v == vc );
 }
+
+TEST_CASE("product: doesn't move or copy elements of iterable", "[product]") {
+    constexpr itertest::SolidInt arr[] = {{1}, {0}, {2}};
+    for (auto&& t : product(arr)) {
+        (void)std::get<0>(t);
+    }
+}

From 1be88e0e5e9f821b443024b9763df3191e0d5e3d Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 19 Jan 2015 19:32:37 -0500
Subject: [PATCH 0758/1866] tests that product moves and binds correctly

---
 catchtest/test_product.cpp | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/catchtest/test_product.cpp b/catchtest/test_product.cpp
index 94ce4906..1b46ff3b 100644
--- a/catchtest/test_product.cpp
+++ b/catchtest/test_product.cpp
@@ -81,6 +81,23 @@ TEST_CASE("product: single iterable", "[product]") {
     REQUIRE( v == vc );
 }
 
+TEST_CASE("product: binds to lvalues and moves rvalues", "[product]") {
+    itertest::BasicIterable<char> bi{'x', 'y'};
+    itertest::BasicIterable<int> bi2{0, 1};
+    
+    SECTION("First ref'd, second moved") {
+        product(bi, std::move(bi2));
+        REQUIRE_FALSE( bi.was_moved_from() );
+        REQUIRE( bi2.was_moved_from() );
+    }
+
+    SECTION("First moved, second ref'd") {
+        product(std::move(bi), bi2);
+        REQUIRE( bi.was_moved_from() );
+        REQUIRE_FALSE( bi2.was_moved_from() );
+    }
+}
+
 TEST_CASE("product: doesn't move or copy elements of iterable", "[product]") {
     constexpr itertest::SolidInt arr[] = {{1}, {0}, {2}};
     for (auto&& t : product(arr)) {

From ff54629f5aa41e6d56b59731f120395301aa4ae4 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 19 Jan 2015 20:02:06 -0500
Subject: [PATCH 0759/1866] tests empty product()

---
 catchtest/test_product.cpp | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/catchtest/test_product.cpp b/catchtest/test_product.cpp
index 1b46ff3b..3e160d0f 100644
--- a/catchtest/test_product.cpp
+++ b/catchtest/test_product.cpp
@@ -81,6 +81,15 @@ TEST_CASE("product: single iterable", "[product]") {
     REQUIRE( v == vc );
 }
 
+TEST_CASE("product: no arguments gives one empty tuple", "[product") {
+    auto p = product();
+    auto it = std::begin(p);
+    REQUIRE( it != std::end(p) );
+    REQUIRE( *it == std::make_tuple() );
+    ++it;
+    REQUIRE( it == std::end(p) );
+}
+
 TEST_CASE("product: binds to lvalues and moves rvalues", "[product]") {
     itertest::BasicIterable<char> bi{'x', 'y'};
     itertest::BasicIterable<int> bi2{0, 1};

From 04a2da4a13ab9f28a407777fc83f8477e7ea8888 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 19 Jan 2015 20:02:19 -0500
Subject: [PATCH 0760/1866] adds special case for product() since it is weird

---
 product.hpp | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/product.hpp b/product.hpp
index b966d581..93c977f2 100644
--- a/product.hpp
+++ b/product.hpp
@@ -6,6 +6,7 @@
 #include <iterator>
 #include <tuple>
 #include <utility>
+#include <array>
 
 namespace iter {
     template <typename... RestContainers>
@@ -121,11 +122,10 @@ namespace iter {
             {
                 public:
                     constexpr static const bool is_base_iter = true;
-
-                    Iterator() { }
                     Iterator(const Iterator&) { }
                     Iterator& operator=(const Iterator&) { return *this; }
 
+                    Iterator() { }
                     void reset() { }
 
                     Iterator& operator++() {
@@ -165,6 +165,10 @@ namespace iter {
     Productor<Containers...> product(Containers&&... containers) {
         return {std::forward<Containers>(containers)...};
     }
+
+    constexpr std::array<std::tuple<>, 1> product() {
+        return {{}};
+    }
 }
 
-#endif // #ifndef ITER_PRODUCT_HPP_
+#endif

From ddf7e6e82bebdd42af68a9d5b9c5e72a93e0d44a Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 19 Jan 2015 20:03:21 -0500
Subject: [PATCH 0761/1866] Removes unecessary explicit ctor and operator=

---
 product.hpp | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/product.hpp b/product.hpp
index 93c977f2..c40909f8 100644
--- a/product.hpp
+++ b/product.hpp
@@ -122,10 +122,7 @@ namespace iter {
             {
                 public:
                     constexpr static const bool is_base_iter = true;
-                    Iterator(const Iterator&) { }
-                    Iterator& operator=(const Iterator&) { return *this; }
 
-                    Iterator() { }
                     void reset() { }
 
                     Iterator& operator++() {

From b244969c402cd87e1165887ac4e9be4b96628d7a Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 19 Jan 2015 20:06:06 -0500
Subject: [PATCH 0762/1866] adds devel catch.hpp to allow printing of tuples

---
 catchtest/catch.hpp | 943 +++++++++++++++++++++++++++++++-------------
 1 file changed, 676 insertions(+), 267 deletions(-)

diff --git a/catchtest/catch.hpp b/catchtest/catch.hpp
index 6b8dfb5e..c79324cf 100644
--- a/catchtest/catch.hpp
+++ b/catchtest/catch.hpp
@@ -1,6 +1,6 @@
 /*
- *  CATCH v1.0 build 53 (master branch)
- *  Generated: 2014-08-20 08:08:19.533804
+ *  CATCH v1.1 build 13 (develop branch)
+ *  Generated: 2014-12-30 18:47:08.984634
  *  ----------------------------------------------------------
  *  This file has been merged from multiple headers. Please don't edit it directly
  *  Copyright (c) 2012 Two Blue Cubes Ltd. All rights reserved.
@@ -33,11 +33,11 @@
 #pragma GCC diagnostic ignored "-Wpadded"
 #endif
 
-#ifdef CATCH_CONFIG_MAIN
-#  define CATCH_CONFIG_RUNNER
+#if defined(CATCH_CONFIG_MAIN) || defined(CATCH_CONFIG_RUNNER)
+#  define CATCH_IMPL
 #endif
 
-#ifdef CATCH_CONFIG_RUNNER
+#ifdef CATCH_IMPL
 #  ifndef CLARA_CONFIG_MAIN
 #    define CLARA_CONFIG_MAIN_NOT_DEFINED
 #    define CLARA_CONFIG_MAIN
@@ -135,6 +135,10 @@
 // Visual C++
 #ifdef _MSC_VER
 
+#if (_MSC_VER >= 1600)
+#define CATCH_CONFIG_CPP11_NULLPTR
+#endif
+
 #if (_MSC_VER >= 1310 ) // (VC++ 7.0+)
 //#define CATCH_CONFIG_SFINAE // Not confirmed
 #endif
@@ -176,8 +180,16 @@
 namespace Catch {
 
     class NonCopyable {
-        NonCopyable( NonCopyable const& );
-        void operator = ( NonCopyable const& );
+#ifdef CATCH_CPP11_OR_GREATER
+        NonCopyable( NonCopyable const& )              = delete;
+        NonCopyable( NonCopyable && )                  = delete;
+        NonCopyable& operator = ( NonCopyable const& ) = delete;
+        NonCopyable& operator = ( NonCopyable && )     = delete;
+#else
+        NonCopyable( NonCopyable const& info );
+        NonCopyable& operator = ( NonCopyable const& );
+#endif
+
     protected:
         NonCopyable() {}
         virtual ~NonCopyable();
@@ -215,6 +227,7 @@ namespace Catch {
     void toLowerInPlace( std::string& s );
     std::string toLower( std::string const& s );
     std::string trim( std::string const& str );
+    bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis );
 
     struct pluralise {
         pluralise( std::size_t count, std::string const& label );
@@ -467,7 +480,7 @@ namespace Catch {
     struct ITestCaseRegistry {
         virtual ~ITestCaseRegistry();
         virtual std::vector<TestCase> const& getAllTests() const = 0;
-        virtual void getFilteredTests( TestSpec const& testSpec, IConfig const& config, std::vector<TestCase>& matchingTestCases ) const = 0;
+        virtual void getFilteredTests( TestSpec const& testSpec, IConfig const& config, std::vector<TestCase>& matchingTestCases, bool negated = false ) const = 0;
 
     };
 }
@@ -603,7 +616,9 @@ namespace Catch {
         Exception = 0x100 | FailureBit,
 
         ThrewException = Exception | 1,
-        DidntThrowException = Exception | 2
+        DidntThrowException = Exception | 2,
+
+        FatalErrorCondition = 0x200 | FailureBit
 
     }; };
 
@@ -1034,9 +1049,49 @@ inline id performOptionalSelector( id obj, SEL sel ) {
 
 #endif
 
+#ifdef CATCH_CPP11_OR_GREATER
+#include <tuple>
+#include <type_traits>
+#endif
+
 namespace Catch {
+
+// Why we're here.
+template<typename T>
+std::string toString( T const& value );
+
+// Built in overloads
+
+std::string toString( std::string const& value );
+std::string toString( std::wstring const& value );
+std::string toString( const char* const value );
+std::string toString( char* const value );
+std::string toString( const wchar_t* const value );
+std::string toString( wchar_t* const value );
+std::string toString( int value );
+std::string toString( unsigned long value );
+std::string toString( unsigned int value );
+std::string toString( const double value );
+std::string toString( const float value );
+std::string toString( bool value );
+std::string toString( char value );
+std::string toString( signed char value );
+std::string toString( unsigned char value );
+
+#ifdef CATCH_CONFIG_CPP11_NULLPTR
+std::string toString( std::nullptr_t );
+#endif
+
+#ifdef __OBJC__
+    std::string toString( NSString const * const& nsstring );
+    std::string toString( NSString * CATCH_ARC_STRONG const& nsstring );
+    std::string toString( NSObject* const& nsObject );
+#endif
+
 namespace Detail {
 
+    extern std::string unprintableString;
+
 // SFINAE is currently disabled by default for all compilers.
 // If the non SFINAE version of IsStreamInsertable is ambiguous for you
 // and your compiler supports SFINAE, try #defining CATCH_CONFIG_SFINAE
@@ -1077,10 +1132,38 @@ namespace Detail {
 
 #endif
 
+#if defined(CATCH_CPP11_OR_GREATER)
+    template<typename T,
+             bool IsEnum = std::is_enum<T>::value
+             >
+    struct EnumStringMaker
+    {
+        static std::string convert( T const& ) { return unprintableString; }
+    };
+
+    template<typename T>
+    struct EnumStringMaker<T,true>
+    {
+        static std::string convert( T const& v )
+        {
+            return ::Catch::toString(
+                static_cast<typename std::underlying_type<T>::type>(v)
+                );
+        }
+    };
+#endif
     template<bool C>
     struct StringMakerBase {
+#if defined(CATCH_CPP11_OR_GREATER)
+        template<typename T>
+        static std::string convert( T const& v )
+        {
+            return EnumStringMaker<T>::convert( v );
+        }
+#else
         template<typename T>
-        static std::string convert( T const& ) { return "{?}"; }
+        static std::string convert( T const& ) { return unprintableString; }
+#endif
     };
 
     template<>
@@ -1102,9 +1185,6 @@ namespace Detail {
 
 } // end namespace Detail
 
-template<typename T>
-std::string toString( T const& value );
-
 template<typename T>
 struct StringMaker :
     Detail::StringMakerBase<Detail::IsStreamInsertable<T>::value> {};
@@ -1135,12 +1215,59 @@ namespace Detail {
     std::string rangeToString( InputIterator first, InputIterator last );
 }
 
+//template<typename T, typename Allocator>
+//struct StringMaker<std::vector<T, Allocator> > {
+//    static std::string convert( std::vector<T,Allocator> const& v ) {
+//        return Detail::rangeToString( v.begin(), v.end() );
+//    }
+//};
+
 template<typename T, typename Allocator>
-struct StringMaker<std::vector<T, Allocator> > {
-    static std::string convert( std::vector<T,Allocator> const& v ) {
-        return Detail::rangeToString( v.begin(), v.end() );
+std::string toString( std::vector<T,Allocator> const& v ) {
+    return Detail::rangeToString( v.begin(), v.end() );
+}
+
+#ifdef CATCH_CPP11_OR_GREATER
+//toString for tuples
+ 
+namespace TupleDetail {
+  template<
+      typename Tuple,
+      std::size_t N = 0,
+      bool = (N < std::tuple_size<Tuple>::value)
+      >
+  struct ElementPrinter {
+      static void print( const Tuple& tuple, std::ostream& os )
+      {
+          os << ( N ? ", " : " " )
+             << Catch::toString(std::get<N>(tuple));
+          ElementPrinter<Tuple,N+1>::print(tuple,os);
+      }
+  };
+
+  template<
+      typename Tuple,
+      std::size_t N
+      >
+  struct ElementPrinter<Tuple,N,false> {
+      static void print( const Tuple&, std::ostream& ) {}
+  };
+
+}
+
+template<typename ...Types>
+struct StringMaker<std::tuple<Types...>> {
+
+    static std::string convert( const std::tuple<Types...>& tuple )
+    {
+        std::ostringstream os;
+        os << '{';
+        TupleDetail::ElementPrinter<std::tuple<Types...>>::print( tuple, os );
+        os << " }";
+        return os.str();
     }
 };
+#endif
 
 namespace Detail {
     template<typename T>
@@ -1161,44 +1288,15 @@ std::string toString( T const& value ) {
     return StringMaker<T>::convert( value );
 }
 
-// Built in overloads
-
-std::string toString( std::string const& value );
-std::string toString( std::wstring const& value );
-std::string toString( const char* const value );
-std::string toString( char* const value );
-std::string toString( const wchar_t* const value );
-std::string toString( wchar_t* const value );
-std::string toString( int value );
-std::string toString( unsigned long value );
-std::string toString( unsigned int value );
-std::string toString( const double value );
-std::string toString( const float value );
-std::string toString( bool value );
-std::string toString( char value );
-std::string toString( signed char value );
-std::string toString( unsigned char value );
-
-#ifdef CATCH_CONFIG_CPP11_NULLPTR
-std::string toString( std::nullptr_t );
-#endif
-
-#ifdef __OBJC__
-    std::string toString( NSString const * const& nsstring );
-    std::string toString( NSString * CATCH_ARC_STRONG const& nsstring );
-    std::string toString( NSObject* const& nsObject );
-#endif
-
     namespace Detail {
     template<typename InputIterator>
     std::string rangeToString( InputIterator first, InputIterator last ) {
         std::ostringstream oss;
         oss << "{ ";
         if( first != last ) {
-            oss << toString( *first );
-            for( ++first ; first != last ; ++first ) {
-                oss << ", " << toString( *first );
-            }
+            oss << Catch::toString( *first );
+            for( ++first ; first != last ; ++first )
+                oss << ", " << Catch::toString( *first );
         }
         oss << " }";
         return oss.str();
@@ -1395,6 +1493,8 @@ namespace Catch {
 
         virtual std::string getCurrentTestName() const = 0;
         virtual const AssertionResult* getLastResult() const = 0;
+
+        virtual void handleFatalErrorCondition( std::string const& message ) = 0;
     };
 
     IResultCapture& getResultCapture();
@@ -1575,7 +1675,7 @@ namespace Catch {
             std::string matcherAsString = ::Catch::Matchers::matcher.toString(); \
             __catchResult \
                 .setLhs( Catch::toString( arg ) ) \
-                .setRhs( matcherAsString == "{?}" ? #matcher : matcherAsString ) \
+                .setRhs( matcherAsString == Catch::Detail::unprintableString ? #matcher : matcherAsString ) \
                 .setOp( "matches" ) \
                 .setResultType( ::Catch::Matchers::matcher.match( arg ) ); \
             __catchResult.captureExpression(); \
@@ -1636,6 +1736,9 @@ namespace Catch {
         bool allPassed() const {
             return failed == 0 && failedButOk == 0;
         }
+        bool allOk() const {
+            return failed == 0;
+        }
 
         std::size_t passed;
         std::size_t failed;
@@ -1688,7 +1791,7 @@ namespace Catch {
     public:
         Timer() : m_ticks( 0 ) {}
         void start();
-        unsigned int getElapsedNanoseconds() const;
+        unsigned int getElapsedMicroseconds() const;
         unsigned int getElapsedMilliseconds() const;
         double getElapsedSeconds() const;
 
@@ -1702,7 +1805,7 @@ namespace Catch {
 
 namespace Catch {
 
-    class Section {
+    class Section : NonCopyable {
     public:
         Section( SectionInfo const& info );
         ~Section();
@@ -1711,15 +1814,6 @@ namespace Catch {
         operator bool() const;
 
     private:
-#ifdef CATCH_CPP11_OR_GREATER
-        Section( Section const& )              = delete;
-        Section( Section && )                  = delete;
-        Section& operator = ( Section const& ) = delete;
-        Section& operator = ( Section && )     = delete;
-#else
-        Section( Section const& info );
-        Section& operator = ( Section const& );
-#endif
         SectionInfo m_info;
 
         std::string m_name;
@@ -2694,7 +2788,7 @@ return @ desc; \
 
 #endif
 
-#ifdef CATCH_CONFIG_RUNNER
+#ifdef CATCH_IMPL
 // #included from: internal/catch_impl.hpp
 #define TWOBLUECUBES_CATCH_IMPL_HPP_INCLUDED
 
@@ -2962,6 +3056,11 @@ namespace Catch {
         Always,
         Never
     }; };
+    struct RunTests { enum InWhatOrder {
+        InDeclarationOrder,
+        InLexicographicalOrder,
+        InRandomOrder
+    }; };
 
     class TestSpec;
 
@@ -2979,6 +3078,8 @@ namespace Catch {
         virtual bool showInvisibles() const = 0;
         virtual ShowDurations::OrNot showDurations() const = 0;
         virtual TestSpec const& testSpec() const = 0;
+        virtual RunTests::InWhatOrder runOrder() const = 0;
+        virtual unsigned int rngSeed() const = 0;
     };
 }
 
@@ -3004,12 +3105,16 @@ namespace Catch {
     private:
         bool isOwned;
     };
+
+    std::ostream& cout();
+    std::ostream& cerr();
 }
 
 #include <memory>
 #include <vector>
 #include <string>
 #include <iostream>
+#include <ctime>
 
 #ifndef CATCH_CONFIG_CONSOLE_WIDTH
 #define CATCH_CONFIG_CONSOLE_WIDTH 80
@@ -3030,9 +3135,11 @@ namespace Catch {
             showHelp( false ),
             showInvisibles( false ),
             abortAfter( -1 ),
+            rngSeed( 0 ),
             verbosity( Verbosity::Normal ),
             warnings( WarnAbout::Nothing ),
-            showDurations( ShowDurations::DefaultForReporter )
+            showDurations( ShowDurations::DefaultForReporter ),
+            runOrder( RunTests::InDeclarationOrder )
         {}
 
         bool listTests;
@@ -3047,10 +3154,12 @@ namespace Catch {
         bool showInvisibles;
 
         int abortAfter;
+        unsigned int rngSeed;
 
         Verbosity::Level verbosity;
         WarnAbout::What warnings;
         ShowDurations::OrNot showDurations;
+        RunTests::InWhatOrder runOrder;
 
         std::string reporterName;
         std::string outputFilename;
@@ -3068,12 +3177,12 @@ namespace Catch {
     public:
 
         Config()
-        :   m_os( std::cout.rdbuf() )
+        :   m_os( Catch::cout().rdbuf() )
         {}
 
         Config( ConfigData const& data )
         :   m_data( data ),
-            m_os( std::cout.rdbuf() )
+            m_os( Catch::cout().rdbuf() )
         {
             if( !data.testsOrTags.empty() ) {
                 TestSpecParser parser( ITagAliasRegistry::get() );
@@ -3084,7 +3193,7 @@ namespace Catch {
         }
 
         virtual ~Config() {
-            m_os.rdbuf( std::cout.rdbuf() );
+            m_os.rdbuf( Catch::cout().rdbuf() );
             m_stream.release();
         }
 
@@ -3106,7 +3215,7 @@ namespace Catch {
         bool shouldDebugBreak() const { return m_data.shouldDebugBreak; }
 
         void setStreamBuf( std::streambuf* buf ) {
-            m_os.rdbuf( buf ? buf : std::cout.rdbuf() );
+            m_os.rdbuf( buf ? buf : Catch::cout().rdbuf() );
         }
 
         void useStream( std::string const& streamName ) {
@@ -3132,6 +3241,8 @@ namespace Catch {
         virtual bool includeSuccessfulResults() const   { return m_data.showSuccessfulTests; }
         virtual bool warnAboutMissingAssertions() const { return m_data.warnings & WarnAbout::NoAssertions; }
         virtual ShowDurations::OrNot showDurations() const { return m_data.showDurations; }
+        virtual RunTests::InWhatOrder runOrder() const  { return m_data.runOrder; }
+        virtual unsigned int rngSeed() const    { return m_data.rngSeed; }
 
     private:
         ConfigData m_data;
@@ -3760,7 +3871,7 @@ namespace Clara {
             m_throwOnUnrecognisedTokens( other.m_throwOnUnrecognisedTokens )
         {
             if( other.m_floatingArg.get() )
-                m_floatingArg = ArgAutoPtr( new Arg( *other.m_floatingArg ) );
+                m_floatingArg.reset( new Arg( *other.m_floatingArg ) );
         }
 
         CommandLine& setThrowOnUnrecognisedTokens( bool shouldThrow = true ) {
@@ -3788,7 +3899,7 @@ namespace Clara {
         ArgBuilder operator[]( UnpositionalTag ) {
             if( m_floatingArg.get() )
                 throw std::logic_error( "Only one unpositional argument can be added" );
-            m_floatingArg = ArgAutoPtr( new Arg() );
+            m_floatingArg.reset( new Arg() );
             ArgBuilder builder( m_floatingArg.get() );
             return builder;
         }
@@ -3930,7 +4041,7 @@ namespace Clara {
                 if( it == itEnd ) {
                     if( token.type == Parser::Token::Positional || !m_throwOnUnrecognisedTokens )
                         unusedTokens.push_back( token );
-                    else if( m_throwOnUnrecognisedTokens )
+                    else if( errors.empty() && m_throwOnUnrecognisedTokens )
                         errors.push_back( "unrecognised option: " + token.data );
                 }
             }
@@ -4028,7 +4139,28 @@ namespace Catch {
             config.warnings = static_cast<WarnAbout::What>( config.warnings | WarnAbout::NoAssertions );
         else
             throw std::runtime_error( "Unrecognised warning: '" + _warning + "'" );
-
+    }
+    inline void setOrder( ConfigData& config, std::string const& order ) {
+        if( startsWith( "declared", order ) )
+            config.runOrder = RunTests::InDeclarationOrder;
+        else if( startsWith( "lexical", order ) )
+            config.runOrder = RunTests::InLexicographicalOrder;
+        else if( startsWith( "random", order ) )
+            config.runOrder = RunTests::InRandomOrder;
+        else
+            throw std::runtime_error( "Unrecognised ordering: '" + order + "'" );
+    }
+    inline void setRngSeed( ConfigData& config, std::string const& seed ) {
+        if( seed == "time" ) {
+            config.rngSeed = static_cast<unsigned int>( std::time(0) );
+        }
+        else {
+            std::stringstream ss;
+            ss << seed;
+            ss >> config.rngSeed;
+            if( ss.fail() )
+                throw std::runtime_error( "Argment to --rng-seed should be the word 'time' or a number" );
+        }
     }
     inline void setVerbosity( ConfigData& config, int level ) {
         // !TBD: accept strings?
@@ -4140,6 +4272,14 @@ namespace Catch {
             .describe( "list all reporters" )
             .bind( &ConfigData::listReporters );
 
+        cli["--order"]
+            .describe( "test case order (defaults to decl)" )
+            .bind( &setOrder, "decl|lex|rand" );
+
+        cli["--rng-seed"]
+            .describe( "set a specific seed for random numbers" )
+            .bind( &setRngSeed, "'time'|number" );
+
         return cli;
     }
 
@@ -4313,10 +4453,6 @@ namespace Catch {
 
 namespace Catch {
 
-    namespace Detail {
-        struct IColourImpl;
-    }
-
     struct Colour {
         enum Code {
             None = 0,
@@ -4362,7 +4498,6 @@ namespace Catch {
         static void use( Code _colourCode );
 
     private:
-        static Detail::IColourImpl* impl();
         bool m_moved;
     };
 
@@ -4592,11 +4727,14 @@ namespace Catch
 
         virtual void assertionStarting( AssertionInfo const& assertionInfo ) = 0;
 
+        // The return value indicates if the messages buffer should be cleared:
         virtual bool assertionEnded( AssertionStats const& assertionStats ) = 0;
         virtual void sectionEnded( SectionStats const& sectionStats ) = 0;
         virtual void testCaseEnded( TestCaseStats const& testCaseStats ) = 0;
         virtual void testGroupEnded( TestGroupStats const& testGroupStats ) = 0;
         virtual void testRunEnded( TestRunStats const& testRunStats ) = 0;
+
+        virtual void skipTest( TestCaseInfo const& testInfo ) = 0;
     };
 
     struct IReporterFactory {
@@ -4624,9 +4762,9 @@ namespace Catch {
 
         TestSpec testSpec = config.testSpec();
         if( config.testSpec().hasFilters() )
-            std::cout << "Matching test cases:\n";
+            Catch::cout() << "Matching test cases:\n";
         else {
-            std::cout << "All available test cases:\n";
+            Catch::cout() << "All available test cases:\n";
             testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "*" ).testSpec();
         }
 
@@ -4647,15 +4785,15 @@ namespace Catch {
                 : Colour::None;
             Colour colourGuard( colour );
 
-            std::cout << Text( testCaseInfo.name, nameAttr ) << std::endl;
+            Catch::cout() << Text( testCaseInfo.name, nameAttr ) << std::endl;
             if( !testCaseInfo.tags.empty() )
-                std::cout << Text( testCaseInfo.tagsAsString, tagsAttr ) << std::endl;
+                Catch::cout() << Text( testCaseInfo.tagsAsString, tagsAttr ) << std::endl;
         }
 
         if( !config.testSpec().hasFilters() )
-            std::cout << pluralise( matchedTests, "test case" ) << "\n" << std::endl;
+            Catch::cout() << pluralise( matchedTests, "test case" ) << "\n" << std::endl;
         else
-            std::cout << pluralise( matchedTests, "matching test case" ) << "\n" << std::endl;
+            Catch::cout() << pluralise( matchedTests, "matching test case" ) << "\n" << std::endl;
         return matchedTests;
     }
 
@@ -4671,7 +4809,7 @@ namespace Catch {
                 ++it ) {
             matchedTests++;
             TestCaseInfo const& testCaseInfo = it->getTestCaseInfo();
-            std::cout << testCaseInfo.name << std::endl;
+            Catch::cout() << testCaseInfo.name << std::endl;
         }
         return matchedTests;
     }
@@ -4697,9 +4835,9 @@ namespace Catch {
     inline std::size_t listTags( Config const& config ) {
         TestSpec testSpec = config.testSpec();
         if( config.testSpec().hasFilters() )
-            std::cout << "Tags for matching test cases:\n";
+            Catch::cout() << "Tags for matching test cases:\n";
         else {
-            std::cout << "All available tags:\n";
+            Catch::cout() << "All available tags:\n";
             testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "*" ).testSpec();
         }
 
@@ -4733,14 +4871,14 @@ namespace Catch {
                                                     .setInitialIndent( 0 )
                                                     .setIndent( oss.str().size() )
                                                     .setWidth( CATCH_CONFIG_CONSOLE_WIDTH-10 ) );
-            std::cout << oss.str() << wrapper << "\n";
+            Catch::cout() << oss.str() << wrapper << "\n";
         }
-        std::cout << pluralise( tagCounts.size(), "tag" ) << "\n" << std::endl;
+        Catch::cout() << pluralise( tagCounts.size(), "tag" ) << "\n" << std::endl;
         return tagCounts.size();
     }
 
     inline std::size_t listReporters( Config const& /*config*/ ) {
-        std::cout << "Available reports:\n";
+        Catch::cout() << "Available reporters:\n";
         IReporterRegistry::FactoryMap const& factories = getRegistryHub().getReporterRegistry().getFactories();
         IReporterRegistry::FactoryMap::const_iterator itBegin = factories.begin(), itEnd = factories.end(), it;
         std::size_t maxNameLen = 0;
@@ -4752,13 +4890,13 @@ namespace Catch {
                                                         .setInitialIndent( 0 )
                                                         .setIndent( 7+maxNameLen )
                                                         .setWidth( CATCH_CONFIG_CONSOLE_WIDTH - maxNameLen-8 ) );
-            std::cout << "  "
+            Catch::cout() << "  "
                     << it->first
                     << ":"
                     << std::string( maxNameLen - it->first.size() + 2, ' ' )
                     << wrapper << "\n";
         }
-        std::cout << std::endl;
+        Catch::cout() << std::endl;
         return factories.size();
     }
 
@@ -4915,6 +5053,81 @@ using SectionTracking::TestCaseTracker;
 
 } // namespace Catch
 
+// #included from: catch_fatal_condition.hpp
+#define TWOBLUECUBES_CATCH_FATAL_CONDITION_H_INCLUDED
+
+namespace Catch {
+
+    // Report the error condition then exit the process
+    inline void fatal( std::string const& message, int exitCode ) {
+        IContext& context = Catch::getCurrentContext();
+        IResultCapture* resultCapture = context.getResultCapture();
+        resultCapture->handleFatalErrorCondition( message );
+
+		if( Catch::alwaysTrue() ) // avoids "no return" warnings
+            exit( exitCode );
+    }
+
+} // namespace Catch
+
+#if defined ( CATCH_PLATFORM_WINDOWS ) /////////////////////////////////////////
+
+namespace Catch {
+
+    struct FatalConditionHandler {
+		void reset() {}
+	};
+
+} // namespace Catch
+
+#else // Not Windows - assumed to be POSIX compatible //////////////////////////
+
+#include <signal.h>
+
+namespace Catch {
+
+    struct SignalDefs { int id; const char* name; };
+    extern SignalDefs signalDefs[];
+    SignalDefs signalDefs[] = {
+            { SIGINT,  "SIGINT - Terminal interrupt signal" },
+            { SIGILL,  "SIGILL - Illegal instruction signal" },
+            { SIGFPE,  "SIGFPE - Floating point error signal" },
+            { SIGSEGV, "SIGSEGV - Segmentation violation signal" },
+            { SIGTERM, "SIGTERM - Termination request signal" },
+            { SIGABRT, "SIGABRT - Abort (abnormal termination) signal" }
+        };
+
+    struct FatalConditionHandler {
+
+        static void handleSignal( int sig ) {
+            for( std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i )
+                if( sig == signalDefs[i].id )
+                    fatal( signalDefs[i].name, -sig );
+            fatal( "<unknown signal>", -sig );
+        }
+
+        FatalConditionHandler() : m_isSet( true ) {
+            for( std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i )
+                signal( signalDefs[i].id, handleSignal );
+        }
+        ~FatalConditionHandler() {
+            reset();
+        }
+        void reset() {
+            if( m_isSet ) {
+                for( std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i )
+                    signal( signalDefs[i].id, SIG_DFL );
+                m_isSet = false;
+            }
+        }
+
+        bool m_isSet;
+    };
+
+} // namespace Catch
+
+#endif // not Windows
+
 #include <set>
 #include <string>
 
@@ -5102,6 +5315,37 @@ namespace Catch {
             return &m_lastResult;
         }
 
+        virtual void handleFatalErrorCondition( std::string const& message ) {
+            ResultBuilder resultBuilder = makeUnexpectedResultBuilder();
+            resultBuilder.setResultType( ResultWas::FatalErrorCondition );
+            resultBuilder << message;
+            resultBuilder.captureExpression();
+
+            handleUnfinishedSections();
+
+            // Recreate section for test case (as we will lose the one that was in scope)
+            TestCaseInfo const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
+            SectionInfo testCaseSection( testCaseInfo.lineInfo, testCaseInfo.name, testCaseInfo.description );
+
+            Counts assertions;
+            assertions.failed = 1;
+            SectionStats testCaseSectionStats( testCaseSection, assertions, 0, false );
+            m_reporter->sectionEnded( testCaseSectionStats );
+
+            TestCaseInfo testInfo = m_activeTestCase->getTestCaseInfo();
+
+            Totals deltaTotals;
+            deltaTotals.testCases.failed = 1;
+            m_reporter->testCaseEnded( TestCaseStats(   testInfo,
+                                                        deltaTotals,
+                                                        "",
+                                                        "",
+                                                        false ) );
+            m_totals.testCases.failed++;
+            testGroupEnded( "", m_totals, 1, 1 );
+            m_reporter->testRunEnded( TestRunStats( m_runInfo, m_totals, false ) );
+        }
+
     public:
         // !TBD We need to do this another way!
         bool aborting() const {
@@ -5123,12 +5367,12 @@ namespace Catch {
                 Timer timer;
                 timer.start();
                 if( m_reporter->getPreferences().shouldRedirectStdOut ) {
-                    StreamRedirect coutRedir( std::cout, redirectedCout );
-                    StreamRedirect cerrRedir( std::cerr, redirectedCerr );
-                    m_activeTestCase->invoke();
+                    StreamRedirect coutRedir( Catch::cout(), redirectedCout );
+                    StreamRedirect cerrRedir( Catch::cerr(), redirectedCerr );
+                    invokeActiveTestCase();
                 }
                 else {
-                    m_activeTestCase->invoke();
+                    invokeActiveTestCase();
                 }
                 duration = timer.getElapsedSeconds();
             }
@@ -5136,20 +5380,9 @@ namespace Catch {
                 // This just means the test was aborted due to failure
             }
             catch(...) {
-                ResultBuilder exResult( m_lastAssertionInfo.macroName.c_str(),
-                                        m_lastAssertionInfo.lineInfo,
-                                        m_lastAssertionInfo.capturedExpression.c_str(),
-                                        m_lastAssertionInfo.resultDisposition );
-                exResult.useActiveException();
+                makeUnexpectedResultBuilder().useActiveException();
             }
-            // If sections ended prematurely due to an exception we stored their
-            // infos here so we can tear them down outside the unwind process.
-            for( std::vector<UnfinishedSections>::const_reverse_iterator it = m_unfinishedSections.rbegin(),
-                        itEnd = m_unfinishedSections.rend();
-                    it != itEnd;
-                    ++it )
-                sectionEnded( it->info, it->prevAssertions, it->durationInSeconds );
-            m_unfinishedSections.clear();
+            handleUnfinishedSections();
             m_messages.clear();
 
             Counts assertions = m_totals.assertions - prevAssertions;
@@ -5165,7 +5398,32 @@ namespace Catch {
             m_reporter->sectionEnded( testCaseSectionStats );
         }
 
+        void invokeActiveTestCase() {
+            FatalConditionHandler fatalConditionHandler; // Handle signals
+            m_activeTestCase->invoke();
+            fatalConditionHandler.reset();
+        }
+
     private:
+
+        ResultBuilder makeUnexpectedResultBuilder() const {
+            return ResultBuilder(   m_lastAssertionInfo.macroName.c_str(),
+                                    m_lastAssertionInfo.lineInfo,
+                                    m_lastAssertionInfo.capturedExpression.c_str(),
+                                    m_lastAssertionInfo.resultDisposition );
+        }
+
+        void handleUnfinishedSections() {
+            // If sections ended prematurely due to an exception we stored their
+            // infos here so we can tear them down outside the unwind process.
+            for( std::vector<UnfinishedSections>::const_reverse_iterator it = m_unfinishedSections.rbegin(),
+                        itEnd = m_unfinishedSections.rend();
+                    it != itEnd;
+                    ++it )
+                sectionEnded( it->info, it->prevAssertions, it->durationInSeconds );
+            m_unfinishedSections.clear();
+        }
+
         struct UnfinishedSections {
             UnfinishedSections( SectionInfo const& _info, Counts const& _prevAssertions, double _durationInSeconds )
             : info( _info ), prevAssertions( _prevAssertions ), durationInSeconds( _durationInSeconds )
@@ -5253,7 +5511,7 @@ namespace Catch {
 
             Totals totals;
 
-            context.testGroupStarting( "", 1, 1 ); // deprecated?
+            context.testGroupStarting( "all tests", 1, 1 ); // deprecated?
 
             TestSpec testSpec = m_config->testSpec();
             if( !testSpec.hasFilters() )
@@ -5276,7 +5534,15 @@ namespace Catch {
                     m_testsAlreadyRun.insert( *it );
                 }
             }
-            context.testGroupEnded( "", totals, 1, 1 );
+            std::vector<TestCase> skippedTestCases;
+            getRegistryHub().getTestCaseRegistry().getFilteredTests( testSpec, *m_config, skippedTestCases, true );
+
+            for( std::vector<TestCase>::const_iterator it = skippedTestCases.begin(), itEnd = skippedTestCases.end();
+                    it != itEnd;
+                    ++it )
+                m_reporter->skipTest( *it );
+
+            context.testGroupEnded( "all tests", totals, 1, 1 );
             return totals;
         }
 
@@ -5313,7 +5579,7 @@ namespace Catch {
         std::set<TestCase> m_testsAlreadyRun;
     };
 
-    class Session {
+    class Session : NonCopyable {
         static bool alreadyInstantiated;
 
     public:
@@ -5324,7 +5590,7 @@ namespace Catch {
         : m_cli( makeCommandLineParser() ) {
             if( alreadyInstantiated ) {
                 std::string msg = "Only one instance of Catch::Session can ever be used";
-                std::cerr << msg << std::endl;
+                Catch::cerr() << msg << std::endl;
                 throw std::logic_error( msg );
             }
             alreadyInstantiated = true;
@@ -5334,15 +5600,15 @@ namespace Catch {
         }
 
         void showHelp( std::string const& processName ) {
-            std::cout << "\nCatch v"    << libraryVersion.majorVersion << "."
+            Catch::cout() << "\nCatch v"    << libraryVersion.majorVersion << "."
                                         << libraryVersion.minorVersion << " build "
                                         << libraryVersion.buildNumber;
             if( libraryVersion.branchName != std::string( "master" ) )
-                std::cout << " (" << libraryVersion.branchName << " branch)";
-            std::cout << "\n";
+                Catch::cout() << " (" << libraryVersion.branchName << " branch)";
+            Catch::cout() << "\n";
 
-            m_cli.usage( std::cout, processName );
-            std::cout << "For more detail usage please see the project docs\n" << std::endl;
+            m_cli.usage( Catch::cout(), processName );
+            Catch::cout() << "For more detail usage please see the project docs\n" << std::endl;
         }
 
         int applyCommandLine( int argc, char* const argv[], OnUnusedOptions::DoWhat unusedOptionBehaviour = OnUnusedOptions::Fail ) {
@@ -5356,11 +5622,11 @@ namespace Catch {
             catch( std::exception& ex ) {
                 {
                     Colour colourGuard( Colour::Red );
-                    std::cerr   << "\nError(s) in input:\n"
+                    Catch::cerr()   << "\nError(s) in input:\n"
                                 << Text( ex.what(), TextAttributes().setIndent(2) )
                                 << "\n\n";
                 }
-                m_cli.usage( std::cout, m_configData.processName );
+                m_cli.usage( Catch::cout(), m_configData.processName );
                 return (std::numeric_limits<int>::max)();
             }
             return 0;
@@ -5386,6 +5652,9 @@ namespace Catch {
             try
             {
                 config(); // Force config to be constructed
+
+                std::srand( m_configData.rngSeed );
+
                 Runner runner( m_config );
 
                 // Handle list request
@@ -5395,7 +5664,7 @@ namespace Catch {
                 return static_cast<int>( runner.runTests().assertions.failed );
             }
             catch( std::exception& ex ) {
-                std::cerr << ex.what() << std::endl;
+                Catch::cerr() << ex.what() << std::endl;
                 return (std::numeric_limits<int>::max)();
             }
         }
@@ -5436,10 +5705,18 @@ namespace Catch {
 #include <set>
 #include <sstream>
 #include <iostream>
+#include <algorithm>
 
 namespace Catch {
 
     class TestRegistry : public ITestCaseRegistry {
+        struct LexSort {
+            bool operator() (TestCase i,TestCase j) const { return (i<j);}
+        };
+        struct RandomNumberGenerator {
+            int operator()( int n ) const { return std::rand() % n; }
+        };
+
     public:
         TestRegistry() : m_unnamedCount( 0 ) {}
         virtual ~TestRegistry();
@@ -5462,7 +5739,7 @@ namespace Catch {
                 TestCase const& prev = *m_functions.find( testCase );
                 {
                     Colour colourGuard( Colour::Red );
-                    std::cerr   << "error: TEST_CASE( \"" << name << "\" ) already defined.\n"
+                    Catch::cerr()   << "error: TEST_CASE( \"" << name << "\" ) already defined.\n"
                                 << "\tFirst seen at " << prev.getTestCaseInfo().lineInfo << "\n"
                                 << "\tRedefined at " << testCase.getTestCaseInfo().lineInfo << std::endl;
                 }
@@ -5478,18 +5755,38 @@ namespace Catch {
             return m_nonHiddenFunctions;
         }
 
-        virtual void getFilteredTests( TestSpec const& testSpec, IConfig const& config, std::vector<TestCase>& matchingTestCases ) const {
+        virtual void getFilteredTests( TestSpec const& testSpec, IConfig const& config, std::vector<TestCase>& matchingTestCases, bool negated = false ) const {
+
             for( std::vector<TestCase>::const_iterator  it = m_functionsInOrder.begin(),
                                                         itEnd = m_functionsInOrder.end();
                     it != itEnd;
                     ++it ) {
-                if( testSpec.matches( *it ) && ( config.allowThrows() || !it->throws() ) )
+                bool includeTest = testSpec.matches( *it ) && ( config.allowThrows() || !it->throws() );
+                if( includeTest != negated )
                     matchingTestCases.push_back( *it );
             }
+            sortTests( config, matchingTestCases );
         }
 
     private:
 
+        static void sortTests( IConfig const& config, std::vector<TestCase>& matchingTestCases ) {
+
+            switch( config.runOrder() ) {
+                case RunTests::InLexicographicalOrder:
+                    std::sort( matchingTestCases.begin(), matchingTestCases.end(), LexSort() );
+                    break;
+                case RunTests::InRandomOrder:
+                {
+                    RandomNumberGenerator rng;
+                    std::random_shuffle( matchingTestCases.begin(), matchingTestCases.end(), rng );
+                }
+                    break;
+                case RunTests::InDeclarationOrder:
+                    // already in declaration order
+                    break;
+            }
+        }
         std::set<TestCase> m_functions;
         std::vector<TestCase> m_functionsInOrder;
         std::vector<TestCase> m_nonHiddenFunctions;
@@ -5613,7 +5910,7 @@ namespace Catch {
                     throw;
                 }
                 @catch (NSException *exception) {
-                    return toString( [exception description] );
+                    return Catch::toString( [exception description] );
                 }
 #else
                 throw;
@@ -5760,6 +6057,7 @@ namespace Catch {
 
 #include <stdexcept>
 #include <cstdio>
+#include <iostream>
 
 namespace Catch {
 
@@ -5823,6 +6121,15 @@ namespace Catch {
             isOwned = false;
         }
     }
+
+#ifndef CATCH_CONFIG_NOSTDOUT // If you #define this you must implement this functions
+    std::ostream& cout() {
+        return std::cout;
+    }
+    std::ostream& cerr() {
+        return std::cerr;
+    }
+#endif
 }
 
 namespace Catch {
@@ -5908,8 +6215,8 @@ namespace Catch {
     }
 
     Stream createStream( std::string const& streamName ) {
-        if( streamName == "stdout" ) return Stream( std::cout.rdbuf(), false );
-        if( streamName == "stderr" ) return Stream( std::cerr.rdbuf(), false );
+        if( streamName == "stdout" ) return Stream( Catch::cout().rdbuf(), false );
+        if( streamName == "stderr" ) return Stream( Catch::cerr().rdbuf(), false );
         if( streamName == "debug" ) return Stream( new StreamBufImpl<OutputDebugWriter>, true );
 
         throw std::domain_error( "Unknown stream: " + streamName );
@@ -5924,14 +6231,35 @@ namespace Catch {
 // #included from: catch_console_colour_impl.hpp
 #define TWOBLUECUBES_CATCH_CONSOLE_COLOUR_IMPL_HPP_INCLUDED
 
-namespace Catch { namespace Detail {
-    struct IColourImpl {
-        virtual ~IColourImpl() {}
-        virtual void use( Colour::Code _colourCode ) = 0;
-    };
-}}
+namespace Catch {
+    namespace {
 
-#if defined ( CATCH_PLATFORM_WINDOWS ) /////////////////////////////////////////
+        struct IColourImpl {
+            virtual ~IColourImpl() {}
+            virtual void use( Colour::Code _colourCode ) = 0;
+        };
+
+        struct NoColourImpl : IColourImpl {
+            void use( Colour::Code ) {}
+
+            static IColourImpl* instance() {
+                static NoColourImpl s_instance;
+                return &s_instance;
+            }
+        };
+
+    } // anon namespace
+} // namespace Catch
+
+#if !defined( CATCH_CONFIG_COLOUR_NONE ) && !defined( CATCH_CONFIG_COLOUR_WINDOWS ) && !defined( CATCH_CONFIG_COLOUR_ANSI )
+#   ifdef CATCH_PLATFORM_WINDOWS
+#       define CATCH_CONFIG_COLOUR_WINDOWS
+#   else
+#       define CATCH_CONFIG_COLOUR_ANSI
+#   endif
+#endif
+
+#if defined ( CATCH_CONFIG_COLOUR_WINDOWS ) /////////////////////////////////////////
 
 #ifndef NOMINMAX
 #define NOMINMAX
@@ -5946,7 +6274,7 @@ namespace Catch { namespace Detail {
 namespace Catch {
 namespace {
 
-    class Win32ColourImpl : public Detail::IColourImpl {
+    class Win32ColourImpl : public IColourImpl {
     public:
         Win32ColourImpl() : stdoutHandle( GetStdHandle(STD_OUTPUT_HANDLE) )
         {
@@ -5983,11 +6311,7 @@ namespace {
         WORD originalAttributes;
     };
 
-    inline bool shouldUseColourForPlatform() {
-        return true;
-    }
-
-    static Detail::IColourImpl* platformColourInstance() {
+    IColourImpl* platformColourInstance() {
         static Win32ColourImpl s_instance;
         return &s_instance;
     }
@@ -5995,7 +6319,7 @@ namespace {
 } // end anon namespace
 } // end namespace Catch
 
-#else // Not Windows - assumed to be POSIX compatible //////////////////////////
+#elif defined( CATCH_CONFIG_COLOUR_ANSI ) //////////////////////////////////////
 
 #include <unistd.h>
 
@@ -6006,7 +6330,7 @@ namespace {
     // Thanks to Adam Strzelecki for original contribution
     // (http://github.com/nanoant)
     // https://github.com/philsquared/Catch/pull/131
-    class PosixColourImpl : public Detail::IColourImpl {
+    class PosixColourImpl : public IColourImpl {
     public:
         virtual void use( Colour::Code _colourCode ) {
             switch( _colourCode ) {
@@ -6027,53 +6351,47 @@ namespace {
                 case Colour::Bright: throw std::logic_error( "not a colour" );
             }
         }
+        static IColourImpl* instance() {
+            static PosixColourImpl s_instance;
+            return &s_instance;
+        }
+
     private:
         void setColour( const char* _escapeCode ) {
-            std::cout << '\033' << _escapeCode;
+            Catch::cout() << '\033' << _escapeCode;
         }
     };
 
-    inline bool shouldUseColourForPlatform() {
-        return isatty(STDOUT_FILENO);
-    }
-
-    static Detail::IColourImpl* platformColourInstance() {
-        static PosixColourImpl s_instance;
-        return &s_instance;
+    IColourImpl* platformColourInstance() {
+        return isatty(STDOUT_FILENO)
+            ? PosixColourImpl::instance()
+            : NoColourImpl::instance();
     }
 
 } // end anon namespace
 } // end namespace Catch
 
-#endif // not Windows
+#else  // not Windows or ANSI ///////////////////////////////////////////////
 
 namespace Catch {
 
-    namespace {
-        struct NoColourImpl : Detail::IColourImpl {
-            void use( Colour::Code ) {}
+    static IColourImpl* platformColourInstance() { return NoColourImpl::instance(); }
 
-            static IColourImpl* instance() {
-                static NoColourImpl s_instance;
-                return &s_instance;
-            }
-        };
-        static bool shouldUseColour() {
-            return shouldUseColourForPlatform() && !isDebuggerActive();
-        }
-    }
+} // end namespace Catch
+
+#endif // Windows/ ANSI/ None
+
+namespace Catch {
 
     Colour::Colour( Code _colourCode ) : m_moved( false ) { use( _colourCode ); }
     Colour::Colour( Colour const& _other ) : m_moved( false ) { const_cast<Colour&>( _other ).m_moved = true; }
     Colour::~Colour(){ if( !m_moved ) use( None ); }
-    void Colour::use( Code _colourCode ) {
-        impl()->use( _colourCode );
-    }
 
-    Detail::IColourImpl* Colour::impl() {
-        return shouldUseColour()
-            ? platformColourInstance()
-            : NoColourImpl::instance();
+    void Colour::use( Code _colourCode ) {
+        static IColourImpl* impl = isDebuggerActive()
+            ? NoColourImpl::instance()
+            : platformColourInstance();
+        impl->use( _colourCode );
     }
 
 } // end namespace Catch
@@ -6238,7 +6556,7 @@ namespace Catch {
 namespace Catch {
 
     inline TestCaseInfo::SpecialProperties parseSpecialTag( std::string const& tag ) {
-        if( tag == "." ||
+        if( startsWith( tag, "." ) ||
             tag == "hide" ||
             tag == "!hide" )
             return TestCaseInfo::IsHidden;
@@ -6252,19 +6570,19 @@ namespace Catch {
             return TestCaseInfo::None;
     }
     inline bool isReservedTag( std::string const& tag ) {
-        return parseSpecialTag( tag ) == TestCaseInfo::None && tag.size() > 0 && !isalnum( tag[0] );
+        return TestCaseInfo::None && tag.size() > 0 && !isalnum( tag[0] );
     }
     inline void enforceNotReservedTag( std::string const& tag, SourceLineInfo const& _lineInfo ) {
         if( isReservedTag( tag ) ) {
             {
                 Colour colourGuard( Colour::Red );
-                std::cerr
+                Catch::cerr()
                     << "Tag name [" << tag << "] not allowed.\n"
                     << "Tag names starting with non alpha-numeric characters are reserved\n";
             }
             {
                 Colour colourGuard( Colour::FileName );
-                std::cerr << _lineInfo << std::endl;
+                Catch::cerr() << _lineInfo << std::endl;
             }
             exit(1);
         }
@@ -6292,14 +6610,15 @@ namespace Catch {
             }
             else {
                 if( c == ']' ) {
-                    enforceNotReservedTag( tag, _lineInfo );
-
-                    inTag = false;
-                    if( tag == "hide" || tag == "." )
+                    TestCaseInfo::SpecialProperties prop = parseSpecialTag( tag );
+                    if( prop == TestCaseInfo::IsHidden )
                         isHidden = true;
-                    else
-                        tags.insert( tag );
+                    else if( prop == TestCaseInfo::None )
+                        enforceNotReservedTag( tag, _lineInfo );
+
+                    tags.insert( tag );
                     tag.clear();
+                    inTag = false;
                 }
                 else
                     tag += c;
@@ -6417,7 +6736,7 @@ namespace Catch {
 namespace Catch {
 
     // These numbers are maintained by a script
-    Version libraryVersion( 1, 0, 53, "master" );
+    Version libraryVersion( 1, 1, 13, "develop" );
 }
 
 // #included from: catch_message.hpp
@@ -6501,6 +6820,7 @@ namespace Catch
         virtual void testCaseEnded( TestCaseStats const& testCaseStats );
         virtual void testGroupEnded( TestGroupStats const& testGroupStats );
         virtual void testRunEnded( TestRunStats const& testRunStats );
+        virtual void skipTest( TestCaseInfo const& );
 
     private:
         Ptr<IReporter> m_legacyReporter;
@@ -6574,6 +6894,8 @@ namespace Catch
     void LegacyReporterAdapter::testRunEnded( TestRunStats const& testRunStats ) {
         m_legacyReporter->EndTesting( testRunStats.totals );
     }
+    void LegacyReporterAdapter::skipTest( TestCaseInfo const& ) {
+    }
 }
 
 // #included from: catch_timer.hpp
@@ -6615,14 +6937,14 @@ namespace Catch {
     void Timer::start() {
         m_ticks = getCurrentTicks();
     }
-    unsigned int Timer::getElapsedNanoseconds() const {
+    unsigned int Timer::getElapsedMicroseconds() const {
         return static_cast<unsigned int>(getCurrentTicks() - m_ticks);
     }
     unsigned int Timer::getElapsedMilliseconds() const {
-        return static_cast<unsigned int>((getCurrentTicks() - m_ticks)/1000);
+        return static_cast<unsigned int>(getElapsedMicroseconds()/1000);
     }
     double Timer::getElapsedSeconds() const {
-        return (getCurrentTicks() - m_ticks)/1000000.0;
+        return getElapsedMicroseconds()/1000000.0;
     }
 
 } // namespace Catch
@@ -6660,6 +6982,20 @@ namespace Catch {
         return start != std::string::npos ? str.substr( start, 1+end-start ) : "";
     }
 
+    bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis ) {
+        bool replaced = false;
+        std::size_t i = str.find( replaceThis );
+        while( i != std::string::npos ) {
+            replaced = true;
+            str = str.substr( 0, i ) + withThis + str.substr( i+replaceThis.size() );
+            if( i < str.size()-withThis.size() )
+                i = str.find( replaceThis, i+withThis.size() );
+            else
+                i = std::string::npos;
+        }
+        return replaced;
+    }
+
     pluralise::pluralise( std::size_t count, std::string const& label )
     :   m_count( count ),
         m_label( label )
@@ -6781,7 +7117,7 @@ namespace Catch {
 
             size = sizeof(info);
             if( sysctl(mib, sizeof(mib) / sizeof(*mib), &info, &size, NULL, 0) != 0 ) {
-                std::cerr << "\n** Call to sysctl failed - unable to determine if debugger is active **\n" << std::endl;
+                Catch::cerr() << "\n** Call to sysctl failed - unable to determine if debugger is active **\n" << std::endl;
                 return false;
             }
 
@@ -6822,7 +7158,7 @@ namespace Catch {
     namespace Catch {
         void writeToDebugConsole( std::string const& text ) {
             // !TBD: Need a version for Mac/ XCode and other IDEs
-            std::cout << text;
+            Catch::cout() << text;
         }
     }
 #endif // Platform
@@ -6834,6 +7170,8 @@ namespace Catch {
 
 namespace Detail {
 
+    std::string unprintableString = "{?}";
+
     namespace {
         struct Endianness {
             enum Arch { Big, Little };
@@ -6892,7 +7230,7 @@ std::string toString( std::wstring const& value ) {
     s.reserve( value.size() );
     for(size_t i = 0; i < value.size(); ++i )
         s += value[i] <= 0xff ? static_cast<char>( value[i] ) : '?';
-    return toString( s );
+    return Catch::toString( s );
 }
 
 std::string toString( const char* const value ) {
@@ -6915,7 +7253,10 @@ std::string toString( wchar_t* const value )
 
 std::string toString( int value ) {
     std::ostringstream oss;
-    oss << value;
+    if( value > 8192 )
+        oss << "0x" << std::hex << value;
+    else
+        oss << value;
     return oss.str();
 }
 
@@ -6929,7 +7270,7 @@ std::string toString( unsigned long value ) {
 }
 
 std::string toString( unsigned int value ) {
-    return toString( static_cast<unsigned long>( value ) );
+    return Catch::toString( static_cast<unsigned long>( value ) );
 }
 
 template<typename T>
@@ -7195,7 +7536,7 @@ namespace Catch {
         }
         catch( std::exception& ex ) {
             Colour colourGuard( Colour::Red );
-            std::cerr << ex.what() << std::endl;
+            Catch::cerr() << ex.what() << std::endl;
             exit(1);
         }
     }
@@ -7208,6 +7549,8 @@ namespace Catch {
 // #included from: catch_reporter_bases.hpp
 #define TWOBLUECUBES_CATCH_REPORTER_BASES_HPP_INCLUDED
 
+#include <cstring>
+
 namespace Catch {
 
     struct StreamingReporterBase : SharedImpl<IStreamingReporter> {
@@ -7251,6 +7594,11 @@ namespace Catch {
             currentTestRunInfo.reset();
         }
 
+        virtual void skipTest( TestCaseInfo const& ) {
+            // Don't do anything with this by default.
+            // It can optionally be overridden in the derived class.
+        }
+
         Ptr<IConfig> m_config;
         std::ostream& stream;
 
@@ -7380,6 +7728,8 @@ namespace Catch {
         }
         virtual void testRunEndedCumulative() = 0;
 
+        virtual void skipTest( TestCaseInfo const& ) {}
+
         Ptr<IConfig> m_config;
         std::ostream& stream;
         std::vector<AssertionStats> m_assertions;
@@ -7395,6 +7745,16 @@ namespace Catch {
 
     };
 
+    template<char C>
+    char const* getLineOfChars() {
+        static char line[CATCH_CONFIG_CONSOLE_WIDTH] = {0};
+        if( !*line ) {
+            memset( line, C, CATCH_CONFIG_CONSOLE_WIDTH-1 );
+            line[CATCH_CONFIG_CONSOLE_WIDTH-1] = 0;
+        }
+        return line;
+    }
+
 } // end namespace Catch
 
 // #included from: ../internal/catch_reporter_registrars.hpp
@@ -7464,7 +7824,6 @@ namespace Catch {
 #define TWOBLUECUBES_CATCH_XMLWRITER_HPP_INCLUDED
 
 #include <sstream>
-#include <iostream>
 #include <string>
 #include <vector>
 
@@ -7507,7 +7866,7 @@ namespace Catch {
         XmlWriter()
         :   m_tagIsOpen( false ),
             m_needsNewline( false ),
-            m_os( &std::cout )
+            m_os( &Catch::cout() )
         {}
 
         XmlWriter( std::ostream& os )
@@ -7677,81 +8036,90 @@ namespace Catch {
 
 }
 namespace Catch {
-    class XmlReporter : public SharedImpl<IReporter> {
+    class XmlReporter : public StreamingReporterBase {
     public:
-        XmlReporter( ReporterConfig const& config ) : m_config( config ), m_sectionDepth( 0 ) {}
+        XmlReporter( ReporterConfig const& _config )
+        :   StreamingReporterBase( _config ),
+            m_sectionDepth( 0 )
+        {}
+
+        virtual ~XmlReporter();
 
         static std::string getDescription() {
             return "Reports test results as an XML document";
         }
-        virtual ~XmlReporter();
-
-    private: // IReporter
 
-        virtual bool shouldRedirectStdout() const {
-            return true;
+    public: // StreamingReporterBase
+        virtual ReporterPreferences getPreferences() const {
+            ReporterPreferences prefs;
+            prefs.shouldRedirectStdOut = true;
+            return prefs;
         }
 
-        virtual void StartTesting() {
-            m_xml.setStream( m_config.stream() );
-            m_xml.startElement( "Catch" );
-            if( !m_config.fullConfig()->name().empty() )
-                m_xml.writeAttribute( "name", m_config.fullConfig()->name() );
+        virtual void noMatchingTestCases( std::string const& s ) {
+            StreamingReporterBase::noMatchingTestCases( s );
         }
 
-        virtual void EndTesting( const Totals& totals ) {
-            m_xml.scopedElement( "OverallResults" )
-                .writeAttribute( "successes", totals.assertions.passed )
-                .writeAttribute( "failures", totals.assertions.failed )
-                .writeAttribute( "expectedFailures", totals.assertions.failedButOk );
-            m_xml.endElement();
+        virtual void testRunStarting( TestRunInfo const& testInfo ) {
+            StreamingReporterBase::testRunStarting( testInfo );
+            m_xml.setStream( stream );
+            m_xml.startElement( "Catch" );
+            if( !m_config->name().empty() )
+                m_xml.writeAttribute( "name", m_config->name() );
         }
 
-        virtual void StartGroup( const std::string& groupName ) {
+        virtual void testGroupStarting( GroupInfo const& groupInfo ) {
+            StreamingReporterBase::testGroupStarting( groupInfo );
             m_xml.startElement( "Group" )
-                .writeAttribute( "name", groupName );
+                .writeAttribute( "name", groupInfo.name );
         }
 
-        virtual void EndGroup( const std::string&, const Totals& totals ) {
-            m_xml.scopedElement( "OverallResults" )
-                .writeAttribute( "successes", totals.assertions.passed )
-                .writeAttribute( "failures", totals.assertions.failed )
-                .writeAttribute( "expectedFailures", totals.assertions.failedButOk );
-            m_xml.endElement();
+        virtual void testCaseStarting( TestCaseInfo const& testInfo ) {
+            StreamingReporterBase::testCaseStarting(testInfo);
+            m_xml.startElement( "TestCase" ).writeAttribute( "name", trim( testInfo.name ) );
+
+            if ( m_config->showDurations() == ShowDurations::Always )
+                m_testCaseTimer.start();
         }
 
-        virtual void StartSection( const std::string& sectionName, const std::string& description ) {
+        virtual void sectionStarting( SectionInfo const& sectionInfo ) {
+            StreamingReporterBase::sectionStarting( sectionInfo );
             if( m_sectionDepth++ > 0 ) {
                 m_xml.startElement( "Section" )
-                    .writeAttribute( "name", trim( sectionName ) )
-                    .writeAttribute( "description", description );
+                    .writeAttribute( "name", trim( sectionInfo.name ) )
+                    .writeAttribute( "description", sectionInfo.description );
             }
         }
-        virtual void NoAssertionsInSection( const std::string& ) {}
-        virtual void NoAssertionsInTestCase( const std::string& ) {}
 
-        virtual void EndSection( const std::string& /*sectionName*/, const Counts& assertions ) {
-            if( --m_sectionDepth > 0 ) {
-                m_xml.scopedElement( "OverallResults" )
-                    .writeAttribute( "successes", assertions.passed )
-                    .writeAttribute( "failures", assertions.failed )
-                    .writeAttribute( "expectedFailures", assertions.failedButOk );
-                m_xml.endElement();
-            }
-        }
+        virtual void assertionStarting( AssertionInfo const& ) { }
 
-        virtual void StartTestCase( const Catch::TestCaseInfo& testInfo ) {
-            m_xml.startElement( "TestCase" ).writeAttribute( "name", trim( testInfo.name ) );
-            m_currentTestSuccess = true;
-        }
+        virtual bool assertionEnded( AssertionStats const& assertionStats ) {
+            const AssertionResult& assertionResult = assertionStats.assertionResult;
 
-        virtual void Result( const Catch::AssertionResult& assertionResult ) {
-            if( !m_config.fullConfig()->includeSuccessfulResults() && assertionResult.getResultType() == ResultWas::Ok )
-                return;
+            // Print any info messages in <Info> tags.
+            if( assertionStats.assertionResult.getResultType() != ResultWas::Ok ) {
+                for( std::vector<MessageInfo>::const_iterator it = assertionStats.infoMessages.begin(), itEnd = assertionStats.infoMessages.end();
+                        it != itEnd;
+                        ++it ) {
+                    if( it->type == ResultWas::Info ) {
+                        m_xml.scopedElement( "Info" )
+                            .writeText( it->message );
+                    } else if ( it->type == ResultWas::Warning ) {
+                        m_xml.scopedElement( "Warning" )
+                            .writeText( it->message );
+                    }
+                }
+            }
+
+            // Drop out if result was successful but we're not printing them.
+            if( !m_config->includeSuccessfulResults() && isOk(assertionResult.getResultType()) )
+                return true;
 
+            // Print the expression if there is one.
             if( assertionResult.hasExpression() ) {
                 m_xml.startElement( "Expression" )
                     .writeAttribute( "success", assertionResult.succeeded() )
+					.writeAttribute( "type", assertionResult.getTestMacroName() )
                     .writeAttribute( "filename", assertionResult.getSourceInfo().file )
                     .writeAttribute( "line", assertionResult.getSourceInfo().line );
 
@@ -7759,58 +8127,96 @@ namespace Catch {
                     .writeText( assertionResult.getExpression() );
                 m_xml.scopedElement( "Expanded" )
                     .writeText( assertionResult.getExpandedExpression() );
-                m_currentTestSuccess &= assertionResult.succeeded();
             }
 
+            // And... Print a result applicable to each result type.
             switch( assertionResult.getResultType() ) {
                 case ResultWas::ThrewException:
                     m_xml.scopedElement( "Exception" )
                         .writeAttribute( "filename", assertionResult.getSourceInfo().file )
                         .writeAttribute( "line", assertionResult.getSourceInfo().line )
                         .writeText( assertionResult.getMessage() );
-                    m_currentTestSuccess = false;
+                    break;
+                case ResultWas::FatalErrorCondition:
+                    m_xml.scopedElement( "Fatal Error Condition" )
+                        .writeAttribute( "filename", assertionResult.getSourceInfo().file )
+                        .writeAttribute( "line", assertionResult.getSourceInfo().line )
+                        .writeText( assertionResult.getMessage() );
                     break;
                 case ResultWas::Info:
                     m_xml.scopedElement( "Info" )
                         .writeText( assertionResult.getMessage() );
                     break;
                 case ResultWas::Warning:
-                    m_xml.scopedElement( "Warning" )
-                        .writeText( assertionResult.getMessage() );
+                    // Warning will already have been written
                     break;
                 case ResultWas::ExplicitFailure:
                     m_xml.scopedElement( "Failure" )
                         .writeText( assertionResult.getMessage() );
-                    m_currentTestSuccess = false;
                     break;
-                case ResultWas::Unknown:
-                case ResultWas::Ok:
-                case ResultWas::FailureBit:
-                case ResultWas::ExpressionFailed:
-                case ResultWas::Exception:
-                case ResultWas::DidntThrowException:
+                default:
                     break;
             }
+
             if( assertionResult.hasExpression() )
                 m_xml.endElement();
+
+            return true;
+        }
+
+        virtual void sectionEnded( SectionStats const& sectionStats ) {
+            StreamingReporterBase::sectionEnded( sectionStats );
+            if( --m_sectionDepth > 0 ) {
+                XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResults" );
+                e.writeAttribute( "successes", sectionStats.assertions.passed );
+                e.writeAttribute( "failures", sectionStats.assertions.failed );
+                e.writeAttribute( "expectedFailures", sectionStats.assertions.failedButOk );
+
+                if ( m_config->showDurations() == ShowDurations::Always )
+                    e.writeAttribute( "durationInSeconds", sectionStats.durationInSeconds );
+
+                m_xml.endElement();
+            }
+        }
+
+        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) {
+            StreamingReporterBase::testCaseEnded( testCaseStats );
+            XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResult" );
+            e.writeAttribute( "success", testCaseStats.totals.assertions.allOk() );
+
+            if ( m_config->showDurations() == ShowDurations::Always )
+                e.writeAttribute( "durationInSeconds", m_testCaseTimer.getElapsedSeconds() );
+
+            m_xml.endElement();
         }
 
-        virtual void Aborted() {
-            // !TBD
+        virtual void testGroupEnded( TestGroupStats const& testGroupStats ) {
+            StreamingReporterBase::testGroupEnded( testGroupStats );
+            // TODO: Check testGroupStats.aborting and act accordingly.
+            m_xml.scopedElement( "OverallResults" )
+                .writeAttribute( "successes", testGroupStats.totals.assertions.passed )
+                .writeAttribute( "failures", testGroupStats.totals.assertions.failed )
+                .writeAttribute( "expectedFailures", testGroupStats.totals.assertions.failedButOk );
+            m_xml.endElement();
         }
 
-        virtual void EndTestCase( const Catch::TestCaseInfo&, const Totals&, const std::string&, const std::string& ) {
-            m_xml.scopedElement( "OverallResult" ).writeAttribute( "success", m_currentTestSuccess );
+        virtual void testRunEnded( TestRunStats const& testRunStats ) {
+            StreamingReporterBase::testRunEnded( testRunStats );
+            m_xml.scopedElement( "OverallResults" )
+                .writeAttribute( "successes", testRunStats.totals.assertions.passed )
+                .writeAttribute( "failures", testRunStats.totals.assertions.failed )
+                .writeAttribute( "expectedFailures", testRunStats.totals.assertions.failedButOk );
             m_xml.endElement();
         }
 
     private:
-        ReporterConfig m_config;
-        bool m_currentTestSuccess;
+        Timer m_testCaseTimer;
         XmlWriter m_xml;
         int m_sectionDepth;
     };
 
+     INTERNAL_CATCH_REGISTER_REPORTER( "xml", XmlReporter )
+
 } // end namespace Catch
 
 // #included from: ../reporters/catch_reporter_junit.hpp
@@ -7937,7 +8343,7 @@ namespace Catch {
                     xml.writeAttribute( "classname", className );
                     xml.writeAttribute( "name", name );
                 }
-                xml.writeAttribute( "time", toString( sectionNode.stats.durationInSeconds ) );
+                xml.writeAttribute( "time", Catch::toString( sectionNode.stats.durationInSeconds ) );
 
                 writeAssertions( sectionNode );
 
@@ -7970,6 +8376,7 @@ namespace Catch {
                 std::string elementName;
                 switch( result.getResultType() ) {
                     case ResultWas::ThrewException:
+                    case ResultWas::FatalErrorCondition:
                         elementName = "error";
                         break;
                     case ResultWas::ExplicitFailure:
@@ -8028,8 +8435,6 @@ namespace Catch {
 // #included from: ../reporters/catch_reporter_console.hpp
 #define TWOBLUECUBES_CATCH_REPORTER_CONSOLE_HPP_INCLUDED
 
-#include <cstring>
-
 namespace Catch {
 
     struct ConsoleReporter : StreamingReporterBase {
@@ -8164,6 +8569,11 @@ namespace Catch {
                         passOrFail = "FAILED";
                         messageLabel = "due to unexpected exception with message";
                         break;
+                    case ResultWas::FatalErrorCondition:
+                        colour = Colour::Error;
+                        passOrFail = "FAILED";
+                        messageLabel = "due to a fatal error condition";
+                        break;
                     case ResultWas::DidntThrowException:
                         colour = Colour::Error;
                         passOrFail = "FAILED";
@@ -8281,6 +8691,9 @@ namespace Catch {
             stream  << " host application.\n"
                     << "Run with -? for options\n\n";
 
+            if( m_config->rngSeed() != 0 )
+                stream << "Randomness seeded to: " << m_config->rngSeed() << "\n\n";
+
             currentTestRunInfo.used = true;
         }
         void lazyPrintGroupInfo() {
@@ -8452,15 +8865,6 @@ namespace Catch {
         void printSummaryDivider() {
             stream << getLineOfChars<'-'>() << "\n";
         }
-        template<char C>
-        static char const* getLineOfChars() {
-            static char line[CATCH_CONFIG_CONSOLE_WIDTH] = {0};
-            if( !*line ) {
-                memset( line, C, CATCH_CONFIG_CONSOLE_WIDTH-1 );
-                line[CATCH_CONFIG_CONSOLE_WIDTH-1] = 0;
-            }
-            return line;
-        }
 
     private:
         bool m_headerPrinted;
@@ -8569,6 +8973,13 @@ namespace Catch {
                         printExpressionWas();
                         printRemainingMessages();
                         break;
+                    case ResultWas::FatalErrorCondition:
+                        printResultType( Colour::Error, failedString() );
+                        printIssue( "fatal error condition with message:" );
+                        printMessage();
+                        printExpressionWas();
+                        printRemainingMessages();
+                        break;
                     case ResultWas::DidntThrowException:
                         printResultType( Colour::Error, failedString() );
                         printIssue( "expected exception, got none" );
@@ -8798,8 +9209,6 @@ namespace Catch {
     Matchers::Impl::StdString::EndsWith::~EndsWith() {}
 
     void Config::dummy() {}
-
-    INTERNAL_CATCH_REGISTER_LEGACY_REPORTER( "xml", XmlReporter )
 }
 
 #ifdef __clang__

From 16b9f350447dc0c75d096882de07008f4a990794 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 19 Jan 2015 20:22:01 -0500
Subject: [PATCH 0763/1866] adds basic repeat test

---
 catchtest/test_repeat.cpp | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 catchtest/test_repeat.cpp

diff --git a/catchtest/test_repeat.cpp b/catchtest/test_repeat.cpp
new file mode 100644
index 00000000..61977e92
--- /dev/null
+++ b/catchtest/test_repeat.cpp
@@ -0,0 +1,25 @@
+#include <repeat.hpp>
+
+#include "helpers.hpp"
+
+#include <vector>
+#include <string>
+#include <iterator>
+
+#include "catch.hpp"
+
+using iter::repeat;
+
+TEST_CASE("repeat: one argument keeps giving value back", "[repeat]") {
+    auto r = repeat('a');
+    auto it = std::begin(r);
+    REQUIRE( *it == 'a' );
+    ++it;
+    REQUIRE( *it == 'a' );
+    ++it;
+    REQUIRE( *it == 'a' );
+    ++it;
+    REQUIRE( *it == 'a' );
+    ++it;
+    REQUIRE( *it == 'a' );
+}

From eabe0dcae6864052e69b42ecc69c211f7dfdb05e Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 19 Jan 2015 20:26:34 -0500
Subject: [PATCH 0764/1866] repeat iterator is input iterator

---
 repeat.hpp | 18 ++++++++++++++----
 1 file changed, 14 insertions(+), 4 deletions(-)

diff --git a/repeat.hpp b/repeat.hpp
index 9753675d..a0b96cf5 100644
--- a/repeat.hpp
+++ b/repeat.hpp
@@ -1,5 +1,5 @@
-#ifndef REPEAT_HPP__
-#define REPEAT_HPP__
+#ifndef ITER_REPEAT_HPP_
+#define ITER_REPEAT_HPP_
 
 #include <iterator>
 #include <utility>
@@ -28,7 +28,7 @@ namespace iter {
             { }
         public:
 
-            class Iterator {
+            class Iterator : public std::iterator<std::input_iterator_tag, T> {
                 private:
                     T& elem;
                     int count;
@@ -49,11 +49,21 @@ namespace iter {
                         return *this;
                     }
 
+                    Iterator operator++(int) {
+                        auto ret = *this;
+                        ++*this;
+                        return ret;
+                    }
+
                     bool operator!=(const Iterator& other) const {
                         return this->count != other.count ||
                             &this->elem != &other.elem;
                     }
 
+                    bool operator==(const Iterator& other) const {
+                        return !(*this != other);
+                    }
+
                     T& operator*() {
                         return this->elem;
                     }
@@ -76,4 +86,4 @@ namespace iter {
         
 }
 
-#endif //REPEAT_HPP__
+#endif

From 79f250a1b69e27ce55176174dd461cb5ca58679b Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 19 Jan 2015 20:31:24 -0500
Subject: [PATCH 0765/1866] makes repeat iterators assignable

replaces reference with pointer
---
 repeat.hpp | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/repeat.hpp b/repeat.hpp
index a0b96cf5..73e0ac27 100644
--- a/repeat.hpp
+++ b/repeat.hpp
@@ -30,10 +30,10 @@ namespace iter {
 
             class Iterator : public std::iterator<std::input_iterator_tag, T> {
                 private:
-                    T& elem;
+                    T* elem;
                     int count;
                 public:
-                    Iterator(T& e, int c)
+                    Iterator(T* e, int c)
                         : elem{e},
                         count{c}
                     { }
@@ -57,7 +57,7 @@ namespace iter {
 
                     bool operator!=(const Iterator& other) const {
                         return this->count != other.count ||
-                            &this->elem != &other.elem;
+                            this->elem != other.elem;
                     }
 
                     bool operator==(const Iterator& other) const {
@@ -65,16 +65,16 @@ namespace iter {
                     }
 
                     T& operator*() {
-                        return this->elem;
+                        return *this->elem;
                     }
             };
 
             Iterator begin() {
-                return {this->elem, this->count};
+                return {&this->elem, this->count};
             }
 
             Iterator end() {
-                return {this->elem, 0};
+                return {&this->elem, 0};
             }
 
     };

From 628a67259b3edcd2a789f1bb2a55ea13bb904c18 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 19 Jan 2015 20:32:14 -0500
Subject: [PATCH 0766/1866] tests repeat with count

---
 catchtest/test_repeat.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/catchtest/test_repeat.cpp b/catchtest/test_repeat.cpp
index 61977e92..7d5fc098 100644
--- a/catchtest/test_repeat.cpp
+++ b/catchtest/test_repeat.cpp
@@ -23,3 +23,9 @@ TEST_CASE("repeat: one argument keeps giving value back", "[repeat]") {
     ++it;
     REQUIRE( *it == 'a' );
 }
+
+TEST_CASE("repeat: two argument repeats a number of times", "[repeat]") {
+    auto r = repeat('a', 3);
+    std::string s(std::begin(r), std::end(r));
+}
+

From 5cdddbaf343fbef7bb461ba456e7903b471d1c57 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 19 Jan 2015 20:32:23 -0500
Subject: [PATCH 0767/1866] builds repeat test

---
 catchtest/SConstruct | 1 +
 1 file changed, 1 insertion(+)

diff --git a/catchtest/SConstruct b/catchtest/SConstruct
index ce88d2a3..62765a99 100644
--- a/catchtest/SConstruct
+++ b/catchtest/SConstruct
@@ -33,6 +33,7 @@ progs = Split(
     permutations
     powerset
     product
+    repeat
     '''
 )
 

From 1bd10ca3bfb018b4453c8dc4f37fffa41986569c Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 19 Jan 2015 20:37:08 -0500
Subject: [PATCH 0768/1866] actually tests repeat with count

---
 catchtest/test_repeat.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/catchtest/test_repeat.cpp b/catchtest/test_repeat.cpp
index 7d5fc098..a8a4c1e9 100644
--- a/catchtest/test_repeat.cpp
+++ b/catchtest/test_repeat.cpp
@@ -27,5 +27,5 @@ TEST_CASE("repeat: one argument keeps giving value back", "[repeat]") {
 TEST_CASE("repeat: two argument repeats a number of times", "[repeat]") {
     auto r = repeat('a', 3);
     std::string s(std::begin(r), std::end(r));
+    REQUIRE( s == "aaa" );
 }
-

From 7804aa319d7cd97fd968a908cd4df58b430eafd8 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 19 Jan 2015 20:38:21 -0500
Subject: [PATCH 0769/1866] tests repeat with 0 count

---
 catchtest/test_repeat.cpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/catchtest/test_repeat.cpp b/catchtest/test_repeat.cpp
index a8a4c1e9..f93bc18b 100644
--- a/catchtest/test_repeat.cpp
+++ b/catchtest/test_repeat.cpp
@@ -29,3 +29,8 @@ TEST_CASE("repeat: two argument repeats a number of times", "[repeat]") {
     std::string s(std::begin(r), std::end(r));
     REQUIRE( s == "aaa" );
 }
+
+TEST_CASE("repeat: 0 count gives empty sequence", "[repeat]") {
+    auto r = repeat('a', 0);
+    REQUIRE( std::begin(r) == std::end(r) );
+}

From 04b97b5103e62ae5ed41eebb6e0d0dc420053a00 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 19 Jan 2015 22:14:16 -0500
Subject: [PATCH 0770/1866] Repeat strips reference from pointer type

---
 repeat.hpp | 25 +++++++++++++++++++------
 1 file changed, 19 insertions(+), 6 deletions(-)

diff --git a/repeat.hpp b/repeat.hpp
index 73e0ac27..749972d0 100644
--- a/repeat.hpp
+++ b/repeat.hpp
@@ -2,6 +2,7 @@
 #define ITER_REPEAT_HPP_
 
 #include <iterator>
+#include <type_traits>
 #include <utility>
 
 namespace iter {
@@ -13,12 +14,17 @@ namespace iter {
     class Repeater;
 
     template <typename T>
-    Repeater<T> repeat(T&&, int count =INFINITE_REPEAT);
+    Repeater<T> repeat(T&&);
+
+    template <typename T>
+    Repeater<T> repeat(T&&, int);
 
     template <typename T>
     class Repeater {
+        friend Repeater repeat<T>(T&&);
         friend Repeater repeat<T>(T&&, int);
         private:
+            using TPlain = typename std::remove_reference<T>::type;
             T elem;
             int count;
 
@@ -28,12 +34,14 @@ namespace iter {
             { }
         public:
 
-            class Iterator : public std::iterator<std::input_iterator_tag, T> {
+            class Iterator
+                : public std::iterator<std::input_iterator_tag, TPlain>
+            {
                 private:
-                    T* elem;
+                    TPlain* elem;
                     int count;
                 public:
-                    Iterator(T* e, int c)
+                    Iterator(TPlain* e, int c)
                         : elem{e},
                         count{c}
                     { }
@@ -80,10 +88,15 @@ namespace iter {
     };
 
     template <typename T>
-    Repeater<T> repeat(T&& e, int count) {
-        return {std::forward<T>(e), count};
+    Repeater<T> repeat(T&& e) {
+        return {std::forward<T>(e), INFINITE_REPEAT};
     }
         
+    template <typename T>
+    Repeater<T> repeat(T&& e, int count) {
+        // if count is negative, pass 0 instead
+        return {std::forward<T>(e), count < 0 ? 0 : count};
+    }
 }
 
 #endif

From f130b82db3e54b32f83f8ddcf301f47058a49480 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 19 Jan 2015 22:14:46 -0500
Subject: [PATCH 0771/1866] tests that repeat doesn't copy element

---
 catchtest/test_repeat.cpp | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/catchtest/test_repeat.cpp b/catchtest/test_repeat.cpp
index f93bc18b..0f159d29 100644
--- a/catchtest/test_repeat.cpp
+++ b/catchtest/test_repeat.cpp
@@ -34,3 +34,18 @@ TEST_CASE("repeat: 0 count gives empty sequence", "[repeat]") {
     auto r = repeat('a', 0);
     REQUIRE( std::begin(r) == std::end(r) );
 }
+
+TEST_CASE("repeat: negative count gives empty sequence", "[repeat]") {
+    auto r = repeat('a', -2);
+    REQUIRE( std::begin(r) == std::end(r) );
+    auto r2 = repeat('a', -1);
+    REQUIRE( std::begin(r2) == std::end(r2) );
+}
+
+TEST_CASE("repeat: doesn't duplicate item", "[repeat]") {
+    itertest::SolidInt si{2};
+    auto r = repeat(si);
+    auto it = std::begin(r);
+    (void)*it;
+}
+

From 4f2ace1890adb9e1ec613f19dee5a74142e5bc92 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 19 Jan 2015 22:16:12 -0500
Subject: [PATCH 0772/1866] simplifies repeat iter ==

---
 repeat.hpp | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/repeat.hpp b/repeat.hpp
index 749972d0..03ecadce 100644
--- a/repeat.hpp
+++ b/repeat.hpp
@@ -64,12 +64,11 @@ namespace iter {
                     }
 
                     bool operator!=(const Iterator& other) const {
-                        return this->count != other.count ||
-                            this->elem != other.elem;
+                        return !(*this == other);
                     }
 
                     bool operator==(const Iterator& other) const {
-                        return !(*this != other);
+                        return this->count == other.count;
                     }
 
                     T& operator*() {

From 24709fe0e8659081082ada9c5dfe55841e0eb1f2 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 20 Jan 2015 14:27:44 -0500
Subject: [PATCH 0773/1866] reversed iter inherits from std::iterator

---
 reversed.hpp | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/reversed.hpp b/reversed.hpp
index dd7a0cc2..483a9ebb 100644
--- a/reversed.hpp
+++ b/reversed.hpp
@@ -28,7 +28,10 @@ namespace iter {
 
         public:
             Reverser(const Reverser&) = default;
-            class Iterator {
+            class Iterator : public std::iterator<
+                         std::input_iterator_tag,
+                         iterator_traits_deref<Container>>
+            {
                 private:
                     reverse_iterator_type<Container> sub_iter;
                 public:
@@ -60,7 +63,6 @@ namespace iter {
 
     };
 
-    // Helper function to instantiate a Reverser
     template <typename Container>
     Reverser<Container> reversed(Container&& container) {
         return {std::forward<Container>(container)};
@@ -76,8 +78,6 @@ namespace iter {
     class Reverser<T[N]> {
         private:
             T *array;
-            // The reversed function is the only thing allowed to create a
-            // Reverser
             friend Reverser reversed<T, N>(T (&)[N]);
             
             // Value constructor for use only in the reversed function
@@ -89,7 +89,8 @@ namespace iter {
 
         public:
             Reverser(const Reverser&) = default;
-            class Iterator {
+            class Iterator : public std::iterator<std::input_iterator_tag, T>
+            {
                 private:
                     T *sub_iter;
                 public:

From 3d9012f5460cb3fd5e6723e7ee22b998b01c31f3 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 20 Jan 2015 14:29:04 -0500
Subject: [PATCH 0774/1866] adds reversed iter == and postfix ++

---
 reversed.hpp | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/reversed.hpp b/reversed.hpp
index 483a9ebb..7563b898 100644
--- a/reversed.hpp
+++ b/reversed.hpp
@@ -48,9 +48,19 @@ namespace iter {
                         return *this;
                     }
 
+                    Iterator operator++(int) {
+                        auto ret = *this;
+                        ++*this;
+                        return ret;
+                    }
+
                     bool operator!=(const Iterator& other) const {
                         return this->sub_iter != other.sub_iter;
                     }
+
+                    bool operator==(const Iterator& other) const {
+                        return !(*this != other);
+                    }
             };
 
             Iterator begin() {
@@ -107,9 +117,19 @@ namespace iter {
                         return *this;
                     }
 
+                    Iterator operator++(int) {
+                        auto ret = *this;
+                        ++*this;
+                        return ret;
+                    }
+
                     bool operator!=(const Iterator& other) const {
                         return this->sub_iter != other.sub_iter;
                     }
+
+                    bool operator==(const Iterator& other) const {
+                        return !(*this != other);
+                    }
             };
 
             Iterator begin() {

From aa4b3738a18c51c36fe29c25af8e13aa85083a01 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 20 Jan 2015 14:29:26 -0500
Subject: [PATCH 0775/1866] tests simple reversed

---
 catchtest/test_reversed.cpp | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 catchtest/test_reversed.cpp

diff --git a/catchtest/test_reversed.cpp b/catchtest/test_reversed.cpp
new file mode 100644
index 00000000..9388592a
--- /dev/null
+++ b/catchtest/test_reversed.cpp
@@ -0,0 +1,20 @@
+#include <reversed.hpp>
+
+#include <vector>
+#include <string>
+
+#include "helpers.hpp"
+#include "catch.hpp"
+
+using iter::reversed;
+using Vec = const std::vector<int>;
+
+TEST_CASE("Reversing a vector", "[reversed]") {
+    Vec ns = {10, 20, 30, 40};
+    auto r = reversed(ns);
+
+    Vec v(std::begin(r), std::end(r));
+    Vec vc = {40, 30, 20, 10};
+
+    REQUIRE( v == vc );
+}

From 4c9bd101d9b5e0149f55ce91649e6c810ed75c42 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 20 Jan 2015 14:29:44 -0500
Subject: [PATCH 0776/1866] builds reversed test

---
 catchtest/SConstruct | 1 +
 1 file changed, 1 insertion(+)

diff --git a/catchtest/SConstruct b/catchtest/SConstruct
index 62765a99..6192441a 100644
--- a/catchtest/SConstruct
+++ b/catchtest/SConstruct
@@ -34,6 +34,7 @@ progs = Split(
     powerset
     product
     repeat
+    reversed
     '''
 )
 

From f01bb1b69062d79923c636386e7b405bed79fb85 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 20 Jan 2015 14:33:13 -0500
Subject: [PATCH 0777/1866] tests reversed with array

---
 catchtest/test_reversed.cpp | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/catchtest/test_reversed.cpp b/catchtest/test_reversed.cpp
index 9388592a..2c16591f 100644
--- a/catchtest/test_reversed.cpp
+++ b/catchtest/test_reversed.cpp
@@ -9,7 +9,7 @@
 using iter::reversed;
 using Vec = const std::vector<int>;
 
-TEST_CASE("Reversing a vector", "[reversed]") {
+TEST_CASE("reversed: can reverse a vector", "[reversed]") {
     Vec ns = {10, 20, 30, 40};
     auto r = reversed(ns);
 
@@ -18,3 +18,13 @@ TEST_CASE("Reversing a vector", "[reversed]") {
 
     REQUIRE( v == vc );
 }
+
+TEST_CASE("reversed: can reverse an array", "[reversed]") {
+    int ns[] = {10, 20, 30, 40};
+    auto r = reversed(ns);
+
+    Vec v(std::begin(r), std::end(r));
+    Vec vc = {40, 30, 20, 10};
+
+    REQUIRE( v == vc );
+}

From c191ef881658da60e2731daa516e66e646a83170 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 20 Jan 2015 14:34:59 -0500
Subject: [PATCH 0778/1866] tests reversed with empy vector

---
 catchtest/test_reversed.cpp | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/catchtest/test_reversed.cpp b/catchtest/test_reversed.cpp
index 2c16591f..669f2bb2 100644
--- a/catchtest/test_reversed.cpp
+++ b/catchtest/test_reversed.cpp
@@ -28,3 +28,10 @@ TEST_CASE("reversed: can reverse an array", "[reversed]") {
 
     REQUIRE( v == vc );
 }
+
+TEST_CASE("reversed: empty when iterable is empty", "[reversed]") {
+    Vec emp{};
+    auto r = reversed(emp);
+    REQUIRE( std::begin(r) == std::end(r) );
+}
+

From 34eb516bb4f4aea8c07e25dad27240fc9b0471d4 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 20 Jan 2015 14:44:04 -0500
Subject: [PATCH 0779/1866] tests that reversed binds and moves correctly

---
 catchtest/test_reversed.cpp | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/catchtest/test_reversed.cpp b/catchtest/test_reversed.cpp
index 669f2bb2..5b9e0360 100644
--- a/catchtest/test_reversed.cpp
+++ b/catchtest/test_reversed.cpp
@@ -2,6 +2,7 @@
 
 #include <vector>
 #include <string>
+#include <utility>
 
 #include "helpers.hpp"
 #include "catch.hpp"
@@ -35,3 +36,12 @@ TEST_CASE("reversed: empty when iterable is empty", "[reversed]") {
     REQUIRE( std::begin(r) == std::end(r) );
 }
 
+TEST_CASE("reversed: moves rvalues and binds to lvalues", "[reversed]") {
+    itertest::BasicIterable<int> bi{1, 2};
+    itertest::BasicIterable<int> bi2{1, 2};
+    reversed(bi);
+    REQUIRE_FALSE( bi.was_moved_from() );
+
+    reversed(std::move(bi2));
+    REQUIRE( bi2.was_moved_from() );
+}

From 72caaafff0d2754e3c9bf7d4d80b48befe2004e4 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 20 Jan 2015 14:44:30 -0500
Subject: [PATCH 0780/1866] tests that reversed doesn't move or copy elements

---
 catchtest/test_reversed.cpp | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/catchtest/test_reversed.cpp b/catchtest/test_reversed.cpp
index 5b9e0360..2fc2adc6 100644
--- a/catchtest/test_reversed.cpp
+++ b/catchtest/test_reversed.cpp
@@ -1,6 +1,7 @@
 #include <reversed.hpp>
 
 #include <vector>
+#include <array>
 #include <string>
 #include <utility>
 
@@ -45,3 +46,17 @@ TEST_CASE("reversed: moves rvalues and binds to lvalues", "[reversed]") {
     reversed(std::move(bi2));
     REQUIRE( bi2.was_moved_from() );
 }
+
+TEST_CASE("reversed: doesn't move or copy elements of array", "[reversed]") {
+    constexpr itertest::SolidInt arr[] = {{6}, {7}, {8}};
+    for (auto&& i : reversed(arr)) {
+        (void)i;
+    }
+}
+
+TEST_CASE("reversed: with iterable doesn't move or copy elems", "[reversed]") {
+    constexpr std::array<itertest::SolidInt, 3> arr{{{6}, {7}, {8}}};
+    for (auto&& i : reversed(arr)) {
+        (void)i;
+    }
+}

From 0bf0d1a881143ccf9c6648beff3cdbd7c8ba3e0e Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 21 Jan 2015 23:16:59 -0500
Subject: [PATCH 0781/1866] adds basic sliding_window test

---
 catchtest/test_sliding_window.cpp | 41 +++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 catchtest/test_sliding_window.cpp

diff --git a/catchtest/test_sliding_window.cpp b/catchtest/test_sliding_window.cpp
new file mode 100644
index 00000000..f3de1cd4
--- /dev/null
+++ b/catchtest/test_sliding_window.cpp
@@ -0,0 +1,41 @@
+#include <sliding_window.hpp>
+
+#include <vector>
+#include <array>
+#include <string>
+#include <utility>
+
+#include "helpers.hpp"
+#include "catch.hpp"
+
+using iter::sliding_window;
+using Vec = const std::vector<int>;
+
+TEST_CASE("sliding_window: window of size 3", "[sliding_window]") {
+    Vec ns = { 10, 20, 30, 40, 50};
+    auto sw = sliding_window(ns, 3);
+    auto it = std::begin(sw);
+    REQUIRE( it != std::end(sw) );
+    {
+        Vec v(std::begin(*it), std::end(*it));
+        Vec vc = {10, 20, 30};
+        REQUIRE( v == vc );
+
+    }
+    ++it;
+    REQUIRE( it != std::end(sw) );
+    {
+        Vec v(std::begin(*it), std::end(*it));
+        Vec vc = {20, 30, 40};
+        REQUIRE( v == vc );
+    }
+    ++it;
+    REQUIRE( it != std::end(sw) );
+    {
+        Vec v(std::begin(*it), std::end(*it));
+        Vec vc = {30, 40, 50};
+        REQUIRE( v == vc );
+    }
+    ++it;
+    REQUIRE( !(it != std::end(sw)) );
+}

From ec7cbc89900335f3c0bb6c39710d81f533d65f79 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Thu, 22 Jan 2015 00:10:20 -0500
Subject: [PATCH 0782/1866] adds test with oversides window

---
 catchtest/test_sliding_window.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/catchtest/test_sliding_window.cpp b/catchtest/test_sliding_window.cpp
index f3de1cd4..2d67d2d8 100644
--- a/catchtest/test_sliding_window.cpp
+++ b/catchtest/test_sliding_window.cpp
@@ -39,3 +39,9 @@ TEST_CASE("sliding_window: window of size 3", "[sliding_window]") {
     ++it;
     REQUIRE( !(it != std::end(sw)) );
 }
+
+TEST_CASE("sliding window: oversized window is empty", "[sliding_window]") {
+    Vec ns = {10, 20, 30};
+    auto sw = sliding_window(ns, 5);
+    REQUIRE( !(std::begin(sw) != std::end(sw)) );
+}

From 5a0798b3ff26c2234b25deca2e44d0abf2808957 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 23 Jan 2015 21:40:05 -0500
Subject: [PATCH 0783/1866] adds sliding_window test with max window size

---
 catchtest/test_sliding_window.cpp | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/catchtest/test_sliding_window.cpp b/catchtest/test_sliding_window.cpp
index 2d67d2d8..75775985 100644
--- a/catchtest/test_sliding_window.cpp
+++ b/catchtest/test_sliding_window.cpp
@@ -45,3 +45,16 @@ TEST_CASE("sliding window: oversized window is empty", "[sliding_window]") {
     auto sw = sliding_window(ns, 5);
     REQUIRE( !(std::begin(sw) != std::end(sw)) );
 }
+
+TEST_CASE("sliding window: window size == len(iterable)", "[sliding_window]") {
+    Vec ns = {10, 20, 30};
+    auto sw = sliding_window(ns, 3);
+    auto it = std::begin(sw);
+    REQUIRE( it != std::end(sw) );
+
+    Vec v(std::begin(*it), std::end(*it));
+
+    REQUIRE( ns == v );
+    ++it;
+    REQUIRE_FALSE( it != std::end(sw) );
+}

From f7bbecaf2d66bda8b7a6158c07d01bf47e841816 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 23 Jan 2015 21:48:00 -0500
Subject: [PATCH 0784/1866] adds sliding_window test with window size of 1

---
 catchtest/test_sliding_window.cpp | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/catchtest/test_sliding_window.cpp b/catchtest/test_sliding_window.cpp
index 75775985..c8df3fb1 100644
--- a/catchtest/test_sliding_window.cpp
+++ b/catchtest/test_sliding_window.cpp
@@ -58,3 +58,22 @@ TEST_CASE("sliding window: window size == len(iterable)", "[sliding_window]") {
     ++it;
     REQUIRE_FALSE( it != std::end(sw) );
 }
+
+TEST_CASE("sliding window: empty iterable is empty", "[sliding_window]") {
+    Vec ns{};
+    auto sw = sliding_window(ns, 1);
+    REQUIRE_FALSE( std::begin(sw) != std::end(sw) );
+}
+
+TEST_CASE("sliding window: window size of 1", "[sliding_window]") {
+    Vec ns = {10, 20, 30};
+    auto sw = sliding_window(ns, 1);
+    auto it = std::begin(sw);
+    REQUIRE( *std::begin(*it) == 10 );
+    ++it;
+    REQUIRE( *std::begin(*it) == 20 );
+    ++it;
+    REQUIRE( *std::begin(*it) == 30 );
+    ++it;
+    REQUIRE_FALSE( it != std::end(sw) );
+}

From 220fa3ade478d0976b66c08ba7762751bc5f6e44 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 23 Jan 2015 21:52:38 -0500
Subject: [PATCH 0785/1866] sliding window lazily consumes iterable

---
 sliding_window.hpp | 83 +++++++++++++++++++---------------------------
 1 file changed, 35 insertions(+), 48 deletions(-)

diff --git a/sliding_window.hpp b/sliding_window.hpp
index 202191f1..1b9fb454 100644
--- a/sliding_window.hpp
+++ b/sliding_window.hpp
@@ -1,12 +1,9 @@
-#ifndef SLIDING_WINDOW_HPP_
-#define SLIDING_WINDOW_HPP_
+#ifndef ITER_SLIDING_WINDOW_HPP_
+#define ITER_SLIDING_WINDOW_HPP_
 
 #include "iterbase.hpp"
 
-#include <vector>
-#include <algorithm>
-#include <functional>
-#include <type_traits>
+#include <deque>
 #include <utility>
 #include <iterator>
 
@@ -23,8 +20,7 @@ namespace iter {
 
     template <typename Container>
     class SlidingWindow {
-        private:
-            Container container;
+        private: Container container;
             std::size_t window_size;
 
             friend SlidingWindow sliding_window<Container>(
@@ -43,62 +39,53 @@ namespace iter {
 
             class Iterator {
                 private:
-                    // confusing, but, just makes the type of the vector
-                    // returned by operator*()
-                    using OpDerefElemType =
-                        std::reference_wrapper<
-                            typename std::remove_reference<
-                                iterator_deref<Container>>::type>;
-                    using DerefVec = std::vector<OpDerefElemType>;
-
-                    std::vector<iterator_type<Container>> section;
-                    std::size_t section_size = 0;
+                    // TODO move defs outside and subclass std::iterator
+                    using OpDerefElemType = collection_item_type<Container>;
+                    using DerefVec = std::deque<OpDerefElemType>;
+                    
+                    iterator_type<Container> sub_iter;
+                    DerefVec window;
 
                 public:
-                    Iterator(Container& container, std::size_t s)
-                        : section_size{s}
+                    Iterator(const iterator_type<Container>& in_iter,
+                            const iterator_type<Container>& in_end,
+                             std::size_t window_sz)
+                        : sub_iter(in_iter)
                     {
-                        auto iter = std::begin(container);
-                        auto end = std::end(container);
-                        for (std::size_t i = 0;
-                                i < section_size && iter != end;
-                                ++iter, ++i) {
-                            section.push_back(iter);
+                        std::size_t i{0};
+                        while (i < window_sz && this->sub_iter != in_end) {
+                            this->window.push_back(*this->sub_iter);
+                            ++i;
+                            if (i != window_sz) ++this->sub_iter;
                         }
                     }
 
-                    // for the end iter
-                    Iterator(Container& container)
-                        : section{std::end(container)},
-                        section_size{0}
-                    { }
-
-                    Iterator& operator++() {
-                        for (auto&& iter : this->section) {
-                            ++iter;
-                        }
-                        return *this;
+                    bool operator!=(const Iterator& other) const {
+                        return this->sub_iter != other.sub_iter;
                     }
 
-                    bool operator!=(const Iterator& rhs) const {
-                       return this->section.back() != rhs.section.back();
+                    DerefVec& operator*() {
+                        return this->window;
                     }
 
-                    DerefVec operator*() {
-                        DerefVec vec;
-                        for (auto&& iter : this->section) {
-                            vec.push_back(*iter);
-                        }
-                        return vec;
+                    Iterator& operator++() {
+                        ++this->sub_iter;
+                        this->window.pop_front();
+                        this->window.push_back(*this->sub_iter);
+                        return *this;
                     }
             };
 
             Iterator begin() {
-                return {container, window_size};
+                return {std::begin(container),
+                    std::end(container),
+                    window_size};
             }
 
             Iterator end() {
-                return {container};
+                return {std::end(container),
+                    std::end(container),
+                    window_size};
             }
     };
 
@@ -115,4 +102,4 @@ namespace iter {
     }
 }
 
-#endif //SLIDING_WINDOW_HPP_
+#endif

From ea81df388a0be484b673f6cbbbb00732689cdf2b Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 23 Jan 2015 21:52:54 -0500
Subject: [PATCH 0786/1866] builds sliding_window catch test

---
 catchtest/SConstruct | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/catchtest/SConstruct b/catchtest/SConstruct
index 6192441a..aebe1c81 100644
--- a/catchtest/SConstruct
+++ b/catchtest/SConstruct
@@ -35,6 +35,8 @@ progs = Split(
     product
     repeat
     reversed
+
+    sliding_window
     '''
 )
 

From a6c67fff651749d933bfefd519fbf42e2332c168 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 23 Jan 2015 21:57:37 -0500
Subject: [PATCH 0787/1866] sliding_window iter inherits from std::iterator

---
 sliding_window.hpp | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/sliding_window.hpp b/sliding_window.hpp
index 1b9fb454..fec4052e 100644
--- a/sliding_window.hpp
+++ b/sliding_window.hpp
@@ -35,14 +35,13 @@ namespace iter {
                 window_size{win_sz}
             { }
 
+            using DerefVec = std::deque<collection_item_type<Container>>;
         public:
 
-            class Iterator {
+            class Iterator
+                : public std::iterator<std::input_iterator_tag, DerefVec>
+            {
                 private:
-                    // TODO move defs outside and subclass std::iterator
-                    using OpDerefElemType = collection_item_type<Container>;
-                    using DerefVec = std::deque<OpDerefElemType>;
-                    
                     iterator_type<Container> sub_iter;
                     DerefVec window;
 

From 67f4f417b9112a8fc04a70f977d1592e76fd6b44 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 23 Jan 2015 21:58:54 -0500
Subject: [PATCH 0788/1866] adds sliding_window iter postfix ++

---
 sliding_window.hpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/sliding_window.hpp b/sliding_window.hpp
index fec4052e..63b573bf 100644
--- a/sliding_window.hpp
+++ b/sliding_window.hpp
@@ -73,6 +73,12 @@ namespace iter {
                         this->window.push_back(*this->sub_iter);
                         return *this;
                     }
+
+                    Iterator operator++(int) {
+                        auto ret = *this;
+                        ++*this;
+                        return ret;
+                    }
             };
 
             Iterator begin() {

From 29f69b5c731f701104344f3ce8418d424e1a8af8 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 23 Jan 2015 22:00:00 -0500
Subject: [PATCH 0789/1866] adds sliding_window iter ==

---
 sliding_window.hpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/sliding_window.hpp b/sliding_window.hpp
index 63b573bf..da22946d 100644
--- a/sliding_window.hpp
+++ b/sliding_window.hpp
@@ -63,6 +63,10 @@ namespace iter {
                         return this->sub_iter != other.sub_iter;
                     }
 
+                    bool operator==(const Iterator& other) const {
+                        return !(*this != other);
+                    }
+
                     DerefVec& operator*() {
                         return this->window;
                     }

From 83e28b68ba1082bed0b925c5d767c7c59bb00a9d Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 23 Jan 2015 22:21:40 -0500
Subject: [PATCH 0790/1866] tests sliding_window with window size of 1

---
 catchtest/test_sliding_window.cpp | 16 +++++++++++-----
 1 file changed, 11 insertions(+), 5 deletions(-)

diff --git a/catchtest/test_sliding_window.cpp b/catchtest/test_sliding_window.cpp
index c8df3fb1..107e89c9 100644
--- a/catchtest/test_sliding_window.cpp
+++ b/catchtest/test_sliding_window.cpp
@@ -37,13 +37,13 @@ TEST_CASE("sliding_window: window of size 3", "[sliding_window]") {
         REQUIRE( v == vc );
     }
     ++it;
-    REQUIRE( !(it != std::end(sw)) );
+    REQUIRE( it == std::end(sw) );
 }
 
 TEST_CASE("sliding window: oversized window is empty", "[sliding_window]") {
     Vec ns = {10, 20, 30};
     auto sw = sliding_window(ns, 5);
-    REQUIRE( !(std::begin(sw) != std::end(sw)) );
+    REQUIRE( std::begin(sw) == std::end(sw) );
 }
 
 TEST_CASE("sliding window: window size == len(iterable)", "[sliding_window]") {
@@ -56,13 +56,13 @@ TEST_CASE("sliding window: window size == len(iterable)", "[sliding_window]") {
 
     REQUIRE( ns == v );
     ++it;
-    REQUIRE_FALSE( it != std::end(sw) );
+    REQUIRE( it == std::end(sw) );
 }
 
 TEST_CASE("sliding window: empty iterable is empty", "[sliding_window]") {
     Vec ns{};
     auto sw = sliding_window(ns, 1);
-    REQUIRE_FALSE( std::begin(sw) != std::end(sw) );
+    REQUIRE( std::begin(sw) == std::end(sw) );
 }
 
 TEST_CASE("sliding window: window size of 1", "[sliding_window]") {
@@ -75,5 +75,11 @@ TEST_CASE("sliding window: window size of 1", "[sliding_window]") {
     ++it;
     REQUIRE( *std::begin(*it) == 30 );
     ++it;
-    REQUIRE_FALSE( it != std::end(sw) );
+    REQUIRE( it == std::end(sw) );
+}
+
+TEST_CASE("sliding window: window size of 0", "[sliding_window]") {
+    Vec ns = {10, 20, 30};
+    auto sw = sliding_window(ns, 0);
+    REQUIRE( std::begin(sw) == std::end(sw) );
 }

From 9eb90cb46db7d217dfcb28c0bdc895f9a54e6cfc Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Fri, 23 Jan 2015 22:23:02 -0500
Subject: [PATCH 0791/1866] handles window size of 0

---
 sliding_window.hpp | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/sliding_window.hpp b/sliding_window.hpp
index da22946d..48d4ca1c 100644
--- a/sliding_window.hpp
+++ b/sliding_window.hpp
@@ -86,15 +86,18 @@ namespace iter {
             };
 
             Iterator begin() {
-                return {std::begin(container),
-                    std::end(container),
-                    window_size};
+                return {
+                    (this->window_size != 0 ?
+                     std::begin(this->container)
+                     : std::end(this->container)),
+                    std::end(this->container),
+                    this->window_size};
             }
 
             Iterator end() {
-                return {std::end(container),
-                    std::end(container),
-                    window_size};
+                return {std::end(this->container),
+                    std::end(this->container),
+                    this->window_size};
             }
     };
 

From 01cbbf9fcb647e45722d8f5090c19d65de2a7ac9 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 24 Jan 2015 16:29:26 -0500
Subject: [PATCH 0792/1866] tests sliding window moves and binds correctly

---
 catchtest/test_sliding_window.cpp | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/catchtest/test_sliding_window.cpp b/catchtest/test_sliding_window.cpp
index 107e89c9..95d40f1b 100644
--- a/catchtest/test_sliding_window.cpp
+++ b/catchtest/test_sliding_window.cpp
@@ -83,3 +83,12 @@ TEST_CASE("sliding window: window size of 0", "[sliding_window]") {
     auto sw = sliding_window(ns, 0);
     REQUIRE( std::begin(sw) == std::end(sw) );
 }
+
+TEST_CASE("sliding window: moves rvalues and binds to lvalues",
+        "[sliding_window]") {
+    itertest::BasicIterable<int> bi{1, 2};
+    sliding_window(bi, 1);
+    REQUIRE_FALSE( bi.was_moved_from() );
+    sliding_window(std::move(bi), 1);
+    REQUIRE( bi.was_moved_from() );
+}

From 72a49e62da541c830411ece6323a30829639615e Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 24 Jan 2015 16:31:59 -0500
Subject: [PATCH 0793/1866] tests sliding window doesn't copy elements

---
 catchtest/test_sliding_window.cpp | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/catchtest/test_sliding_window.cpp b/catchtest/test_sliding_window.cpp
index 95d40f1b..3bcd0878 100644
--- a/catchtest/test_sliding_window.cpp
+++ b/catchtest/test_sliding_window.cpp
@@ -92,3 +92,10 @@ TEST_CASE("sliding window: moves rvalues and binds to lvalues",
     sliding_window(std::move(bi), 1);
     REQUIRE( bi.was_moved_from() );
 }
+
+TEST_CASE("sliding window: doesn't copy elements", "[sliding_window]") {
+    constexpr std::array<itertest::SolidInt, 3> arr{{{6}, {7}, {8}}};
+    for (auto&& i : sliding_window(arr, 1)) {
+        (void)*std::begin(i);
+    }
+}

From 733bfa598c4bc80b79b8d7a1f1418bf1d7a95a5a Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 24 Jan 2015 16:55:26 -0500
Subject: [PATCH 0794/1866] basic takewhile test

---
 catchtest/test_takewhile.cpp | 35 +++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 catchtest/test_takewhile.cpp

diff --git a/catchtest/test_takewhile.cpp b/catchtest/test_takewhile.cpp
new file mode 100644
index 00000000..9b92b9ab
--- /dev/null
+++ b/catchtest/test_takewhile.cpp
@@ -0,0 +1,35 @@
+#include <takewhile.hpp>
+
+#include <vector>
+#include <array>
+#include <string>
+#include <utility>
+
+#include "helpers.hpp"
+#include "catch.hpp"
+
+using iter::takewhile;
+using Vec = const std::vector<int>;
+
+
+namespace {
+    bool under_ten(int i) {
+        return i < 10;
+    }
+
+    struct UnderTen {
+        bool operator()(int i) {
+            return i < 10;
+        }
+    };
+}
+
+TEST_CASE("takewhile: works with lambda, callable, and function pointer",
+        "[takewhile]") {
+    Vec ns = {1, 3, 5, 20, 2, 4, 6, 8};
+    SECTION("function pointer") {
+        auto tw = takewhile(under_ten, ns);
+        Vec v(std::begin(tw), std::end(tw));
+
+    }
+}

From 5356ce0499adb10d7447185498e22212be29d618 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 24 Jan 2015 16:55:37 -0500
Subject: [PATCH 0795/1866] takewhile iter inherits from std iterator

---
 takewhile.hpp | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/takewhile.hpp b/takewhile.hpp
index 528f6fb0..5447f791 100644
--- a/takewhile.hpp
+++ b/takewhile.hpp
@@ -1,5 +1,5 @@
-#ifndef TAKEWHILE__H__
-#define TAKEWHILE__H__
+#ifndef ITER_TAKEWHILE_H_
+#define ITER_TAKEWHILE_H_
 
 #include "iterbase.hpp"
 
@@ -39,13 +39,13 @@ namespace iter {
                 filter_func(filter_func)
             { }
 
-            TakeWhile () = delete;
-            TakeWhile& operator=(const TakeWhile&) = delete;
 
         public:
-            TakeWhile(const TakeWhile&) = default;
 
-            class Iterator {
+            class Iterator 
+                : public std::iterator<std::input_iterator_tag,
+                    iterator_traits_deref<Container>>
+            {
                 private:
                     using iter_type = iterator_type<Container>;
                     iterator_type<Container> sub_iter;
@@ -123,4 +123,4 @@ namespace iter {
 
 }
 
-#endif //ifndef TAKEWHILE__H__
+#endif

From c459de9e517d8563fddaf01dbde0f05621faa201 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 24 Jan 2015 16:58:50 -0500
Subject: [PATCH 0796/1866] actually basic tests takewhile

---
 catchtest/test_takewhile.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/catchtest/test_takewhile.cpp b/catchtest/test_takewhile.cpp
index 9b92b9ab..35bb40c6 100644
--- a/catchtest/test_takewhile.cpp
+++ b/catchtest/test_takewhile.cpp
@@ -30,6 +30,7 @@ TEST_CASE("takewhile: works with lambda, callable, and function pointer",
     SECTION("function pointer") {
         auto tw = takewhile(under_ten, ns);
         Vec v(std::begin(tw), std::end(tw));
-
+        Vec vc = {1, 3, 5};
+        REQUIRE( v == vc );
     }
 }

From e422b8ae63fa87e6a7d17e4c394b6ad8490437a9 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 24 Jan 2015 17:00:45 -0500
Subject: [PATCH 0797/1866] tests takewhile with different functor types

---
 catchtest/test_takewhile.cpp | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/catchtest/test_takewhile.cpp b/catchtest/test_takewhile.cpp
index 35bb40c6..58a1bc52 100644
--- a/catchtest/test_takewhile.cpp
+++ b/catchtest/test_takewhile.cpp
@@ -33,4 +33,18 @@ TEST_CASE("takewhile: works with lambda, callable, and function pointer",
         Vec vc = {1, 3, 5};
         REQUIRE( v == vc );
     }
+
+    SECTION("callable object") {
+        auto tw = takewhile(UnderTen{}, ns);
+        Vec v(std::begin(tw), std::end(tw));
+        Vec vc = {1, 3, 5};
+        REQUIRE( v == vc );
+    }
+
+    SECTION("lambda") {
+        auto tw = takewhile([](int i){ return i < 10; }, ns);
+        Vec v(std::begin(tw), std::end(tw));
+        Vec vc = {1, 3, 5};
+        REQUIRE( v == vc );
+    }
 }

From 111057d59e70e571ffb361cb2aa44f0ef18220f0 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 24 Jan 2015 17:01:22 -0500
Subject: [PATCH 0798/1866] removes placement new from takewhile

---
 takewhile.hpp | 12 +++---------
 1 file changed, 3 insertions(+), 9 deletions(-)

diff --git a/takewhile.hpp b/takewhile.hpp
index 5447f791..43ddc53d 100644
--- a/takewhile.hpp
+++ b/takewhile.hpp
@@ -49,18 +49,12 @@ namespace iter {
                 private:
                     using iter_type = iterator_type<Container>;
                     iterator_type<Container> sub_iter;
-                    const iterator_type<Container> sub_end;
+                    iterator_type<Container> sub_end;
                     FilterFunc filter_func;
 
-                    // check if the current value is true under the predicate
-                    // if it is not, set the sub_iter to the end using
-                    // placement new to avoid the requirement of the iterator
-                    // having an operator=
                     void check_current() {
                         if (!this->filter_func(*this->sub_iter)) {
-                            this->sub_iter.~iter_type();
-                            new(&this->sub_iter) iterator_type<Container>(
-                                    this->sub_end);
+                            this->sub_iter = this->sub_end;
                         }
                     }
 
@@ -78,7 +72,7 @@ namespace iter {
                         }
                     } 
 
-                    iterator_deref<Container> operator*() const {
+                    iterator_deref<Container> operator*() {
                         return *this->sub_iter;
                     }
 

From 4dfce4c6736c8f9b26f5dce7342fd93742b7e118 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 24 Jan 2015 17:02:50 -0500
Subject: [PATCH 0799/1866] adds takewhile iter postfix ++ and ==

---
 takewhile.hpp | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

diff --git a/takewhile.hpp b/takewhile.hpp
index 43ddc53d..ef8d5409 100644
--- a/takewhile.hpp
+++ b/takewhile.hpp
@@ -33,7 +33,6 @@ namespace iter {
             friend TakeWhile<FF, std::initializer_list<T>> takewhile(
                     FF, std::initializer_list<T>);
 
-            // Value constructor for use only in the takewhile function
             TakeWhile(FilterFunc filter_func, Container container)
                 : container(std::forward<Container>(container)),
                 filter_func(filter_func)
@@ -47,7 +46,6 @@ namespace iter {
                     iterator_traits_deref<Container>>
             {
                 private:
-                    using iter_type = iterator_type<Container>;
                     iterator_type<Container> sub_iter;
                     iterator_type<Container> sub_end;
                     FilterFunc filter_func;
@@ -59,7 +57,7 @@ namespace iter {
                     }
 
                 public:
-                    Iterator (iterator_type<Container> iter,
+                    Iterator(iterator_type<Container> iter,
                             iterator_type<Container> end,
                             FilterFunc filter_func)
                         : sub_iter{iter},
@@ -82,9 +80,20 @@ namespace iter {
                         return *this;
                     }
 
+                    Iterator operator++(int) {
+                        auto ret = *this;
+                        ++*this;
+                        return ret;
+                    }
+
                     bool operator!=(const Iterator& other) const {
                         return this->sub_iter != other.sub_iter;
                     }
+
+                    bool operator==(const Iterator& other) const {
+                        return !(*this != other);
+                    }
+                
             };
 
             Iterator begin() {
@@ -101,7 +110,6 @@ namespace iter {
 
     };
 
-    // Helper function to instantiate a TakeWhile
     template <typename FilterFunc, typename Container>
     TakeWhile<FilterFunc, Container> takewhile(
             FilterFunc filter_func, Container&& container) {

From fcbd18159b2c5772df0ad19bcd8192ad2bf56a7a Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 24 Jan 2015 17:06:14 -0500
Subject: [PATCH 0800/1866] tests takewhile with empty iterable

---
 catchtest/test_takewhile.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/catchtest/test_takewhile.cpp b/catchtest/test_takewhile.cpp
index 58a1bc52..ff3f42b5 100644
--- a/catchtest/test_takewhile.cpp
+++ b/catchtest/test_takewhile.cpp
@@ -48,3 +48,9 @@ TEST_CASE("takewhile: works with lambda, callable, and function pointer",
         REQUIRE( v == vc );
     }
 }
+
+TEST_CASE("takewhile: empty iterable is empty", "[takewhile]") {
+    Vec ns{};
+    auto tw = takewhile(under_ten, ns);
+    REQUIRE( std::begin(tw) == std::end(tw) );
+}

From 333b6743157b85771c88d15e86b8285e4256d7c2 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 24 Jan 2015 17:15:05 -0500
Subject: [PATCH 0801/1866] tests takewhile when first element fails predicate

---
 catchtest/test_takewhile.cpp | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/catchtest/test_takewhile.cpp b/catchtest/test_takewhile.cpp
index ff3f42b5..88d755ff 100644
--- a/catchtest/test_takewhile.cpp
+++ b/catchtest/test_takewhile.cpp
@@ -54,3 +54,20 @@ TEST_CASE("takewhile: empty iterable is empty", "[takewhile]") {
     auto tw = takewhile(under_ten, ns);
     REQUIRE( std::begin(tw) == std::end(tw) );
 }
+
+TEST_CASE("takewhile: when first element fails predicate, it's empty"
+        "[takewhile]") {
+    SECTION("First element is only element") {
+        Vec ns = {20};
+        auto tw = takewhile(under_ten, ns);
+        REQUIRE( std::begin(tw) == std::end(tw) );
+    }
+
+    SECTION("First element followed by elements that pass") {
+        Vec ns = {20, 1, 1};
+        auto tw = takewhile(under_ten, ns);
+        REQUIRE( std::begin(tw) == std::end(tw) );
+    }
+}
+
+        

From a0a17ba9c329e75a4819094cd3117721acf28d2f Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 24 Jan 2015 17:15:35 -0500
Subject: [PATCH 0802/1866] builds takewhile test

---
 catchtest/SConstruct | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/catchtest/SConstruct b/catchtest/SConstruct
index aebe1c81..4fac7a84 100644
--- a/catchtest/SConstruct
+++ b/catchtest/SConstruct
@@ -37,6 +37,8 @@ progs = Split(
     reversed
 
     sliding_window
+    
+    takewhile
     '''
 )
 

From 3c2696e7fb4eadd1aba60659a1dd8fe24cec9ef7 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 24 Jan 2015 17:17:49 -0500
Subject: [PATCH 0803/1866] tests that takewhile moves and binds correctly

---
 catchtest/test_takewhile.cpp | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/catchtest/test_takewhile.cpp b/catchtest/test_takewhile.cpp
index 88d755ff..80189737 100644
--- a/catchtest/test_takewhile.cpp
+++ b/catchtest/test_takewhile.cpp
@@ -70,4 +70,11 @@ TEST_CASE("takewhile: when first element fails predicate, it's empty"
     }
 }
 
-        
+TEST_CASE("takewhile: moves rvalues, binds to lvalues", "[takewhile]") {
+    itertest::BasicIterable<int> bi{1, 2};
+    takewhile(under_ten, bi);
+    REQUIRE_FALSE( bi.was_moved_from() );
+
+    takewhile(under_ten, std::move(bi));
+    REQUIRE( bi.was_moved_from() );
+}

From fe9af2178cde28f0a9e6bf91883c72a1adc705d0 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sat, 24 Jan 2015 17:21:46 -0500
Subject: [PATCH 0804/1866] tests that takewhile doesn't copy elements

---
 catchtest/test_takewhile.cpp | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/catchtest/test_takewhile.cpp b/catchtest/test_takewhile.cpp
index 80189737..9394d32c 100644
--- a/catchtest/test_takewhile.cpp
+++ b/catchtest/test_takewhile.cpp
@@ -78,3 +78,13 @@ TEST_CASE("takewhile: moves rvalues, binds to lvalues", "[takewhile]") {
     takewhile(under_ten, std::move(bi));
     REQUIRE( bi.was_moved_from() );
 }
+
+TEST_CASE("takewhile: with iterable doesn't move or copy elements",
+        "[takewhile]") {
+    constexpr std::array<itertest::SolidInt, 3> arr{{{6}, {7}, {8}}};
+    auto func =
+        [](const itertest::SolidInt& si){return si.getint() < 10;};
+    for (auto&& i : takewhile(func, arr)) {
+        (void)i;
+    }
+}

From 5f0cc36f275bcda0d510f7e26373932df4540be6 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 25 Jan 2015 21:18:49 -0500
Subject: [PATCH 0805/1866] tests range with floats

---
 catchtest/test_range.cpp | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/catchtest/test_range.cpp b/catchtest/test_range.cpp
index 9a0bee9e..8b4b0150 100644
--- a/catchtest/test_range.cpp
+++ b/catchtest/test_range.cpp
@@ -144,3 +144,12 @@ TEST_CASE("range: works with a variable start, stop, and step", "[range]") {
     }
 
 }
+
+using FVec = const std::vector<double>;
+
+TEST_CASE("range: using doubles", "[range]") {
+    auto r = range(5.0);
+    FVec fv(std::begin(r), std::end(r));
+    FVec fvc = {0.0, 1.0, 2.0, 3.0, 4.0};
+    REQUIRE( fv == fvc );
+}

From c3a9438418267ed99d33a3a9de3646b0e2e073b9 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 25 Jan 2015 21:34:14 -0500
Subject: [PATCH 0806/1866] adds float specific range tests

---
 catchtest/test_range.cpp | 37 +++++++++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)

diff --git a/catchtest/test_range.cpp b/catchtest/test_range.cpp
index 8b4b0150..fbf50298 100644
--- a/catchtest/test_range.cpp
+++ b/catchtest/test_range.cpp
@@ -153,3 +153,40 @@ TEST_CASE("range: using doubles", "[range]") {
     FVec fvc = {0.0, 1.0, 2.0, 3.0, 4.0};
     REQUIRE( fv == fvc );
 }
+
+TEST_CASE("range: using doubles with start and stop", "[range]") {
+    auto r = range(5.0, 10.0);
+    FVec fv(std::begin(r), std::end(r));
+    FVec fvc = {5.0, 6.0, 7.0, 8.0, 9.0};
+    REQUIRE( fv == fvc );
+}
+
+TEST_CASE("range: using doubles with start, stop and step", "[range]") {
+    auto r = range(1.0, 4.0, 0.5);
+    FVec fv(std::begin(r), std::end(r));
+    FVec fvc = {1.0, 1.5, 2.0, 2.5, 3.0, 3.5};
+    REQUIRE( fv == fvc );
+}
+
+TEST_CASE("range: using doubles with negative", "[range]") {
+    auto r = range(0.5, -2.0, -0.5);
+    FVec fv(std::begin(r), std::end(r));
+    FVec fvc = {0.5, 0.0, -0.5, -1.0, -1.5};
+    REQUIRE( fv == fvc );
+}
+
+TEST_CASE("range: using doubles with uneven step", "[range]") {
+    auto r = range(0.0, 1.75, 0.5);
+    FVec fv(std::begin(r), std::end(r));
+    FVec fvc = {0.0, 0.5, 1.0, 1.5};
+    REQUIRE( fv == fvc );
+}
+
+TEST_CASE("range: using doubles detects empty ranges", "[range]") {
+    auto r1 = range(0.0, -1.0);
+    REQUIRE(std::begin(r1) == std::end(r1));
+
+    auto r2 = range(0.0, 1.0, -1.0);
+    REQUIRE(std::begin(r2) == std::end(r2));
+}
+    

From f5302c90e5a72a51878df72c1096fc650d6ca881 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 25 Jan 2015 21:34:27 -0500
Subject: [PATCH 0807/1866] Divides range into float and non-float versions

Since repeatedly adding a value to a floating point number will
accumulate inaccuracies, a special version of Range was needed.  The
normal version is the same, but the float version will calculate the
current value on each increment using start + (steps_taken + step_size).
This will reduce the inaccuracies by preventing them from building up.
---
 range.hpp | 117 ++++++++++++++++++++++++++++++++++++++++++++----------
 1 file changed, 96 insertions(+), 21 deletions(-)

diff --git a/range.hpp b/range.hpp
index 6366e727..3ce9784c 100644
--- a/range.hpp
+++ b/range.hpp
@@ -23,27 +23,27 @@ namespace iter {
 
     // Thrown when step 0 occurs
     class RangeException : public std::exception {
-        virtual const char *what() const noexcept { 
+        const char *what() const noexcept override {
             return "range step must be non-zero";
         }
     };
 
-    //Forward declarations of Enumerable and enumerate
-    template <typename T>
+    template <typename T, bool IsFloat>
     class Range;
 
-    template <typename T>
-    Range<T> range(T);
-    template <typename T>
-    Range<T> range(T, T);
-    template <typename T>
-    Range<T> range(T, T, T);
+    template <typename T, bool IsFloat =std::is_floating_point<T>::value>
+    Range<T, IsFloat> range(T);
+    template <typename T, bool IsFloat =std::is_floating_point<T>::value>
+    Range<T, IsFloat> range(T, T);
+    template <typename T, bool IsFloat =std::is_floating_point<T>::value>
+    Range<T, IsFloat> range(T, T, T);
 
+    // General version for everything not a float
     template <typename T>
-    class Range {
-        friend Range range<T>(T);
-        friend Range range<T>(T, T);
-        friend Range range<T>(T, T, T);
+    class Range<T, false> {
+        friend Range range<T, false>(T);
+        friend Range range<T, false>(T, T);
+        friend Range range<T, false>(T, T, T);
         private:
             const T start; 
             const T stop;
@@ -62,8 +62,6 @@ namespace iter {
             { }
 
         public:
-            Range() = delete;
-            Range(const Range&) = default;
             class Iterator
                 : public std::iterator<std::input_iterator_tag, T>
             {
@@ -140,19 +138,96 @@ namespace iter {
             }
     };
 
-
+    // This specialization is used for floating point types.  Instead of
+    // adding one "step" each time ++ is called on the iterator, the value
+    // is recalculated as start + (steps_taken + step_size) to avoid
+    // accumulating floating point inaccuracies 
     template <typename T>
-    Range<T> range(T stop) {
+    class Range<T, true> {
+        friend Range range<T, true>(T);
+        friend Range range<T, true>(T, T);
+        friend Range range<T, true>(T, T, T);
+        private:
+            const T start; 
+            const T stop;
+            const T step;
+
+            Range(T stop)
+                : start{0},
+                stop{stop},
+                step{1}
+            { }
+
+            Range(T start, T stop, T step =1)
+                : start{start},
+                stop{stop},
+                step{step}
+            { }
+        public:
+            class Iterator
+                : public std::iterator<std::input_iterator_tag, T>
+            {
+                private:
+                    T start;
+                    T value;
+                    T step;
+                    unsigned long steps_taken =0;
+
+                public:
+                    Iterator(T start, T step)
+                        : start{start},
+                        value{start},
+                        step{step}
+                    { }
+
+                    bool operator!=(const Iterator& other) const {
+                        return !(this->step > 0 && this->value >= other.value) 
+                            && !(this->step < 0 && this->value <= other.value);
+                    }
+
+                    bool operator==(const Iterator& other) const {
+                        return !(*this != other);
+                    }
+
+                    T operator*() const {
+                        return this->value;
+                    }
+
+                    Iterator& operator++() {
+                        ++this->steps_taken;
+                        this->value = this->start +
+                            (this->step * this->steps_taken);
+                        return *this;
+                    }
+
+                    Iterator operator++(int) {
+                        auto ret = *this;
+                        ++*this;
+                        return ret;
+                    }
+            };
+
+            Iterator begin() const {
+                return {start, step};
+            }
+
+            Iterator end() const { 
+                return {stop, step};
+            }
+    };
+
+    template <typename T, bool IsFloat>
+    Range<T, IsFloat> range(T stop) {
         return {stop};
     }
 
-    template <typename T>
-    Range<T> range(T start, T stop) {
+    template <typename T, bool IsFloat>
+    Range<T, IsFloat> range(T start, T stop) {
         return {start, stop};
     }
 
-    template <typename T>
-    Range<T> range(T start, T stop, T step) {
+    template <typename T, bool IsFloat>
+    Range<T, IsFloat> range(T start, T stop, T step) {
         if (step == 0) {
             throw RangeException{};
         }

From 567121d8dc914a68df3d118073563b67caf128f8 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 25 Jan 2015 21:36:13 -0500
Subject: [PATCH 0808/1866] count deduces return type

---
 count.hpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/count.hpp b/count.hpp
index 579edceb..e0bc7cd0 100644
--- a/count.hpp
+++ b/count.hpp
@@ -9,13 +9,13 @@ namespace iter {
 
     using DefaultRangeType = long;
 
-    Range<DefaultRangeType> count() {
+    auto count() -> decltype(range(DefaultRangeType(0), DefaultRangeType(0))) {
         return range(DefaultRangeType(0),
                 std::numeric_limits<DefaultRangeType>::max());
     }
 
     template <typename T>
-    Range<T> count(T start, T step) {
+    auto count(T start, T step) -> decltype(range(start, start, start)) {
         // if step is < 0, set the stop to numeric min, otherwise numeric max
         T stop = step < T(0) ? std::numeric_limits<T>::min() :
                             std::numeric_limits<T>::max();
@@ -23,7 +23,7 @@ namespace iter {
     }
 
     template <typename T>
-    Range<T> count(T start) {
+    auto count(T start) -> decltype(range(start, start)) {
         return count(start, T(1));
     }
 }

From a4298d665a52e7ea1d19b95e015c9b6ca8eb5bf3 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 26 Jan 2015 14:47:33 -0500
Subject: [PATCH 0809/1866] removes reference in imap iterator_traits

---
 imap.hpp | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/imap.hpp b/imap.hpp
index ef0727fd..9df55a1a 100644
--- a/imap.hpp
+++ b/imap.hpp
@@ -87,15 +87,11 @@ namespace iter {
                 map_func(map_func),
                 zipped(zip(std::forward<Containers>(containers)...))
             { }
-            IMap() = delete;
-            IMap& operator=(const IMap&) = delete;
 
         public:
-            IMap(const IMap&) = default;
-            IMap(IMap&&) = default;
-
             class Iterator 
-                : public std::iterator<std::input_iterator_tag, IMapIterDeref>
+                : public std::iterator<std::input_iterator_tag,
+                    typename std::remove_reference<IMapIterDeref>::type >
             {
                 private:
                     MapFunc map_func;

From 4df5e5a37f4a0fa688aeb7a6b8d02a49a10e1c42 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 26 Jan 2015 14:53:07 -0500
Subject: [PATCH 0810/1866] tests takewhile when everything passes

---
 catchtest/test_takewhile.cpp | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/catchtest/test_takewhile.cpp b/catchtest/test_takewhile.cpp
index 9394d32c..aae3f481 100644
--- a/catchtest/test_takewhile.cpp
+++ b/catchtest/test_takewhile.cpp
@@ -49,6 +49,13 @@ TEST_CASE("takewhile: works with lambda, callable, and function pointer",
     }
 }
 
+TEST_CASE("takewhile: everything passes predicate", "[takewhile]") {
+    Vec ns{1, 2, 3};
+    auto tw = takewhile(under_ten, ns);
+    Vec v(std::begin(tw), std::end(tw));
+    Vec vc = {1, 2, 3};
+}
+
 TEST_CASE("takewhile: empty iterable is empty", "[takewhile]") {
     Vec ns{};
     auto tw = takewhile(under_ten, ns);
@@ -81,7 +88,7 @@ TEST_CASE("takewhile: moves rvalues, binds to lvalues", "[takewhile]") {
 
 TEST_CASE("takewhile: with iterable doesn't move or copy elements",
         "[takewhile]") {
-    constexpr std::array<itertest::SolidInt, 3> arr{{{6}, {7}, {8}}};
+    constexpr std::array<itertest::SolidInt, 3> arr{{{8}, {9}, {10}}};
     auto func =
         [](const itertest::SolidInt& si){return si.getint() < 10;};
     for (auto&& i : takewhile(func, arr)) {

From a6c2976f9b5d133499340724a3c1a27019904c40 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 26 Jan 2015 14:53:24 -0500
Subject: [PATCH 0811/1866] checks for end in check_current()

---
 takewhile.hpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/takewhile.hpp b/takewhile.hpp
index ef8d5409..de5c7178 100644
--- a/takewhile.hpp
+++ b/takewhile.hpp
@@ -51,7 +51,8 @@ namespace iter {
                     FilterFunc filter_func;
 
                     void check_current() {
-                        if (!this->filter_func(*this->sub_iter)) {
+                        if (this->sub_iter != this->sub_end
+                                && !this->filter_func(*this->sub_iter)) {
                             this->sub_iter = this->sub_end;
                         }
                     }

From 091e4f948535b8fbbf959393ba4e4b6941bb272e Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 26 Jan 2015 14:55:45 -0500
Subject: [PATCH 0812/1866] eliminates useless specifications in dropwhile

---
 dropwhile.hpp | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/dropwhile.hpp b/dropwhile.hpp
index 28e823eb..0f2725cd 100644
--- a/dropwhile.hpp
+++ b/dropwhile.hpp
@@ -9,7 +9,6 @@
 
 namespace iter {
 
-    //Forward declarations of DropWhile and dropwhile
     template <typename FilterFunc, typename Container>
     class DropWhile;
 
@@ -33,16 +32,12 @@ namespace iter {
             friend DropWhile<FF, std::initializer_list<T>> dropwhile(
                     FF, std::initializer_list<T>);
             
-            // Value constructor for use only in the dropwhile function
             DropWhile(FilterFunc filter_func, Container container)
                 : container(std::forward<Container>(container)),
                 filter_func(filter_func)
             { }
-            DropWhile() = delete;
-            DropWhile& operator=(const DropWhile&) = delete;
 
         public:
-            DropWhile(const DropWhile&) = default;
             class Iterator 
                 : public std::iterator<std::input_iterator_tag,
                     iterator_traits_deref<Container>>
@@ -109,7 +104,6 @@ namespace iter {
 
     };
 
-    // Helper function to instantiate a DropWhile
     template <typename FilterFunc, typename Container>
     DropWhile<FilterFunc, Container> dropwhile(
             FilterFunc filter_func, Container&& container) {

From 9ae6355088527a07af386ccdf2f2b895e97071de Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 26 Jan 2015 14:59:14 -0500
Subject: [PATCH 0813/1866] slight alteration on range differentiation

instead of two specializations, have IsFloat default to false so
Range<T> still works.  this shouldn't affect too much though.
---
 range.hpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/range.hpp b/range.hpp
index 3ce9784c..f0e7048c 100644
--- a/range.hpp
+++ b/range.hpp
@@ -28,7 +28,7 @@ namespace iter {
         }
     };
 
-    template <typename T, bool IsFloat>
+    template <typename T, bool IsFloat =false>
     class Range;
 
     template <typename T, bool IsFloat =std::is_floating_point<T>::value>
@@ -39,8 +39,8 @@ namespace iter {
     Range<T, IsFloat> range(T, T, T);
 
     // General version for everything not a float
-    template <typename T>
-    class Range<T, false> {
+    template <typename T, bool>
+    class Range {
         friend Range range<T, false>(T);
         friend Range range<T, false>(T, T);
         friend Range range<T, false>(T, T, T);

From 1c2a4bbea86ed71ae4e5cf241f9c2c833d39c20f Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 26 Jan 2015 15:11:22 -0500
Subject: [PATCH 0814/1866] tests unique_everseen with adjacent duplicates

---
 catchtest/test_unique_everseen.cpp | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 catchtest/test_unique_everseen.cpp

diff --git a/catchtest/test_unique_everseen.cpp b/catchtest/test_unique_everseen.cpp
new file mode 100644
index 00000000..c8c87317
--- /dev/null
+++ b/catchtest/test_unique_everseen.cpp
@@ -0,0 +1,21 @@
+#include <unique_everseen.hpp>
+
+#include "helpers.hpp"
+
+#include <vector>
+#include <string>
+#include <iterator>
+
+#include "catch.hpp"
+
+using iter::unique_everseen;
+
+using Vec = const std::vector<int>;
+
+TEST_CASE("unique everseen: adjacent repeating values", "[unique_everseen]") {
+        Vec ns = {1,1,1,2,2,3,4,4,5,6,7,8,8,8,8,9,9};
+        auto ue = unique_everseen(ns);
+        Vec v(std::begin(ue), std::end(ue));
+        Vec vc = {1,2,3,4,5,6,7,8,9};
+        REQUIRE( v == vc );
+}

From 10a4e72343f9973a7b2a9f2745c7db7551ce05d6 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 26 Jan 2015 15:13:24 -0500
Subject: [PATCH 0815/1866] replaces remove_reference with decay

---
 unique_everseen.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/unique_everseen.hpp b/unique_everseen.hpp
index 77124c8d..066107e4 100644
--- a/unique_everseen.hpp
+++ b/unique_everseen.hpp
@@ -19,7 +19,7 @@ namespace iter
         -> Filter<std::function<bool(iterator_deref<Container>)>,Container>
     {
         using elem_t = iterator_deref<Container>;
-        std::unordered_set<typename std::remove_reference<elem_t>::type> elem_seen;
+        std::unordered_set<typename std::decay<elem_t>::type> elem_seen;
 
         std::function<bool(elem_t)> func =
         //has to be captured by value because it goes out of scope when the 

From 4eb2423252772e26f60491c322a7051b06bebdfb Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 26 Jan 2015 15:15:33 -0500
Subject: [PATCH 0816/1866] tests unique_everseen with non-adjacent duplicates

---
 catchtest/test_unique_everseen.cpp | 19 ++++++++++++++-----
 1 file changed, 14 insertions(+), 5 deletions(-)

diff --git a/catchtest/test_unique_everseen.cpp b/catchtest/test_unique_everseen.cpp
index c8c87317..359ad50a 100644
--- a/catchtest/test_unique_everseen.cpp
+++ b/catchtest/test_unique_everseen.cpp
@@ -13,9 +13,18 @@ using iter::unique_everseen;
 using Vec = const std::vector<int>;
 
 TEST_CASE("unique everseen: adjacent repeating values", "[unique_everseen]") {
-        Vec ns = {1,1,1,2,2,3,4,4,5,6,7,8,8,8,8,9,9};
-        auto ue = unique_everseen(ns);
-        Vec v(std::begin(ue), std::end(ue));
-        Vec vc = {1,2,3,4,5,6,7,8,9};
-        REQUIRE( v == vc );
+    Vec ns = {1,1,1,2,2,3,4,4,5,6,7,8,8,8,8,9,9};
+    auto ue = unique_everseen(ns);
+    Vec v(std::begin(ue), std::end(ue));
+    Vec vc = {1,2,3,4,5,6,7,8,9};
+    REQUIRE( v == vc );
+}
+
+TEST_CASE("unique everseen: nonadjacent repeating values",
+        "[unique_everseen]") {
+    Vec ns = {1,2,3,4,3,2,1,5,6};
+    auto ue = unique_everseen(ns);
+    Vec v(std::begin(ue), std::end(ue));
+    Vec vc = {1,2,3,4,5,6};
+    REQUIRE( v == vc );
 }

From 29c823391d3a8fe3adc7d4a44abc187333536d95 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 26 Jan 2015 15:19:47 -0500
Subject: [PATCH 0817/1866] tests unique_everseen binds and moves correctly

---
 catchtest/test_unique_everseen.cpp | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/catchtest/test_unique_everseen.cpp b/catchtest/test_unique_everseen.cpp
index 359ad50a..31e712a2 100644
--- a/catchtest/test_unique_everseen.cpp
+++ b/catchtest/test_unique_everseen.cpp
@@ -28,3 +28,13 @@ TEST_CASE("unique everseen: nonadjacent repeating values",
     Vec vc = {1,2,3,4,5,6};
     REQUIRE( v == vc );
 }
+
+TEST_CASE("unique everseen: moves rvalues, binds to lvalues",
+        "[unique_everseen]") {
+    itertest::BasicIterable<int> bi{1, 2};
+    unique_everseen(bi);
+    REQUIRE_FALSE( bi.was_moved_from() );
+
+    unique_everseen(std::move(bi));
+    REQUIRE( bi.was_moved_from() );
+}

From 5e13dfc60b2a1621a6c194e2036ee992ec12096b Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 26 Jan 2015 15:20:09 -0500
Subject: [PATCH 0818/1866] builds unique_everseen test

---
 catchtest/SConstruct | 1 +
 1 file changed, 1 insertion(+)

diff --git a/catchtest/SConstruct b/catchtest/SConstruct
index 4fac7a84..c81a1b97 100644
--- a/catchtest/SConstruct
+++ b/catchtest/SConstruct
@@ -39,6 +39,7 @@ progs = Split(
     sliding_window
     
     takewhile
+    unique_everseen
     '''
 )
 

From 9ffe3dac17f0942ba864dc78c9885981f56eb7c2 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 26 Jan 2015 15:24:27 -0500
Subject: [PATCH 0819/1866] changes everseen header

---
 unique_everseen.hpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/unique_everseen.hpp b/unique_everseen.hpp
index 066107e4..ec95eb34 100644
--- a/unique_everseen.hpp
+++ b/unique_everseen.hpp
@@ -1,5 +1,5 @@
-#ifndef UNIQUE_EVERSEEN_HPP
-#define UNIQUE_EVERSEEN_HPP
+#ifndef ITER_UNIQUE_EVERSEEN_HPP_
+#define ITER_UNIQUE_EVERSEEN_HPP_
 
 #include "iterbase.hpp"
 #include "filter.hpp"
@@ -54,4 +54,4 @@ namespace iter
     }
 }
 
-#endif //UNIQUE_EVERSEEN_HPP
+#endif

From bf345ac0a6be8e5b7e0f3c514bd0fd939e58d512 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 26 Jan 2015 15:34:24 -0500
Subject: [PATCH 0820/1866] initial unique justseen tests

---
 catchtest/test_unique_justseen.cpp | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 catchtest/test_unique_justseen.cpp

diff --git a/catchtest/test_unique_justseen.cpp b/catchtest/test_unique_justseen.cpp
new file mode 100644
index 00000000..0ba88b64
--- /dev/null
+++ b/catchtest/test_unique_justseen.cpp
@@ -0,0 +1,21 @@
+#include <unique_justseen.hpp>
+
+#include "helpers.hpp"
+
+#include <vector>
+#include <string>
+#include <iterator>
+
+#include "catch.hpp"
+
+using iter::unique_justseen;
+
+using Vec = const std::vector<int>;
+
+TEST_CASE("unique justseen: adjacent repeating values", "[unique_justseen]") {
+    Vec ns = {1,1,1,2,2,3,4,4,5,6,7,8,8,8,8,9,9};
+    auto ue = unique_justseen(ns);
+    Vec v(std::begin(ue), std::end(ue));
+    Vec vc = {1,2,3,4,5,6,7,8,9};
+    REQUIRE( v == vc );
+}

From e233994718d75ab232cb795f6d4394b1b6e829c2 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 26 Jan 2015 15:44:34 -0500
Subject: [PATCH 0821/1866] tests unique_justseen with non-adjacent dupes

---
 catchtest/test_unique_justseen.cpp | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/catchtest/test_unique_justseen.cpp b/catchtest/test_unique_justseen.cpp
index 0ba88b64..e8a09b1a 100644
--- a/catchtest/test_unique_justseen.cpp
+++ b/catchtest/test_unique_justseen.cpp
@@ -19,3 +19,19 @@ TEST_CASE("unique justseen: adjacent repeating values", "[unique_justseen]") {
     Vec vc = {1,2,3,4,5,6,7,8,9};
     REQUIRE( v == vc );
 }
+
+TEST_CASE("unique justseen: some repeating values", "[unique_justseen]") {
+    Vec ns = {1,2,2,3,4,4,5,6,6};
+    auto ue = unique_justseen(ns);
+    Vec v(std::begin(ue), std::end(ue));
+    Vec vc = {1,2,3,4,5,6};
+    REQUIRE( v == vc );
+}
+
+TEST_CASE("unique justseen: doesn't omit non-adjacent duplicates",
+        "[unique_justseen]") {
+    Vec ns = {1,2,1,2,1};
+    auto ue = unique_justseen(ns);
+    Vec v(std::begin(ue), std::end(ue));
+    REQUIRE( v == ns );
+}

From 0e76af74277a77cad8034d31629aae888aecce68 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 26 Jan 2015 15:46:41 -0500
Subject: [PATCH 0822/1866] builds unique_justseen test

---
 catchtest/SConstruct | 1 +
 1 file changed, 1 insertion(+)

diff --git a/catchtest/SConstruct b/catchtest/SConstruct
index c81a1b97..603ec080 100644
--- a/catchtest/SConstruct
+++ b/catchtest/SConstruct
@@ -40,6 +40,7 @@ progs = Split(
     
     takewhile
     unique_everseen
+    unique_justseen
     '''
 )
 

From 34f151bc038a2d324e816a755fae9acb647e1e23 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 26 Jan 2015 23:06:19 -0500
Subject: [PATCH 0823/1866] groupby does end-of-group check in ++

This way it's only done once, and it avoids constness issues arising
elsewhere when it was in operator!=
---
 groupby.hpp | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/groupby.hpp b/groupby.hpp
index 79960c8b..9ac0bfb1 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -107,14 +107,14 @@ namespace iter {
                     }
 
                     bool exhausted() const {
-                        return this->sub_iter == this->sub_end;
+                        return !(this->sub_iter != this->sub_end);
                     }
 
                     iterator_deref<Container> current() {
                         return *this->sub_iter;
                     }
 
-                    key_func_ret next_key() const {
+                    key_func_ret next_key() {
                         return this->key_func(*this->sub_iter);
                     }
             };
@@ -173,7 +173,7 @@ namespace iter {
                             const key_func_ret key;
                             const Group& group;
 
-                            bool not_at_end() const {
+                            bool not_at_end() {
                                 return !this->group.owner.exhausted()&&
                                     this->group.owner.next_key() == this->key;
                             }
@@ -188,12 +188,15 @@ namespace iter {
                             GroupIterator(const GroupIterator&) = default;
 
                             bool operator!=(const GroupIterator&) const {
+                                return !this->group.completed;
+#if 0
                                 if (this->not_at_end()) {
                                     return true;
                                 } else {
                                     this->group.completed = true;
                                     return false;
                                 }
+#endif
                             }
 
                             bool operator==(const GroupIterator& other) const {
@@ -202,6 +205,9 @@ namespace iter {
 
                             GroupIterator& operator++() {
                                 this->group.owner.increment_iterator();
+                                if (!this->not_at_end()) {
+                                    this->group.completed = true;
+                                }
                                 return *this;
                             }
 
@@ -246,7 +252,6 @@ namespace iter {
     template <typename Container>
     class ItemReturner {
         public:
-            ItemReturner() = default;
             iterator_deref<Container> operator() (
                     iterator_deref<Container> item) const {
                 return item;

From 6392b1cf180c30e1a94fe6c3f697dc5bb51d6955 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 26 Jan 2015 23:11:47 -0500
Subject: [PATCH 0824/1866] tests unique_justseen binds and moves correctly

---
 catchtest/test_unique_justseen.cpp | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/catchtest/test_unique_justseen.cpp b/catchtest/test_unique_justseen.cpp
index e8a09b1a..fcb9067b 100644
--- a/catchtest/test_unique_justseen.cpp
+++ b/catchtest/test_unique_justseen.cpp
@@ -30,8 +30,17 @@ TEST_CASE("unique justseen: some repeating values", "[unique_justseen]") {
 
 TEST_CASE("unique justseen: doesn't omit non-adjacent duplicates",
         "[unique_justseen]") {
-    Vec ns = {1,2,1,2,1};
+    Vec ns = {1,2,3,2,1,2,3,2,1};
     auto ue = unique_justseen(ns);
     Vec v(std::begin(ue), std::end(ue));
     REQUIRE( v == ns );
 }
+
+TEST_CASE("unique justseen: moves and binds correctly", "[unique_justseen]") {
+    itertest::BasicIterable<int> bi{1, 2};
+    unique_justseen(bi);
+    REQUIRE_FALSE( bi.was_moved_from() );
+
+    unique_justseen(std::move(bi));
+    REQUIRE( bi.was_moved_from() );
+}

From 50bb692149198ccd274392021defdfbf89499315 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 26 Jan 2015 23:38:29 -0500
Subject: [PATCH 0825/1866] tests zip_longest

---
 catchtest/test_zip_longest.cpp | 48 ++++++++++++++++++++++++++++++++++
 1 file changed, 48 insertions(+)
 create mode 100644 catchtest/test_zip_longest.cpp

diff --git a/catchtest/test_zip_longest.cpp b/catchtest/test_zip_longest.cpp
new file mode 100644
index 00000000..e603d655
--- /dev/null
+++ b/catchtest/test_zip_longest.cpp
@@ -0,0 +1,48 @@
+#include <zip_longest.hpp>
+
+#include "helpers.hpp"
+
+#include <vector>
+#include <tuple>
+#include <string>
+#include <iterator>
+#include <utility>
+#include <iterator>
+
+#include "catch.hpp"
+
+using iter::zip_longest;
+
+TEST_CASE("zip longest: correctly detects longest at any position",
+        "[zip_longest]") {
+    using TP = std::tuple<int, std::string, char>;
+    using ResVec = std::vector<TP>;
+
+    const std::vector<int> ivec{2, 4, 6, 8, 10, 12};
+    const std::vector<std::string> svec{"abc", "def", "xyz"};
+    const std::string str{"hello"};
+
+    ResVec results;
+    ResVec rc;
+
+    SECTION("longest first") {
+        for (auto&& t : zip_longest(ivec, svec, str)) {
+            results.emplace_back(
+                    std::get<0>(t).get_value_or(-1),
+                    std::get<1>(t).get_value_or(""),
+                    std::get<2>(t).get_value_or('\0')
+            );
+        }
+        rc = ResVec {
+            TP{2, "abc", 'h'},
+                TP{4, "def", 'e'},
+                TP{6, "xyz", 'l'},
+                TP{8, "", 'l'},
+                TP{10, "", 'o'},
+                TP{12, "", '\0'}
+        };
+    }
+
+
+    REQUIRE( results == rc );
+}

From d591165102fad8c38a233ad222fe318dbeb68a36 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 26 Jan 2015 23:51:06 -0500
Subject: [PATCH 0826/1866] simplifies first zip_longest test

---
 catchtest/test_zip_longest.cpp | 22 ++++++++++------------
 1 file changed, 10 insertions(+), 12 deletions(-)

diff --git a/catchtest/test_zip_longest.cpp b/catchtest/test_zip_longest.cpp
index e603d655..3fc01eaa 100644
--- a/catchtest/test_zip_longest.cpp
+++ b/catchtest/test_zip_longest.cpp
@@ -12,10 +12,12 @@
 #include "catch.hpp"
 
 using iter::zip_longest;
+template <typename T>
+using opt = boost::optional<T>;
 
 TEST_CASE("zip longest: correctly detects longest at any position",
         "[zip_longest]") {
-    using TP = std::tuple<int, std::string, char>;
+    using TP = std::tuple<opt<const int&>, opt<const std::string&>, opt<const char&>>;
     using ResVec = std::vector<TP>;
 
     const std::vector<int> ivec{2, 4, 6, 8, 10, 12};
@@ -27,19 +29,15 @@ TEST_CASE("zip longest: correctly detects longest at any position",
 
     SECTION("longest first") {
         for (auto&& t : zip_longest(ivec, svec, str)) {
-            results.emplace_back(
-                    std::get<0>(t).get_value_or(-1),
-                    std::get<1>(t).get_value_or(""),
-                    std::get<2>(t).get_value_or('\0')
-            );
+            results.push_back(t);
         }
         rc = ResVec {
-            TP{2, "abc", 'h'},
-                TP{4, "def", 'e'},
-                TP{6, "xyz", 'l'},
-                TP{8, "", 'l'},
-                TP{10, "", 'o'},
-                TP{12, "", '\0'}
+            TP{ivec[0], svec[0], str[0]},
+            TP{ivec[1], svec[1], str[1]},
+            TP{ivec[2], svec[2], str[2]},
+            TP{ivec[3], {},      str[3]},
+            TP{ivec[4], {},      str[4]},
+            TP{ivec[5], {},      {}    }
         };
     }
 

From 90fa2defa28cf5e503c4f31226e3242b7fe9eaaf Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 00:01:28 -0500
Subject: [PATCH 0827/1866] further simplifies zip_longest test

---
 catchtest/test_zip_longest.cpp | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/catchtest/test_zip_longest.cpp b/catchtest/test_zip_longest.cpp
index 3fc01eaa..bf6307d5 100644
--- a/catchtest/test_zip_longest.cpp
+++ b/catchtest/test_zip_longest.cpp
@@ -28,9 +28,8 @@ TEST_CASE("zip longest: correctly detects longest at any position",
     ResVec rc;
 
     SECTION("longest first") {
-        for (auto&& t : zip_longest(ivec, svec, str)) {
-            results.push_back(t);
-        }
+        auto zl = zip_longest(ivec, svec, str);
+        results = ResVec(std::begin(zl), std::end(zl));
         rc = ResVec {
             TP{ivec[0], svec[0], str[0]},
             TP{ivec[1], svec[1], str[1]},
@@ -41,6 +40,5 @@ TEST_CASE("zip longest: correctly detects longest at any position",
         };
     }
 
-
     REQUIRE( results == rc );
 }

From 9468b53c64c498e24b4f845421e80f9ac2f2d4d1 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 00:01:43 -0500
Subject: [PATCH 0828/1866] zip_longest iters inherit from std::iterator

---
 zip_longest.hpp | 23 ++++++++++++++---------
 1 file changed, 14 insertions(+), 9 deletions(-)

diff --git a/zip_longest.hpp b/zip_longest.hpp
index f3fd8014..803c809e 100644
--- a/zip_longest.hpp
+++ b/zip_longest.hpp
@@ -28,6 +28,10 @@ namespace iter {
         friend class ZippedLongest;
 
         private:
+            using OptType = boost::optional<iterator_deref<Container>>;
+            using ZipIterDeref =
+                std::tuple<OptType,
+                    boost::optional<iterator_deref<RestContainers>>...>;
             Container container;
             ZippedLongest<RestContainers...> rest_zipped;
             ZippedLongest(Container container, RestContainers&&... rest)
@@ -36,11 +40,12 @@ namespace iter {
             { }
 
         public:
-            class Iterator {
+            class Iterator
+                : public std::iterator<std::input_iterator_tag, ZipIterDeref>
+            {
                 private:
                     using RestIter =
                         typename ZippedLongest<RestContainers...>::Iterator;
-                    using OptType = boost::optional<iterator_deref<Container>>;
 
                     iterator_type<Container> iter;
                     iterator_type<Container> end;
@@ -69,11 +74,7 @@ namespace iter {
                             this->rest_iter != other.rest_iter;
                     }
 
-                    auto operator*() ->
-                        decltype(std::tuple_cat(
-                                    std::tuple<OptType>{OptType{*this->iter}},
-                                    *this->rest_iter))
-                    {
+                    ZipIterDeref operator*() {
                         if (this->iter != this->end) {
                             return std::tuple_cat(
                                     std::tuple<OptType>{OptType{*this->iter}},
@@ -111,6 +112,8 @@ namespace iter {
         friend class ZippedLongest;
 
         private:
+            using OptType = boost::optional<iterator_deref<Container>>;
+
             Container container;
             ZippedLongest(Container container)
                 : container(std::forward<Container>(container))
@@ -118,9 +121,11 @@ namespace iter {
 
         public:
 
-            class Iterator {
+            class Iterator
+                : public std::iterator<std::input_iterator_tag,
+                    std::tuple<OptType>> 
+            {
                 private:
-                    using OptType = boost::optional<iterator_deref<Container>>;
                     iterator_type<Container> iter;
                     iterator_type<Container> end;
                 public:

From e958db8d6c735e62a21a3252957577c74c89ea47 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 00:06:47 -0500
Subject: [PATCH 0829/1866] adds alias for getting optional type

optional<iterator_deref<T>> that is.
---
 zip_longest.hpp | 18 +++++++++++-------
 1 file changed, 11 insertions(+), 7 deletions(-)

diff --git a/zip_longest.hpp b/zip_longest.hpp
index 803c809e..affb0d5d 100644
--- a/zip_longest.hpp
+++ b/zip_longest.hpp
@@ -1,5 +1,5 @@
-#ifndef ZIP_LONGEST_HPP_
-#define ZIP_LONGEST_HPP_
+#ifndef ITER_ZIP_LONGEST_HPP_
+#define ITER_ZIP_LONGEST_HPP_
 
 #include "iterbase.hpp"
 
@@ -10,6 +10,10 @@
 
 
 namespace iter {
+
+    template <typename Container>
+    using OptIterDeref = boost::optional<iterator_deref<Container>>;
+
     template <typename Container, typename... RestContainers>
     class ZippedLongest;
 
@@ -28,10 +32,10 @@ namespace iter {
         friend class ZippedLongest;
 
         private:
-            using OptType = boost::optional<iterator_deref<Container>>;
+            using OptType = OptIterDeref<Container>;
             using ZipIterDeref =
-                std::tuple<OptType,
-                    boost::optional<iterator_deref<RestContainers>>...>;
+                std::tuple<OptType, OptIterDeref<RestContainers>...>;
+
             Container container;
             ZippedLongest<RestContainers...> rest_zipped;
             ZippedLongest(Container container, RestContainers&&... rest)
@@ -112,7 +116,7 @@ namespace iter {
         friend class ZippedLongest;
 
         private:
-            using OptType = boost::optional<iterator_deref<Container>>;
+            using OptType = OptIterDeref<Container>;
 
             Container container;
             ZippedLongest(Container container)
@@ -172,4 +176,4 @@ namespace iter {
     }
 }
 
-#endif // #ifndef ZIP_LONGEST_HPP_
+#endif

From 767f8c9a6ec665e7fb6c2a7f3307bd21df11c4fb Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 12:40:56 -0500
Subject: [PATCH 0830/1866] direct initialization-list for tuple

---
 zip_longest.hpp | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/zip_longest.hpp b/zip_longest.hpp
index affb0d5d..88886666 100644
--- a/zip_longest.hpp
+++ b/zip_longest.hpp
@@ -4,6 +4,7 @@
 #include "iterbase.hpp"
 
 #include <boost/optional.hpp>
+#include <iostream> // TODO remove
 #include <iterator>
 #include <tuple>
 #include <utility>
@@ -81,11 +82,11 @@ namespace iter {
                     ZipIterDeref operator*() {
                         if (this->iter != this->end) {
                             return std::tuple_cat(
-                                    std::tuple<OptType>{OptType{*this->iter}},
+                                    std::tuple<OptType>{{*this->iter}},
                                     *this->rest_iter);
                         } else {
                             return std::tuple_cat(
-                                    std::tuple<OptType>{OptType{}},
+                                    std::tuple<OptType>{{}},
                                     *this->rest_iter);
                         }
                     }
@@ -153,9 +154,9 @@ namespace iter {
 
                     std::tuple<OptType> operator*() {
                         if (this->iter != this->end) {
-                            return std::tuple<OptType>{OptType{*this->iter}};
+                            return std::tuple<OptType>{{*this->iter}};
                         }
-                        return std::tuple<OptType>{OptType{}};
+                        return std::tuple<OptType>{{}};
                     }
             };
 

From 2b03d1b6dbea24746a2c9b733cffbb6c843f90cb Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 12:41:52 -0500
Subject: [PATCH 0831/1866] tests zip_longest with longest in different places

---
 catchtest/test_zip_longest.cpp | 70 ++++++++++++++++++++++++++--------
 1 file changed, 54 insertions(+), 16 deletions(-)

diff --git a/catchtest/test_zip_longest.cpp b/catchtest/test_zip_longest.cpp
index bf6307d5..bb73dbb3 100644
--- a/catchtest/test_zip_longest.cpp
+++ b/catchtest/test_zip_longest.cpp
@@ -8,37 +8,75 @@
 #include <iterator>
 #include <utility>
 #include <iterator>
+#include <sstream>
+#include <iostream>
 
 #include "catch.hpp"
 
 using iter::zip_longest;
-template <typename T>
-using opt = boost::optional<T>;
+
+
+template <typename... Ts>
+using const_opt_tuple = std::tuple<boost::optional<const Ts&>...>;
 
 TEST_CASE("zip longest: correctly detects longest at any position",
         "[zip_longest]") {
-    using TP = std::tuple<opt<const int&>, opt<const std::string&>, opt<const char&>>;
-    using ResVec = std::vector<TP>;
 
     const std::vector<int> ivec{2, 4, 6, 8, 10, 12};
     const std::vector<std::string> svec{"abc", "def", "xyz"};
     const std::string str{"hello"};
 
-    ResVec results;
-    ResVec rc;
-
     SECTION("longest first") {
+        using TP = const_opt_tuple<int, std::string, char>;
+        using ResVec = std::vector<TP>;
+
         auto zl = zip_longest(ivec, svec, str);
-        results = ResVec(std::begin(zl), std::end(zl));
-        rc = ResVec {
-            TP{ivec[0], svec[0], str[0]},
-            TP{ivec[1], svec[1], str[1]},
-            TP{ivec[2], svec[2], str[2]},
-            TP{ivec[3], {},      str[3]},
-            TP{ivec[4], {},      str[4]},
-            TP{ivec[5], {},      {}    }
+        ResVec results(std::begin(zl), std::end(zl));
+        ResVec rc = {
+            TP{{ivec[0]},  {svec[0]},   {str[0]}},
+            TP{{ivec[1]},  {svec[1]},   {str[1]}},
+            TP{{ivec[2]},  {svec[2]},   {str[2]}},
+            TP{{ivec[3]},  {},          {str[3]}},
+            TP{{ivec[4]},  {},          {str[4]}},
+            TP{{ivec[5]},  {},          {}    }
+        };
+
+        REQUIRE( results == rc );
+    }
+
+    SECTION("longest in middle") {
+        using TP = const_opt_tuple<std::string, int, char>;
+        using ResVec = std::vector<TP>;
+
+        auto zl = zip_longest(svec, ivec, str);
+        ResVec results(std::begin(zl), std::end(zl));
+        ResVec rc = {
+            TP{{svec[0]},   {ivec[0]},  {str[0]}},
+            TP{{svec[1]},   {ivec[1]},  {str[1]}},
+            TP{{svec[2]},   {ivec[2]},  {str[2]}},
+            TP{{},          {ivec[3]},  {str[3]}},
+            TP{{},          {ivec[4]},  {str[4]}},
+            TP{{},          {ivec[5]},  {}    }
         };
+
+        REQUIRE( results == rc );
     }
 
-    REQUIRE( results == rc );
+    SECTION("longest at end") {
+        using TP = const_opt_tuple<std::string, char, int>;
+        using ResVec = std::vector<TP>;
+
+        auto zl = zip_longest(svec, str, ivec);
+        ResVec results(std::begin(zl), std::end(zl));
+        ResVec rc = {
+            TP{{svec[0]},   {str[0]},   {ivec[0]}},
+            TP{{svec[1]},   {str[1]},   {ivec[1]}},
+            TP{{svec[2]},   {str[2]},   {ivec[2]}},
+            TP{{},          {str[3]},   {ivec[3]}},
+            TP{{},          {str[4]},   {ivec[4]}},
+            TP{{},          {},         {ivec[5]}}
+        };
+
+        REQUIRE( results == rc );
+    }
 }

From b8cd2c1335e721d2a4c18dd8487a0c449fea6856 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 12:42:23 -0500
Subject: [PATCH 0832/1866] makes optionals printable

I had to reopen boost for this to work, hopefully this won't be too
disasterous down the road.
---
 catchtest/test_zip_longest.cpp | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/catchtest/test_zip_longest.cpp b/catchtest/test_zip_longest.cpp
index bb73dbb3..6a2afbc2 100644
--- a/catchtest/test_zip_longest.cpp
+++ b/catchtest/test_zip_longest.cpp
@@ -15,6 +15,18 @@
 
 using iter::zip_longest;
 
+// reopening boost is the only way I can find that gets this to print
+namespace boost {
+template <typename T>
+std::ostream& operator<<(std::ostream& out, const optional<T>& opt) {
+    if (opt) {
+        out << "Just " << *opt;
+    } else {
+        out << "Nothing";
+    }
+    return out;
+}
+}
 
 template <typename... Ts>
 using const_opt_tuple = std::tuple<boost::optional<const Ts&>...>;

From a4f3c0f07ee94e4401baabe1cb0e06096e1491b8 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 12:42:57 -0500
Subject: [PATCH 0833/1866] builds zip_longest test

---
 catchtest/SConstruct | 1 +
 1 file changed, 1 insertion(+)

diff --git a/catchtest/SConstruct b/catchtest/SConstruct
index 603ec080..5b333d41 100644
--- a/catchtest/SConstruct
+++ b/catchtest/SConstruct
@@ -41,6 +41,7 @@ progs = Split(
     takewhile
     unique_everseen
     unique_justseen
+    zip_longest
     '''
 )
 

From bc80ff0028eee75f8485b50728ffc0fed697b734 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 12:44:09 -0500
Subject: [PATCH 0834/1866] removes include of iostream in zip_longest.hpp

---
 zip_longest.hpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/zip_longest.hpp b/zip_longest.hpp
index 88886666..f6861458 100644
--- a/zip_longest.hpp
+++ b/zip_longest.hpp
@@ -4,7 +4,6 @@
 #include "iterbase.hpp"
 
 #include <boost/optional.hpp>
-#include <iostream> // TODO remove
 #include <iterator>
 #include <tuple>
 #include <utility>

From 9687b5480c40677113def07bf669ed2a343bc1f8 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 12:47:38 -0500
Subject: [PATCH 0835/1866] adds postfix ++ and == to zip_longest iters

---
 zip_longest.hpp | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/zip_longest.hpp b/zip_longest.hpp
index f6861458..53d49e67 100644
--- a/zip_longest.hpp
+++ b/zip_longest.hpp
@@ -73,11 +73,21 @@ namespace iter {
                         return *this;
                     }
 
+                    Iterator operator++(int) {
+                        auto ret = *this;
+                        ++*this;
+                        return ret;
+                    }
+
                     bool operator!=(const Iterator& other) const {
                         return this->iter != other.iter ||
                             this->rest_iter != other.rest_iter;
                     }
 
+                    bool operator==(const Iterator& other) const {
+                        return !(*this != other);
+                    }
+
                     ZipIterDeref operator*() {
                         if (this->iter != this->end) {
                             return std::tuple_cat(
@@ -147,10 +157,20 @@ namespace iter {
                         return *this;
                     }
 
+                    Iterator operator++(int) {
+                        auto ret = *this;
+                        ++*this;
+                        return ret;
+                    }
+
                     bool operator!=(const Iterator& other) const {
                         return this->iter != other.iter;
                     }
 
+                    bool operator==(const Iterator& other) const {
+                        return !(*this != other);
+                    }
+
                     std::tuple<OptType> operator*() {
                         if (this->iter != this->end) {
                             return std::tuple<OptType>{{*this->iter}};

From f8aa66a97710f6b92e7d7e5f6c7349f78eadd1d2 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 12:55:01 -0500
Subject: [PATCH 0836/1866] tests that zip_longest'd elements can be modified

---
 catchtest/test_zip_longest.cpp | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/catchtest/test_zip_longest.cpp b/catchtest/test_zip_longest.cpp
index 6a2afbc2..5431480c 100644
--- a/catchtest/test_zip_longest.cpp
+++ b/catchtest/test_zip_longest.cpp
@@ -92,3 +92,26 @@ TEST_CASE("zip longest: correctly detects longest at any position",
         REQUIRE( results == rc );
     }
 }
+
+TEST_CASE("zip longest: when all are empty, terminates right away",
+        "[zip_longest]") {
+    const std::vector<int> ivec{};
+    const std::vector<std::string> svec{};
+    const std::string str{};
+
+    auto zl = zip_longest(ivec, svec, str);
+    REQUIRE( std::begin(zl) == std::end(zl) );
+}
+
+TEST_CASE("zip longest: can modify zipped sequences", "[zip_longest]") {
+    std::vector<int> ns1 = {1, 2, 3};
+    std::vector<int> ns2 = {10, 11, 12};
+    for (auto&& t : zip_longest(ns1, ns2)) {
+        *std::get<0>(t) = -1;
+        *std::get<1>(t) = -1;
+    }
+
+    std::vector<int> vc = {-1, -1, -1};
+    REQUIRE( ns1 == vc );
+    REQUIRE( ns2 == vc );
+}

From e3639b38edefa2ad010cf3b1e473fa7bad4962e2 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 13:21:29 -0500
Subject: [PATCH 0837/1866] specifies reversed array deref

---
 reversed.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/reversed.hpp b/reversed.hpp
index 7563b898..e62bf4dc 100644
--- a/reversed.hpp
+++ b/reversed.hpp
@@ -108,7 +108,7 @@ namespace iter {
                         : sub_iter{iter}
                     { } 
 
-                    auto operator*() -> decltype(*array) {
+                    iterator_deref<T[N]> operator*() {
                         return *(this->sub_iter - 1);
                     }
 

From 3679aaf5c0525581c21d5e8545c0449f2cc4c057 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 13:38:51 -0500
Subject: [PATCH 0838/1866] slice iter inherits from std iterator

---
 slice.hpp | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/slice.hpp b/slice.hpp
index fa5f8e2a..76bfc88a 100644
--- a/slice.hpp
+++ b/slice.hpp
@@ -93,12 +93,15 @@ namespace iter {
             Slice(const Slice &) = default;
 
 
-            class Iterator {
+            class Iterator 
+                : public std::iterator<std::input_iterator_tag,
+                    iterator_traits_deref<Container>>
+            {
                 private:
                     iterator_type<Container> sub_iter;
                     DifferenceType current;
-                    const DifferenceType stop;
-                    const DifferenceType step;
+                    DifferenceType stop;
+                    DifferenceType step;
 
                 public:
                     Iterator (iterator_type<Container> si, DifferenceType start,

From 472b24ecdd48b70ef3f45f8647cdfed22ef1825b Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 13:39:44 -0500
Subject: [PATCH 0839/1866] adds postfix ++ and == to slice iter

---
 slice.hpp | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/slice.hpp b/slice.hpp
index 76bfc88a..859ae898 100644
--- a/slice.hpp
+++ b/slice.hpp
@@ -122,9 +122,19 @@ namespace iter {
                         return *this;
                     }
 
+                    Iterator operator++(int) {
+                        auto ret = *this;
+                        ++*this;
+                        return ret;
+                    }
+
                     bool operator!=(const Iterator &) const {
-                        return (this->step > 0 && this->current < this->stop)||
-                            (this->step < 0 && this->current > this->stop);
+                        return (this->step > 0 && this->current < this->stop)
+                            || (this->step < 0 && this->current > this->stop);
+                    }
+
+                    bool operator==(const Iterator& other) const {
+                        return !(*this != other);
                     }
             };
 

From 626b08b91be9692c7d14965e5e246cbc0d7a4513 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 14:37:11 -0500
Subject: [PATCH 0840/1866] tests slice with just stop

---
 catchtest/test_slice.cpp | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 catchtest/test_slice.cpp

diff --git a/catchtest/test_slice.cpp b/catchtest/test_slice.cpp
new file mode 100644
index 00000000..c5f9a311
--- /dev/null
+++ b/catchtest/test_slice.cpp
@@ -0,0 +1,21 @@
+#include <slice.hpp>
+
+#include <vector>
+#include <string>
+#include <utility>
+
+#include "helpers.hpp"
+#include "catch.hpp"
+
+using iter::slice;
+using Vec = const std::vector<int>;
+
+TEST_CASE("slice: take from beginning", "[slice]") {
+    Vec ns = {10,11,12,13,14,15,16,17,18,19};
+    auto sl = slice(ns, 5);
+
+    Vec v(std::begin(sl), std::end(sl));
+    Vec vc = {10,11,12,13,14};
+
+    REQUIRE( v == vc );
+}

From b71c001ef12cba112af109de630cb6fc94db4137 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 14:37:38 -0500
Subject: [PATCH 0841/1866] builds slice test

---
 catchtest/SConstruct | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/catchtest/SConstruct b/catchtest/SConstruct
index 5b333d41..cbf664c3 100644
--- a/catchtest/SConstruct
+++ b/catchtest/SConstruct
@@ -35,7 +35,7 @@ progs = Split(
     product
     repeat
     reversed
-
+    slice
     sliding_window
     
     takewhile

From d7d887097a930ebd50ebb40a7afe4743b7b8e54c Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 14:41:03 -0500
Subject: [PATCH 0842/1866] tests slice with start and stop

---
 catchtest/test_slice.cpp | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/catchtest/test_slice.cpp b/catchtest/test_slice.cpp
index c5f9a311..848f0cc3 100644
--- a/catchtest/test_slice.cpp
+++ b/catchtest/test_slice.cpp
@@ -19,3 +19,13 @@ TEST_CASE("slice: take from beginning", "[slice]") {
 
     REQUIRE( v == vc );
 }
+
+TEST_CASE("slice: start and stop", "[slice]") {
+    Vec ns = {10,11,12,13,14,15,16,17,18,19};
+    auto sl = slice(ns, 2, 6);
+
+    Vec v(std::begin(sl), std::end(sl));
+    Vec vc = {12, 13, 14, 15};
+
+    REQUIRE( v == vc );
+}

From 492383c56fa23547983bc6ddc55fb9e33f83aba1 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 14:41:29 -0500
Subject: [PATCH 0843/1866] adjusts include guards

---
 slice.hpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/slice.hpp b/slice.hpp
index 859ae898..8621c1e6 100644
--- a/slice.hpp
+++ b/slice.hpp
@@ -1,5 +1,5 @@
-#ifndef SLICE_HPP
-#define SLICE_HPP
+#ifndef ITER_SLICE_HPP
+#define ITER_SLICE_HPP
 
 #include "iterbase.hpp"
 
@@ -179,4 +179,4 @@ namespace iter {
     }
 }
 
-#endif //SLICE_HPP
+#endif

From b4a3d0a5a92c1caa214560c670ec7e894027df4c Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 14:44:14 -0500
Subject: [PATCH 0844/1866] tests slice with step

---
 catchtest/test_slice.cpp | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/catchtest/test_slice.cpp b/catchtest/test_slice.cpp
index 848f0cc3..96f5f9da 100644
--- a/catchtest/test_slice.cpp
+++ b/catchtest/test_slice.cpp
@@ -29,3 +29,13 @@ TEST_CASE("slice: start and stop", "[slice]") {
 
     REQUIRE( v == vc );
 }
+
+TEST_CASE("slice: start, stop, step", "[slice]") {
+    Vec ns = {10,11,12,13,14,15,16,17,18,19};
+    auto sl = slice(ns, 2, 8, 2);
+
+    Vec v(std::begin(sl), std::end(sl));
+    Vec vc = {12,14,16};
+
+    REQUIRE( v == vc );
+}

From 26360638c550a8873ddae7bfb68b90fec5c6272a Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 14:49:04 -0500
Subject: [PATCH 0845/1866] tests slice when stop is too high

---
 catchtest/test_slice.cpp | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/catchtest/test_slice.cpp b/catchtest/test_slice.cpp
index 96f5f9da..9c860a8a 100644
--- a/catchtest/test_slice.cpp
+++ b/catchtest/test_slice.cpp
@@ -39,3 +39,11 @@ TEST_CASE("slice: start, stop, step", "[slice]") {
 
     REQUIRE( v == vc );
 }
+
+TEST_CASE("slice: stop is beyond end of iterable", "[slice]") {
+    Vec ns = {1, 2, 3};
+    auto sl = slice(ns, 10);
+
+    Vec v(std::begin(sl), std::end(sl));
+    REQUIRE( v == ns );
+}

From f69b08fa4691da886feabf6f2f3e2b050abc80c7 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 14:54:38 -0500
Subject: [PATCH 0846/1866] tests slice when start is too high

---
 catchtest/test_slice.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/catchtest/test_slice.cpp b/catchtest/test_slice.cpp
index 9c860a8a..79d993a4 100644
--- a/catchtest/test_slice.cpp
+++ b/catchtest/test_slice.cpp
@@ -47,3 +47,9 @@ TEST_CASE("slice: stop is beyond end of iterable", "[slice]") {
     Vec v(std::begin(sl), std::end(sl));
     REQUIRE( v == ns );
 }
+
+TEST_CASE("slice: start is beyond end of iterable", "[slice]") {
+    Vec ns = {1, 2, 3};
+    auto sl = slice(ns, 5, 10);
+    REQUIRE( std::begin(sl) == std::end(sl) );
+}

From cc2c685797bd7174485bc6461fb961e71ee6689e Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 15:00:12 -0500
Subject: [PATCH 0847/1866] tests slice with step going past stop

---
 catchtest/test_slice.cpp | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/catchtest/test_slice.cpp b/catchtest/test_slice.cpp
index 79d993a4..d6845014 100644
--- a/catchtest/test_slice.cpp
+++ b/catchtest/test_slice.cpp
@@ -53,3 +53,12 @@ TEST_CASE("slice: start is beyond end of iterable", "[slice]") {
     auto sl = slice(ns, 5, 10);
     REQUIRE( std::begin(sl) == std::end(sl) );
 }
+
+TEST_CASE("slice: (stop - start) % step != 0", "[slice]") {
+    Vec ns = {1, 2, 3, 4};
+    auto sl = slice(ns, 0, 2, 3);
+    Vec v(std::begin(sl), std::end(sl));
+    Vec vc = {1}; 
+
+    REQUIRE( v == vc );
+}

From 29c73b012d5baaada12e104bd9e82b1a82a1b4f3 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 15:07:29 -0500
Subject: [PATCH 0848/1866] tests slice with empty ranges

---
 catchtest/test_slice.cpp | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/catchtest/test_slice.cpp b/catchtest/test_slice.cpp
index d6845014..4414276e 100644
--- a/catchtest/test_slice.cpp
+++ b/catchtest/test_slice.cpp
@@ -62,3 +62,15 @@ TEST_CASE("slice: (stop - start) % step != 0", "[slice]") {
 
     REQUIRE( v == vc );
 }
+
+TEST_CASE("slice: invalid ranges give 0 size slices", "[slice]") {
+    Vec ns = {1, 2, 3};
+    SECTION("stop > start, step < 0") {
+        auto sl = slice(ns, 1, 10,-1);
+        REQUIRE( std::begin(sl) == std::end(sl) );
+    }
+    SECTION("stop < start, step > 0") {
+        auto sl = slice(ns, 2, 0, 3);
+        REQUIRE( std::begin(sl) == std::end(sl) );
+    }
+}

From d7b1f8461df5960379e2409e69b5325d52d6f70c Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 15:11:27 -0500
Subject: [PATCH 0849/1866] tests that slice doesn't move or copy elements

---
 catchtest/test_slice.cpp | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/catchtest/test_slice.cpp b/catchtest/test_slice.cpp
index 4414276e..64093e4b 100644
--- a/catchtest/test_slice.cpp
+++ b/catchtest/test_slice.cpp
@@ -74,3 +74,13 @@ TEST_CASE("slice: invalid ranges give 0 size slices", "[slice]") {
         REQUIRE( std::begin(sl) == std::end(sl) );
     }
 }
+
+// TODO test with BasicIterable can't currently be done because of
+// range checking using std::distance.  (also screws up infinite ranges)
+
+TEST_CASE("slice: with iterable doesn't move or copy elems", "[slice]") {
+    constexpr std::array<itertest::SolidInt, 3> arr{{{6}, {7}, {8}}};
+    for (auto&& i : slice(arr, 2)) {
+        (void)i;
+    }
+}

From 1ba1a9bc96bc2c30b7a0d63db8725b0c840c22e6 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 15:14:02 -0500
Subject: [PATCH 0850/1866] tests that zip_longest moves and binds correctly

---
 catchtest/test_zip_longest.cpp | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/catchtest/test_zip_longest.cpp b/catchtest/test_zip_longest.cpp
index 5431480c..36d74dcb 100644
--- a/catchtest/test_zip_longest.cpp
+++ b/catchtest/test_zip_longest.cpp
@@ -115,3 +115,16 @@ TEST_CASE("zip longest: can modify zipped sequences", "[zip_longest]") {
     REQUIRE( ns1 == vc );
     REQUIRE( ns2 == vc );
 }
+
+TEST_CASE("zip_longest: binds to lvalues, moves rvalues", "[zip_longest]") {
+    itertest::BasicIterable<char> b1{'x', 'y', 'z'};
+    itertest::BasicIterable<char> b2{'a', 'b'};
+    SECTION("bind to first, moves second") {
+        zip_longest(b1, std::move(b2));
+    }
+    SECTION("move first, bind to second") {
+        zip_longest(std::move(b2), b1);
+    }
+    REQUIRE_FALSE( b1.was_moved_from() );
+    REQUIRE( b2.was_moved_from() );
+}

From 29f0807e8f495a19ba242d87d231f0fd65a00127 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 15:15:44 -0500
Subject: [PATCH 0851/1866] tests zip_longest doesn't move or copy elements

---
 catchtest/test_zip_longest.cpp | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/catchtest/test_zip_longest.cpp b/catchtest/test_zip_longest.cpp
index 36d74dcb..d6966e46 100644
--- a/catchtest/test_zip_longest.cpp
+++ b/catchtest/test_zip_longest.cpp
@@ -128,3 +128,10 @@ TEST_CASE("zip_longest: binds to lvalues, moves rvalues", "[zip_longest]") {
     REQUIRE_FALSE( b1.was_moved_from() );
     REQUIRE( b2.was_moved_from() );
 }
+
+TEST_CASE("zip_longest: doesn't move or copy elements", "[zip_longest]") {
+    constexpr itertest::SolidInt arr[] = {{6}, {7}, {8}};
+    for (auto&& t : zip_longest(arr, arr)) {
+        (void)std::get<0>(t);
+    }
+}

From e65d114365a819230281ffe4ad7175276e3255dd Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 21:17:34 -0500
Subject: [PATCH 0852/1866] alphabetizes sconstruct

---
 catchtest/SConstruct | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/catchtest/SConstruct b/catchtest/SConstruct
index cbf664c3..f05eecea 100644
--- a/catchtest/SConstruct
+++ b/catchtest/SConstruct
@@ -15,8 +15,6 @@ env['ENV']['TERM'] = os.environ['TERM']
 
 progs = Split(
     '''
-    zip
-    range
     accumulate
     chain
     combinations
@@ -33,6 +31,7 @@ progs = Split(
     permutations
     powerset
     product
+    range
     repeat
     reversed
     slice
@@ -41,6 +40,7 @@ progs = Split(
     takewhile
     unique_everseen
     unique_justseen
+    zip
     zip_longest
     '''
 )

From bbe4e09bca59ef40bf08f7903f12ef81ba410e01 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 21:23:36 -0500
Subject: [PATCH 0853/1866] uses empty base case zip_longest

instead of specializing on one template parameter, specializes on 0
---
 zip_longest.hpp | 74 ++++++++++++-------------------------------------
 1 file changed, 18 insertions(+), 56 deletions(-)

diff --git a/zip_longest.hpp b/zip_longest.hpp
index 53d49e67..49114505 100644
--- a/zip_longest.hpp
+++ b/zip_longest.hpp
@@ -14,21 +14,21 @@ namespace iter {
     template <typename Container>
     using OptIterDeref = boost::optional<iterator_deref<Container>>;
 
-    template <typename Container, typename... RestContainers>
+    template <typename... RestContainers>
     class ZippedLongest;
 
     template <typename... Containers>
     ZippedLongest<Containers...> zip_longest(Containers&&...);
 
     template <typename Container, typename... RestContainers>
-    class ZippedLongest {
+    class ZippedLongest <Container, RestContainers...> {
         static_assert(!std::is_rvalue_reference<Container>::value,
                 "Itertools cannot be templated with rvalue references");
 
         friend ZippedLongest zip_longest<Container, RestContainers...>(
                 Container&&, RestContainers&&...);
 
-        template <typename C, typename... RC>
+        template <typename... Cs>
         friend class ZippedLongest;
 
         private:
@@ -115,78 +115,40 @@ namespace iter {
     };
 
 
-    template <typename Container>
-    class ZippedLongest<Container> {
-        static_assert(!std::is_rvalue_reference<Container>::value,
-                "Itertools cannot be templated with rvalue references");
-
-        friend ZippedLongest zip_longest<Container>(Container&&);
-
-        template <typename C, typename... RC>
-        friend class ZippedLongest;
-
-        private:
-            using OptType = OptIterDeref<Container>;
-
-            Container container;
-            ZippedLongest(Container container)
-                : container(std::forward<Container>(container))
-            { }
-
+    template <>
+    class ZippedLongest<> {
         public:
-
             class Iterator
-                : public std::iterator<std::input_iterator_tag,
-                    std::tuple<OptType>> 
+                : public std::iterator<std::input_iterator_tag, std::tuple<>> 
             {
-                private:
-                    iterator_type<Container> iter;
-                    iterator_type<Container> end;
                 public:
-                    Iterator(
-                            iterator_type<Container> it,
-                            iterator_type<Container> in_end)
-                        : iter{it},
-                        end{in_end}
-                    { }
-
                     Iterator& operator++() {
-                        if (this->iter != this->end) {
-                            ++this->iter;
-                        }
                         return *this;
                     }
 
-                    Iterator operator++(int) {
-                        auto ret = *this;
-                        ++*this;
-                        return ret;
+                    constexpr Iterator operator++(int) {
+                        return *this;
                     }
 
-                    bool operator!=(const Iterator& other) const {
-                        return this->iter != other.iter;
+                    constexpr bool operator!=(const Iterator&) const {
+                        return false;
                     }
 
-                    bool operator==(const Iterator& other) const {
-                        return !(*this != other);
+                    constexpr bool operator==(const Iterator&) const {
+                        return true;
                     }
 
-                    std::tuple<OptType> operator*() {
-                        if (this->iter != this->end) {
-                            return std::tuple<OptType>{{*this->iter}};
-                        }
-                        return std::tuple<OptType>{{}};
+                    constexpr std::tuple<> operator*() {
+                        return {};
                     }
             };
 
-            Iterator begin() {
-                return {std::begin(this->container),
-                    std::end(this->container)};
+            constexpr Iterator begin() {
+                return {};
             }
 
-            Iterator end() {
-                return {std::end(this->container),
-                    std::end(this->container)};
+            constexpr Iterator end() {
+                return {};
             }
     };
 

From d243ac77cbe174b066e930f714b7a7fd8c5640dd Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 21:29:14 -0500
Subject: [PATCH 0854/1866] tests empty zip_longest()

---
 catchtest/test_zip_longest.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/catchtest/test_zip_longest.cpp b/catchtest/test_zip_longest.cpp
index d6966e46..1e12a68a 100644
--- a/catchtest/test_zip_longest.cpp
+++ b/catchtest/test_zip_longest.cpp
@@ -116,6 +116,12 @@ TEST_CASE("zip longest: can modify zipped sequences", "[zip_longest]") {
     REQUIRE( ns2 == vc );
 }
 
+TEST_CASE("zip longest: empty zip_longest() is empty", "[zip_longest]") {
+    auto zl = zip_longest();
+    REQUIRE( std::begin(zl) == std::end(zl) );
+    REQUIRE_FALSE( std::begin(zl) != std::end(zl) );
+}
+
 TEST_CASE("zip_longest: binds to lvalues, moves rvalues", "[zip_longest]") {
     itertest::BasicIterable<char> b1{'x', 'y', 'z'};
     itertest::BasicIterable<char> b2{'a', 'b'};

From 7c30585260d33edf37caf0a78ae5e51408c9b394 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 21:37:38 -0500
Subject: [PATCH 0855/1866] removes wrap_iter, nothing uses it anymore

---
 wrap_iter.hpp | 51 ---------------------------------------------------
 1 file changed, 51 deletions(-)
 delete mode 100644 wrap_iter.hpp

diff --git a/wrap_iter.hpp b/wrap_iter.hpp
deleted file mode 100644
index 70017b4b..00000000
--- a/wrap_iter.hpp
+++ /dev/null
@@ -1,51 +0,0 @@
-#ifndef WRAP_ITER_HPP__
-#define WRAP_ITER_HPP__
-
-#include <iterator>
-
-namespace iter {
-    template <typename Iterator>
-    class wrap_iter {
-        private:
-            Iterator iter;
-            typename std::iterator_traits<Iterator>::difference_type step;
-
-        public:
-            //using difference_type = typename std::iterator_traits<Iterator>::difference_type;
-            wrap_iter(const Iterator & iter,
-                    typename std::iterator_traits<Iterator>::difference_type step) : 
-                iter(iter),
-                step(step)
-            { }
-
-            wrap_iter & operator++() {
-                std::advance(iter,step);
-                return *this;
-            }
-
-            bool operator!=(const wrap_iter & rhs) const {
-                return this->iter != rhs.iter;
-            }
-
-            auto operator*() const -> decltype(*iter)
-            {
-                return *iter;
-            }
-    };
-
-    template <typename Iterator>
-    wrap_iter<Iterator> make_wrap_iter(const Iterator & iter,
-            typename std::iterator_traits<Iterator>::difference_type step) {
-        return wrap_iter<Iterator>(iter,step);
-    }
-    
-}
-namespace std {
-template <typename Iterator>
-    struct iterator_traits<iter::wrap_iter<Iterator>> {
-        using difference_type = typename iterator_traits<Iterator>::difference_type;
-        using iterator_category = typename iterator_traits<Iterator>::iterator_category;
-        //should add the rest later for a more usable class
-    };
-}
-#endif //WRAP_ITER_HPP__

From e96bfe7dffef436150c4b0b9da42204815689eef Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 21:40:36 -0500
Subject: [PATCH 0856/1866] removes extra move, makes iterator assignable

---
 accumulate.hpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/accumulate.hpp b/accumulate.hpp
index 218c98cb..8df2e409 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -46,7 +46,7 @@ namespace iter {
                     std::is_default_constructible<AccumVal>::value,
                     "Cannot accumulate a non-default constructible type");
 
-            Accumulator(Container container, AccumulateFunc accumulate_func)
+            Accumulator(Container&& container, AccumulateFunc accumulate_func)
                 : container(std::forward<Container>(container)),
                 accumulate_func(accumulate_func)
             { }
@@ -57,7 +57,7 @@ namespace iter {
             {
                 private:
                     iterator_type<Container> sub_iter;
-                    const iterator_type<Container> sub_end;
+                    iterator_type<Container> sub_end;
                     AccumulateFunc accumulate_func;
                     AccumVal acc_val;
                 public:
@@ -150,4 +150,4 @@ namespace iter {
 
 }
 
-#endif //ifndef ITER_ACCUMULATE_H_
+#endif

From 2a9488a27bc34f253c350b8430ca4ce98883a959 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 21:45:16 -0500
Subject: [PATCH 0857/1866] eliminates extra moves

---
 chain.hpp | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/chain.hpp b/chain.hpp
index 399ea3e9..5130dc56 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -30,7 +30,7 @@ namespace iter {
         private:
             Container container;
             Chained<RestContainers...> rest_chained;
-            Chained(Container container, RestContainers&&... rest)
+            Chained(Container&& container, RestContainers&&... rest)
                 : container(std::forward<Container>(container)),
                 rest_chained{std::forward<RestContainers>(rest)...}
             { }
@@ -45,7 +45,7 @@ namespace iter {
                     using RestIter =
                         typename Chained<RestContainers...>::Iterator;
                     iterator_type<Container> sub_iter;
-                    const iterator_type<Container> sub_end;
+                    iterator_type<Container> sub_end;
                     RestIter rest_iter;
                     bool at_end;
 
@@ -112,7 +112,7 @@ namespace iter {
 
         private:
             Container container;
-            Chained(Container container)
+            Chained(Container&& container)
                 : container(std::forward<Container>(container))
             { }
 
@@ -124,7 +124,7 @@ namespace iter {
             {
                 private:
                     iterator_type<Container> sub_iter;
-                    const iterator_type<Container> sub_end;
+                    iterator_type<Container> sub_end;
 
                 public:
                     Iterator(const iterator_type<Container>& s_begin,
@@ -173,7 +173,7 @@ namespace iter {
         private:
             Container container;
             friend class ChainMaker;
-            ChainedFromIterable(Container container)
+            ChainedFromIterable(Container&& container)
                 : container(std::forward<Container>(container))
             { }
 
@@ -315,4 +315,4 @@ namespace iter {
 
 }
 
-#endif // #ifndef ITER_CHAIN_HPP_
+#endif

From 8c02af2468b80fdad17b11aad27deeaffca10366 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 21:46:46 -0500
Subject: [PATCH 0858/1866] eliminates extra moves

---
 combinations.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/combinations.hpp b/combinations.hpp
index 089d0abc..d98ecd6e 100644
--- a/combinations.hpp
+++ b/combinations.hpp
@@ -30,7 +30,7 @@ namespace iter {
             friend Combinator<std::initializer_list<T>> combinations(
                     std::initializer_list<T>, std::size_t);
 
-            Combinator(Container in_container, std::size_t in_length)
+            Combinator(Container&& in_container, std::size_t in_length)
                 : container(std::forward<Container>(in_container)),
                 length{in_length}
             { }

From 1283d231d38881cdd6bdd16e46df5e40cdb950df Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 21:48:36 -0500
Subject: [PATCH 0859/1866] eliminates extra moves

---
 combinations_with_replacement.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/combinations_with_replacement.hpp b/combinations_with_replacement.hpp
index 4b521e76..2ed2af4b 100644
--- a/combinations_with_replacement.hpp
+++ b/combinations_with_replacement.hpp
@@ -36,7 +36,7 @@ namespace iter {
             combinations_with_replacement(
                     std::initializer_list<T>, std::size_t);
 
-           CombinatorWithReplacement(Container container, std::size_t n)
+           CombinatorWithReplacement(Container&& container, std::size_t n)
                : container(std::forward<Container>(container)),
                length{n}
            { }

From 0779083e8eb4bd5bcf33987fedf429f85b0a66f3 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 21:52:23 -0500
Subject: [PATCH 0860/1866] removes moves, makes iterators assignable

---
 compress.hpp | 21 +++++++++++----------
 1 file changed, 11 insertions(+), 10 deletions(-)

diff --git a/compress.hpp b/compress.hpp
index 9d3ff7d0..4dfab7a8 100644
--- a/compress.hpp
+++ b/compress.hpp
@@ -48,7 +48,8 @@ namespace iter {
                     Con&&, std::initializer_list<T>);
 
             template <typename T, typename U>
-            friend Compressed<std::initializer_list<T>, std::initializer_list<U>> compress(
+            friend Compressed<std::initializer_list<T>,
+                   std::initializer_list<U>> compress(
                     std::initializer_list<T>, std::initializer_list<U>);
 
             
@@ -56,7 +57,7 @@ namespace iter {
             using selector_iter_type = decltype(std::begin(selectors));
             
             // Value constructor for use only in the compress function
-            Compressed(Container container, Selector selectors)
+            Compressed(Container&& container, Selector&& selectors)
                 : container(std::forward<Container>(container)),
                 selectors(std::forward<Selector>(selectors))
             { }
@@ -69,10 +70,10 @@ namespace iter {
             {
                 private:
                     iterator_type<Container> sub_iter;
-                    const iterator_type<Container> sub_end;
+                    iterator_type<Container> sub_end;
 
                     selector_iter_type selector_iter;
-                    const selector_iter_type selector_end;
+                    selector_iter_type selector_end;
 
                     void increment_iterators() {
                         ++this->sub_iter;
@@ -80,9 +81,9 @@ namespace iter {
                     }
 
                     void skip_failures() {
-                        while (this->sub_iter != this->sub_end &&
-                               this->selector_iter != this->selector_end &&
-                                !*this->selector_iter) {
+                        while (this->sub_iter != this->sub_end
+                               && this->selector_iter != this->selector_end
+                                && !*this->selector_iter) {
                             this->increment_iterators();
                         }
                     }
@@ -100,7 +101,7 @@ namespace iter {
                         this->skip_failures();
                     } 
 
-                    iterator_deref<Container> operator*() const {
+                    iterator_deref<Container> operator*() {
                         return *this->sub_iter;
                     }
 
@@ -117,8 +118,8 @@ namespace iter {
                     }
 
                     bool operator!=(const Iterator& other) const {
-                        return this->sub_iter != other.sub_iter &&
-                            this->selector_iter != other.selector_iter;
+                        return this->sub_iter != other.sub_iter
+                            && this->selector_iter != other.selector_iter;
                     }
 
                     bool operator==(const Iterator& other) const {

From d760457c3d2df903008f22b5bfde11c61c67d973 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 21:59:14 -0500
Subject: [PATCH 0861/1866] eliminates extra moves

---
 cycle.hpp | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/cycle.hpp b/cycle.hpp
index 8c8962e1..484fc922 100644
--- a/cycle.hpp
+++ b/cycle.hpp
@@ -9,7 +9,6 @@
 
 namespace iter {
 
-    //Forward declarations of Cycle and cycle
     template <typename Container>
     class Cycle;
 
@@ -22,7 +21,6 @@ namespace iter {
     template <typename Container>
     class Cycle {
         private:
-            // The cycle function is the only thing allowed to create a Cycle
             friend Cycle cycle<Container>(Container&&);
             template <typename T>
             friend Cycle<std::initializer_list<T>> cycle(
@@ -30,8 +28,7 @@ namespace iter {
 
             Container container;
             
-            // Value constructor for use only in the cycle function
-            Cycle(Container container)
+            Cycle(Container&& container)
                 : container(std::forward<Container>(container))
             { }
 
@@ -53,7 +50,7 @@ namespace iter {
                         end{end}
                     { } 
 
-                    iterator_deref<Container> operator*() const {
+                    iterator_deref<Container> operator*() {
                         return *this->sub_iter;
                     }
 
@@ -93,7 +90,6 @@ namespace iter {
 
     };
 
-    // Helper function to instantiate a Cycle
     template <typename Container>
     Cycle<Container> cycle(Container&& container) {
         return {std::forward<Container>(container)};

From 70334e769c44af08bcd1b0b67e75ebb04a12bb73 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 22:01:01 -0500
Subject: [PATCH 0862/1866] eliminates extra moves

---
 dropwhile.hpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/dropwhile.hpp b/dropwhile.hpp
index 0f2725cd..169aa305 100644
--- a/dropwhile.hpp
+++ b/dropwhile.hpp
@@ -32,7 +32,7 @@ namespace iter {
             friend DropWhile<FF, std::initializer_list<T>> dropwhile(
                     FF, std::initializer_list<T>);
             
-            DropWhile(FilterFunc filter_func, Container container)
+            DropWhile(FilterFunc filter_func, Container&& container)
                 : container(std::forward<Container>(container)),
                 filter_func(filter_func)
             { }
@@ -44,7 +44,7 @@ namespace iter {
             {
                 private:
                     iterator_type<Container> sub_iter;
-                    const iterator_type<Container> sub_end;
+                    iterator_type<Container> sub_end;
                     FilterFunc filter_func;
 
                     // skip all values for which the predicate is true
@@ -66,7 +66,7 @@ namespace iter {
                         this->skip_passes();
                     } 
 
-                    iterator_deref<Container> operator*() const {
+                    iterator_deref<Container> operator*() {
                         return *this->sub_iter;
                     }
 

From b7f55d2e5706d76f6c7b587a4036ef62608a2b72 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 22:08:00 -0500
Subject: [PATCH 0863/1866] eliminates extra moves

---
 enumerate.hpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index 845b0412..cba785f5 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -47,7 +47,7 @@ namespace iter {
             using BasePair = std::pair<std::size_t, iterator_deref<Container>>;
 
             // Value constructor for use only in the enumerate function
-            Enumerable(Container container)
+            Enumerable(Container&& container)
                 : container(std::forward<Container>(container))
             { }
             
@@ -71,7 +71,7 @@ namespace iter {
                     iterator_type<Container> sub_iter;
                     std::size_t index;
                 public:
-                    Iterator (iterator_type<Container> si)
+                    Iterator(const iterator_type<Container>& si)
                         : sub_iter{si},
                         index{0}
                     { } 
@@ -121,8 +121,8 @@ namespace iter {
     Enumerable<std::initializer_list<T>> enumerate(
             std::initializer_list<T> il)
     {   
-        return {il};
+        return {std::move(il)};
     }
 }
 
-#endif //#ifndef ITER_ENUMERATE_H_
+#endif

From 9c30253adb51e4ae435814fab83862bf94897ad8 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 22:11:28 -0500
Subject: [PATCH 0864/1866] corrects handling of init lists

---
 combinations.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/combinations.hpp b/combinations.hpp
index d98ecd6e..c7c36724 100644
--- a/combinations.hpp
+++ b/combinations.hpp
@@ -151,7 +151,7 @@ namespace iter {
     template <typename T>
     Combinator<std::initializer_list<T>> combinations(
             std::initializer_list<T> il, std::size_t length) {
-        return {il, length};
+        return {std::move(il), length};
     }
 }
 #endif

From 2140cbbdc701a284e704604d30f7518245afb912 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 22:12:02 -0500
Subject: [PATCH 0865/1866] corrects handling of init lasts

---
 combinations_with_replacement.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/combinations_with_replacement.hpp b/combinations_with_replacement.hpp
index 2ed2af4b..62e24db8 100644
--- a/combinations_with_replacement.hpp
+++ b/combinations_with_replacement.hpp
@@ -135,7 +135,7 @@ namespace iter {
     CombinatorWithReplacement<std::initializer_list<T>> 
     combinations_with_replacement(
             std::initializer_list<T> il, std::size_t length) {
-        return {il, length};
+        return {std::move(il), length};
     }
 }
 

From 66ad83ff1fed6088c9fbf11b46dff64a618883b5 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 22:17:56 -0500
Subject: [PATCH 0866/1866] eliminates extra moves

---
 filter.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/filter.hpp b/filter.hpp
index 28ab60b7..fdefe612 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -35,7 +35,7 @@ namespace iter {
                     FF, std::initializer_list<T>);
             
             // Value constructor for use only in the filter function
-            Filter(FilterFunc filter_func, Container container)
+            Filter(FilterFunc filter_func, Container&& container)
                 : container(std::forward<Container>(container)),
                 filter_func(filter_func)
             { }

From 02dfbf447f4084802f1c710247ab5273637d414f Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 22:21:39 -0500
Subject: [PATCH 0867/1866] corrects include guards

---
 filterfalse.hpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/filterfalse.hpp b/filterfalse.hpp
index 38ded919..3bad5fa0 100644
--- a/filterfalse.hpp
+++ b/filterfalse.hpp
@@ -1,5 +1,5 @@
-#ifndef FILTER_FALSE__HPP__
-#define FILTER_FALSE__HPP__
+#ifndef ITER_FILTER_FALSE_HPP_
+#define ITER_FILTER_FALSE_HPP_
 
 #include "iterbase.hpp"
 #include "filter.hpp"
@@ -102,4 +102,4 @@ namespace iter {
     }
 }
 
-#endif //#ifndef FILTER_FALSE__HPP__
+#endif

From 30afc6c961ea48a8db75238b92b7098d04d44ea8 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 22:23:14 -0500
Subject: [PATCH 0868/1866] corrects include guards

---
 groupby.hpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/groupby.hpp b/groupby.hpp
index 9ac0bfb1..d0e8cbf5 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -1,5 +1,5 @@
-#ifndef GROUP__BY__HPP
-#define GROUP__BY__HPP
+#ifndef ITER_GROUP_BY_HPP_
+#define ITER_GROUP_BY_HPP_
 
 #include "iterbase.hpp"
 
@@ -294,4 +294,4 @@ namespace iter {
 }
 
 
-#endif //#ifndef GROUP__BY__HPP
+#endif

From d705b1d0118e73e499d8af83709e043edb1ea0c7 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 22:24:59 -0500
Subject: [PATCH 0869/1866] eliminates extra moves

---
 groupby.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/groupby.hpp b/groupby.hpp
index d0e8cbf5..718b4abc 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -35,7 +35,7 @@ namespace iter {
                 decltype(std::declval<KeyFunc>()(
                             std::declval<iterator_deref<Container>>()));
 
-            GroupBy(Container container, KeyFunc key_func)
+            GroupBy(Container&& container, KeyFunc key_func)
                 : container(std::forward<Container>(container)),
                 key_func(key_func)
             { }
@@ -62,7 +62,7 @@ namespace iter {
                 private:
                     iterator_type<Container> sub_iter;
                     iterator_type<Container> sub_iter_peek;
-                    const iterator_type<Container> sub_end;
+                    iterator_type<Container> sub_end;
                     KeyFunc key_func;
 
                 public:

From e0bd55e342bd2ce3bde607bf1ac973f8922acb8f Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 22:28:59 -0500
Subject: [PATCH 0870/1866] eliminates extra moves

---
 grouper.hpp | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/grouper.hpp b/grouper.hpp
index af75ade3..4fdcfec7 100644
--- a/grouper.hpp
+++ b/grouper.hpp
@@ -1,5 +1,5 @@
-#ifndef GROUPER_HPP_
-#define GROUPER_HPP_
+#ifndef ITER_GROUPER_HPP_
+#define ITER_GROUPER_HPP_
 
 #include "iterbase.hpp"
 
@@ -28,7 +28,7 @@ namespace iter {
             Container container;
             std::size_t group_size;
 
-            Grouper(Container c, std::size_t sz)
+            Grouper(Container&& c, std::size_t sz)
                 : container(std::forward<Container>(c)),
                 group_size{sz}
             { }
@@ -127,7 +127,7 @@ namespace iter {
     template <typename T>
     Grouper<std::initializer_list<T>> grouper(
             std::initializer_list<T> il, std::size_t group_size) {
-        return {il, group_size};
+        return {std::move(il), group_size};
     }
 }
-#endif // #ifndef GROUPER_HPP_
+#endif

From 2134a12cdcd9c92b9eccafb95c91843094bbc91b Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 22:32:11 -0500
Subject: [PATCH 0871/1866] eliminates extra moves

---
 permutations.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/permutations.hpp b/permutations.hpp
index bb383ac7..97ae6639 100644
--- a/permutations.hpp
+++ b/permutations.hpp
@@ -19,7 +19,7 @@ namespace iter {
                 std::vector<collection_item_type<Container>>;
 
         public:
-            Permuter(Container in_container)
+            Permuter(Container&& in_container)
                 : container(std::forward<Container>(in_container))
             { }
 
@@ -88,7 +88,7 @@ namespace iter {
     template <typename T>
     Permuter<std::initializer_list<T>> permutations(
             std::initializer_list<T> il) {
-        return {il};
+        return {std::move(il)};
     }
 
 }

From 1aab55db8d84aee86a093bfd8952f7bb2caa5fcb Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 22:33:35 -0500
Subject: [PATCH 0872/1866] eliminates extra moves

---
 powerset.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/powerset.hpp b/powerset.hpp
index 69abf4fa..964b0651 100644
--- a/powerset.hpp
+++ b/powerset.hpp
@@ -20,7 +20,7 @@ namespace iter {
                 decltype(combinations(std::declval<Container&>(), 0));
 
         public:
-            Powersetter(Container in_container)
+            Powersetter(Container&& in_container)
                 : container(std::forward<Container>(in_container))
             { }
 
@@ -92,7 +92,7 @@ namespace iter {
     template <typename T>
     Powersetter<std::initializer_list<T>> powerset(
             std::initializer_list<T> il) {
-        return {il};
+        return {std::move(il)};
     }
 }
 #endif

From 428679911cfb73926d477b946f718e92198ab6c4 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 22:35:35 -0500
Subject: [PATCH 0873/1866] eliminates extra moves

---
 product.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/product.hpp b/product.hpp
index c40909f8..6d7d281d 100644
--- a/product.hpp
+++ b/product.hpp
@@ -33,7 +33,7 @@ namespace iter {
         private:
             Container container;
             Productor<RestContainers...> rest_products;
-            Productor(Container container, RestContainers&&... rest)
+            Productor(Container&& container, RestContainers&&... rest)
                 : container(std::forward<Container>(container)),
                 rest_products{std::forward<RestContainers>(rest)...}
             { }

From fbbaafc138790e48257d61dfe8f0b392ebef6839 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 22:36:05 -0500
Subject: [PATCH 0874/1866] eliminates extra moves

---
 product.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/product.hpp b/product.hpp
index 6d7d281d..92e0c5b8 100644
--- a/product.hpp
+++ b/product.hpp
@@ -83,8 +83,8 @@ namespace iter {
 
                     bool operator!=(const Iterator& other) const {
                         return this->iter != other.iter &&
-                            (RestIter::is_base_iter ||
-                                this->rest_iter != other.rest_iter);
+                            (RestIter::is_base_iter
+                                || this->rest_iter != other.rest_iter);
                     }
 
                     bool operator==(const Iterator& other) const {

From 124d93834b7e7fda05f867415230a0b50a287120 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 22:38:31 -0500
Subject: [PATCH 0875/1866] eliminates extra moves

---
 reversed.hpp | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/reversed.hpp b/reversed.hpp
index e62bf4dc..13f0689b 100644
--- a/reversed.hpp
+++ b/reversed.hpp
@@ -20,14 +20,11 @@ namespace iter {
             Container container;
             friend Reverser reversed<Container>(Container&&);
             
-            Reverser(Container container)
+            Reverser(Container&& container)
                 : container(std::forward<Container>(container))
             { }
-            Reverser() = delete;
-            Reverser& operator=(const Reverser&) = delete;
 
         public:
-            Reverser(const Reverser&) = default;
             class Iterator : public std::iterator<
                          std::input_iterator_tag,
                          iterator_traits_deref<Container>>
@@ -94,8 +91,6 @@ namespace iter {
             Reverser(T *array)
                 : array{array}
             { }
-            Reverser() = delete;
-            Reverser& operator=(const Reverser&) = delete;
 
         public:
             Reverser(const Reverser&) = default;

From e1d653d6fd600e50b33cd3c2b7b1aae27571abe0 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 22:39:08 -0500
Subject: [PATCH 0876/1866] eliminates extra moves

---
 reversed.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/reversed.hpp b/reversed.hpp
index 13f0689b..9d580ec5 100644
--- a/reversed.hpp
+++ b/reversed.hpp
@@ -144,4 +144,4 @@ namespace iter {
 
 }
 
-#endif //ITER_REVERSE_HPP_
+#endif

From e6b7042b86c1106f76ed40f042f6bcb7c635b784 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 22:45:10 -0500
Subject: [PATCH 0877/1866] eliminates extra moves

---
 slice.hpp | 17 ++++++-----------
 1 file changed, 6 insertions(+), 11 deletions(-)

diff --git a/slice.hpp b/slice.hpp
index 8621c1e6..be0d5ac2 100644
--- a/slice.hpp
+++ b/slice.hpp
@@ -1,5 +1,5 @@
-#ifndef ITER_SLICE_HPP
-#define ITER_SLICE_HPP
+#ifndef ITER_SLICE_HPP_
+#define ITER_SLICE_HPP_
 
 #include "iterbase.hpp"
 
@@ -65,7 +65,7 @@ namespace iter {
             //template <typename T>
             //friend Slice<std::initializer_list<T>> slice(std::initializer_list<T>);
         public:
-            Slice(Container in_container, DifferenceType start,
+            Slice(Container&& in_container, DifferenceType start,
                   DifferenceType stop, DifferenceType step)
                 : container(std::forward<Container>(in_container)),
                 start{start},
@@ -87,11 +87,6 @@ namespace iter {
                 }
             }
 
-            Slice() = delete;
-            Slice& operator=(const Slice&) = delete;
-
-            Slice(const Slice &) = default;
-
 
             class Iterator 
                 : public std::iterator<std::input_iterator_tag,
@@ -112,7 +107,7 @@ namespace iter {
                         step{step}
                     { }
 
-                    iterator_deref<Container> operator*() const {
+                    iterator_deref<Container> operator*() {
                         return *this->sub_iter;
                     }
 
@@ -169,13 +164,13 @@ namespace iter {
     Slice<std::initializer_list<T>, DifferenceType> slice(
             std::initializer_list<T> il, DifferenceType start,
             DifferenceType stop, DifferenceType step=1) {
-        return {il, start, stop, step};
+        return {std::move(il), start, stop, step};
     }
 
     template <typename T, typename DifferenceType>
     Slice<std::initializer_list<T>, DifferenceType> slice(
             std::initializer_list<T> il, DifferenceType stop) {
-        return {il, 0, stop, 1};
+        return {std::move(il), 0, stop, 1};
     }
 }
 

From 232dcae035ee0049edce2f777ad0ff0b8b5da344 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 22:47:43 -0500
Subject: [PATCH 0878/1866] eliminates extra moves

---
 sliding_window.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/sliding_window.hpp b/sliding_window.hpp
index 48d4ca1c..4efdf7d1 100644
--- a/sliding_window.hpp
+++ b/sliding_window.hpp
@@ -30,7 +30,7 @@ namespace iter {
             friend SlidingWindow<std::initializer_list<T>> sliding_window(
                     std::initializer_list<T>, std::size_t);
 
-            SlidingWindow(Container container, std::size_t win_sz)
+            SlidingWindow(Container&& container, std::size_t win_sz)
                 : container(std::forward<Container>(container)),
                 window_size{win_sz}
             { }
@@ -110,7 +110,7 @@ namespace iter {
     template <typename T>
     SlidingWindow<std::initializer_list<T>> sliding_window(
             std::initializer_list<T> il, std::size_t window_size) {
-        return {il, window_size};
+        return {std::move(il), window_size};
     }
 }
 

From 4a732c156bed3bb4ee90a2d5b5b09b87a670f0f7 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 22:49:41 -0500
Subject: [PATCH 0879/1866] eliminates extra moves

---
 sorted.hpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/sorted.hpp b/sorted.hpp
index 349fc881..05c5a3e3 100644
--- a/sorted.hpp
+++ b/sorted.hpp
@@ -1,5 +1,5 @@
-#ifndef SORTED__HPP__
-#define SORTED__HPP__
+#ifndef ITER_SORTED_HPP_
+#define ITER_SORTED_HPP_
 
 #include "iterbase.hpp"
 
@@ -29,7 +29,7 @@ namespace iter {
             Sorted() = delete;
             Sorted& operator=(const Sorted&) = delete;
 
-            Sorted(Container in_container, CompareFunc compare_func)
+            Sorted(Container&& in_container, CompareFunc compare_func)
                 : container(std::forward<Container>(in_container))
             {
                 // Fill the sorted_iters vector with an iterator to each
@@ -93,4 +93,4 @@ namespace iter {
 
 }
 
-#endif //#ifndef SORTED__HPP__
+#endif

From b192188b5a533bb04a88a9c2ca6c85edd02ae556 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 22:50:40 -0500
Subject: [PATCH 0880/1866] eliminates extra moves

---
 takewhile.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/takewhile.hpp b/takewhile.hpp
index de5c7178..12eb4368 100644
--- a/takewhile.hpp
+++ b/takewhile.hpp
@@ -33,7 +33,7 @@ namespace iter {
             friend TakeWhile<FF, std::initializer_list<T>> takewhile(
                     FF, std::initializer_list<T>);
 
-            TakeWhile(FilterFunc filter_func, Container container)
+            TakeWhile(FilterFunc filter_func, Container&& container)
                 : container(std::forward<Container>(container)),
                 filter_func(filter_func)
             { }

From 323774171f2c9a8dcda4e5bf33eec7b791777ab6 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 22:51:09 -0500
Subject: [PATCH 0881/1866] eliminates extra moves

---
 zip.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/zip.hpp b/zip.hpp
index a77061bf..64b3f087 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -31,7 +31,7 @@ namespace iter {
         private:
             Container container;
             Zipped<RestContainers...> rest_zipped;
-            Zipped(Container container, RestContainers&&... rest)
+            Zipped(Container&& container, RestContainers&&... rest)
                 : container(std::forward<Container>(container)),
                 rest_zipped{std::forward<RestContainers>(rest)...}
             { }
@@ -154,4 +154,4 @@ namespace iter {
     }
 }
 
-#endif // #ifndef ITER_ZIP_HPP_
+#endif

From 436d5d0bdf0ddacd69eff84e1583b96bde47cfa4 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Tue, 27 Jan 2015 22:53:37 -0500
Subject: [PATCH 0882/1866] eliminates extra moves

---
 zip_longest.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/zip_longest.hpp b/zip_longest.hpp
index 49114505..cc6705b9 100644
--- a/zip_longest.hpp
+++ b/zip_longest.hpp
@@ -38,7 +38,7 @@ namespace iter {
 
             Container container;
             ZippedLongest<RestContainers...> rest_zipped;
-            ZippedLongest(Container container, RestContainers&&... rest)
+            ZippedLongest(Container&& container, RestContainers&&... rest)
                 : container(std::forward<Container>(container)),
                 rest_zipped{std::forward<RestContainers>(rest)...}
             { }

From 1199eeb08d7fe6bbaa0b0f3590bdd5ae6eff0217 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 28 Jan 2015 16:26:22 -0500
Subject: [PATCH 0883/1866] adds TMP for advancing O(1) when possible

---
 iterbase.hpp | 113 ++++++++++++++++++++++++++++++++-------------------
 1 file changed, 72 insertions(+), 41 deletions(-)

diff --git a/iterbase.hpp b/iterbase.hpp
index d426af91..81f6ff95 100644
--- a/iterbase.hpp
+++ b/iterbase.hpp
@@ -15,46 +15,6 @@
 #include <type_traits>
 
 namespace iter {
-    // because std::advance assumes a lot and is actually smart, I need a dumb
-    // version that will work with most things
-    template <typename InputIt, typename Distance =std::size_t>
-    void dumb_advance(InputIt& iter, Distance distance=1) {
-        for (Distance i(0); i < distance; ++i) {
-            ++iter;
-        }
-    }
-
-    // iter will not be incremented past end
-    template <typename InputIt, typename Distance =std::size_t>
-    void dumb_advance(InputIt& iter, const InputIt& end, Distance distance=1) {
-        for (Distance i(0); i < distance && iter != end; ++i) {
-            ++iter;
-        }
-    }
-
-    template <typename ForwardIt, typename Distance =std::size_t>
-    ForwardIt dumb_next(ForwardIt it, Distance distance=1) {
-        dumb_advance(it, distance);
-        return it;
-    }
-
-    template <typename ForwardIt, typename Distance =std::size_t>
-    ForwardIt dumb_next(
-            ForwardIt it, const ForwardIt& end, Distance distance=1) {
-        dumb_advance(it, end, distance);
-        return it;
-    }
-
-    template <typename Container, typename Distance =std::size_t>
-    Distance dumb_size(Container&& container) {
-        Distance d{0};
-        for (auto it = std::begin(container), end = std::end(container);
-                it != end;
-                ++it) {
-            ++d;
-        }
-        return d;
-    }
 
     // iterator_type<C> is the type of C's iterator
     template <typename Container>
@@ -95,6 +55,77 @@ namespace iter {
         typename std::remove_const<
             iterator_deref<Container>>::type>::type;
 
+    template <typename, typename =void>
+    struct is_random_access_iter : std::false_type { };
+
+    template <typename T>
+    struct is_random_access_iter<T,
+        typename std::enable_if<
+             std::is_same<
+                 typename std::iterator_traits<T>::iterator_category,
+              std::random_access_iterator_tag>::value,
+          void>::type> : std::true_type { };
+
+    template <typename T>
+    using has_random_access_iter = is_random_access_iter<iterator_type<T>>;
+    // because std::advance assumes a lot and is actually smart, I need a dumb
+
+    // version that will work with most things
+    template <typename InputIt, typename Distance =std::size_t>
+    void dumb_advance(InputIt& iter, Distance distance=1) {
+        for (Distance i(0); i < distance; ++i) {
+            ++iter;
+        }
+    }
+
+    template <typename Iter, typename Distance>
+    void dumb_advance_impl(Iter& iter, const Iter& end,
+            Distance distance, std::false_type) {
+        for (Distance i(0); i < distance && iter != end; ++i) {
+            ++iter;
+        }
+    }
+
+    template <typename Iter, typename Distance>
+    void dumb_advance_impl(Iter& iter, const Iter& end,
+            Distance distance, std::true_type) {
+        if (static_cast<Distance>(end - iter) < distance) {
+            iter = end;
+        } else {
+            iter += distance;
+        }
+    }
+
+    // iter will not be incremented past end
+    template <typename Iter, typename Distance =std::size_t>
+    void dumb_advance(Iter& iter, const Iter& end, Distance distance=1) {
+        dumb_advance_impl(iter, end, distance, is_random_access_iter<Iter>{});
+    }
+
+    template <typename ForwardIt, typename Distance =std::size_t>
+    ForwardIt dumb_next(ForwardIt it, Distance distance=1) {
+        dumb_advance(it, distance);
+        return it;
+    }
+
+    template <typename ForwardIt, typename Distance =std::size_t>
+    ForwardIt dumb_next(
+            ForwardIt it, const ForwardIt& end, Distance distance=1) {
+        dumb_advance(it, end, distance);
+        return it;
+    }
+
+    template <typename Container, typename Distance =std::size_t>
+    Distance dumb_size(Container&& container) {
+        Distance d{0};
+        for (auto it = std::begin(container), end = std::end(container);
+                it != end;
+                ++it) {
+            ++d;
+        }
+        return d;
+    }
+
 
     template <typename... Ts>
     struct are_same : std::true_type { };
@@ -105,4 +136,4 @@ namespace iter {
             std::is_same<T, U>::value && are_same<T, Ts...>::value> { };
 }
 
-#endif // #ifndef ITERBASE_HPP_
+#endif

From 6b74744e402555ed4257432ea8ce069fc0249bab Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 28 Jan 2015 16:29:29 -0500
Subject: [PATCH 0884/1866] tests that slice moves and binds correctly

---
 catchtest/test_slice.cpp | 21 ++++++++++++++++-----
 1 file changed, 16 insertions(+), 5 deletions(-)

diff --git a/catchtest/test_slice.cpp b/catchtest/test_slice.cpp
index 64093e4b..d7992dee 100644
--- a/catchtest/test_slice.cpp
+++ b/catchtest/test_slice.cpp
@@ -65,18 +65,29 @@ TEST_CASE("slice: (stop - start) % step != 0", "[slice]") {
 
 TEST_CASE("slice: invalid ranges give 0 size slices", "[slice]") {
     Vec ns = {1, 2, 3};
-    SECTION("stop > start, step < 0") {
-        auto sl = slice(ns, 1, 10,-1);
+    SECTION("negative step") {
+        auto sl = slice(ns, 1, 10, -1);
         REQUIRE( std::begin(sl) == std::end(sl) );
     }
-    SECTION("stop < start, step > 0") {
+    SECTION("stop < start") {
         auto sl = slice(ns, 2, 0, 3);
         REQUIRE( std::begin(sl) == std::end(sl) );
     }
 }
 
-// TODO test with BasicIterable can't currently be done because of
-// range checking using std::distance.  (also screws up infinite ranges)
+TEST_CASE("slice: moves rvalues and binds to lvalues", "[slice]") {
+    itertest::BasicIterable<int> bi{1, 2, 3, 4};
+    slice(bi, 1, 3);
+    REQUIRE_FALSE( bi.was_moved_from() );
+    auto sl = slice(std::move(bi), 1, 3);
+    REQUIRE( bi.was_moved_from() );
+
+    Vec v(std::begin(sl), std::end(sl));
+    Vec vc = {2, 3};
+
+    REQUIRE( v == vc );
+}
+
 
 TEST_CASE("slice: with iterable doesn't move or copy elems", "[slice]") {
     constexpr std::array<itertest::SolidInt, 3> arr{{{6}, {7}, {8}}};

From b821337de75ed93131d065e86e2dd1c7b5f10725 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 28 Jan 2015 16:30:21 -0500
Subject: [PATCH 0885/1866] removes slice SFINAE, doesn't calculate distance

---
 slice.hpp | 78 +++++++++++++++----------------------------------------
 1 file changed, 21 insertions(+), 57 deletions(-)

diff --git a/slice.hpp b/slice.hpp
index be0d5ac2..d04f863b 100644
--- a/slice.hpp
+++ b/slice.hpp
@@ -19,38 +19,6 @@ namespace iter {
 
     //template <typename Container, typename DifferenceType>
     //Slice<Container> slice(Container &&);
-    template <typename T>
-    class has_size
-    {
-        typedef char one;
-        typedef long two;
-
-        template <typename C> static one test( decltype(&C::size) ) ;
-        template <typename C> static two test(...);
-
-
-        public:
-        enum { value = sizeof(test<T>(0)) == sizeof(char) };
-    };
-    template <typename Container>
-    typename std::enable_if<has_size<Container>::value, std::size_t>::type 
-    size(const Container& container) {
-        return container.size();
-    }
-
-    template <typename Container>
-    typename std::enable_if<!has_size<Container>::value, std::size_t>::type 
-    size(const Container& container) {
-        return std::distance(std::begin(container), std::end(container));
-    }
-
-    template <typename T, std::size_t N>
-    std::size_t size(const T (&)[N]) {
-        return N;
-    }
-
-
-
     template <typename Container, typename DifferenceType>
     class Slice {
         private:
@@ -68,24 +36,10 @@ namespace iter {
             Slice(Container&& in_container, DifferenceType start,
                   DifferenceType stop, DifferenceType step)
                 : container(std::forward<Container>(in_container)),
-                start{start},
+                start{start < stop && step > 0 ? start : stop},
                 stop{stop},
                 step{step}
-            { 
-                // sets stop = start if the range is empty
-                if ((start < stop && step <=0) ||
-                        (start > stop && step >=0)){
-                    this->stop = start;
-                } 
-                if (this->stop > static_cast<DifferenceType>(
-                            size(this->container))) {
-                    this->stop = static_cast<DifferenceType>(size(
-                                this->container));
-                }
-                if (this->start < 0) {
-                    this->start = 0; 
-                }
-            }
+            { }
 
 
             class Iterator 
@@ -94,14 +48,19 @@ namespace iter {
             {
                 private:
                     iterator_type<Container> sub_iter;
+                    iterator_type<Container> sub_end;
                     DifferenceType current;
                     DifferenceType stop;
                     DifferenceType step;
 
                 public:
-                    Iterator (iterator_type<Container> si, DifferenceType start,
-                            DifferenceType stop, DifferenceType step)
-                        : sub_iter{si},
+                    Iterator (iterator_type<Container> si,
+                            iterator_type<Container> se,
+                            DifferenceType start,
+                            DifferenceType stop,
+                            DifferenceType step)
+                        : sub_iter{std::move(si)},
+                        sub_end{std::move(se)},
                         current{start},
                         stop{stop},
                         step{step}
@@ -112,8 +71,11 @@ namespace iter {
                     }
 
                     Iterator& operator++() { 
-                        std::advance(this->sub_iter, this->step);
+                        dumb_advance(this->sub_iter, this->sub_end,this->step);
                         this->current += this->step;
+                        if (this->stop < this->current ) {
+                            this->current = this->stop;
+                        }
                         return *this;
                     }
 
@@ -123,9 +85,9 @@ namespace iter {
                         return ret;
                     }
 
-                    bool operator!=(const Iterator &) const {
-                        return (this->step > 0 && this->current < this->stop)
-                            || (this->step < 0 && this->current > this->stop);
+                    bool operator!=(const Iterator& other) const {
+                        return this->sub_iter != other.sub_iter
+                            && this->current != other.current;
                     }
 
                     bool operator==(const Iterator& other) const {
@@ -134,12 +96,14 @@ namespace iter {
             };
 
             Iterator begin() {
-                return {std::next(std::begin(this->container), this->start),
+                auto it = std::begin(this->container);
+                dumb_advance(it, std::end(this->container), this->start);
+                return {std::move(it), std::end(this->container),
                         this->start, this->stop, this->step};
             }
 
             Iterator end() {
-                return {std::next(std::begin(this->container), this->stop),
+                return {std::end(this->container), std::end(this->container),
                         this->stop, this->stop, this->step};
             }
 

From 9e740f41d2cf4c6f518bf2ffb8ef14059a59fe69 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 28 Jan 2015 16:35:38 -0500
Subject: [PATCH 0886/1866] tests slice with empty sequence

---
 catchtest/test_slice.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/catchtest/test_slice.cpp b/catchtest/test_slice.cpp
index d7992dee..3d95380e 100644
--- a/catchtest/test_slice.cpp
+++ b/catchtest/test_slice.cpp
@@ -40,6 +40,12 @@ TEST_CASE("slice: start, stop, step", "[slice]") {
     REQUIRE( v == vc );
 }
 
+TEST_CASE("slice: empty iterable", "[slice]") {
+    Vec ns{};
+    auto sl = slice(ns, 3);
+    REQUIRE( std::begin(sl) == std::end(sl) );
+}
+
 TEST_CASE("slice: stop is beyond end of iterable", "[slice]") {
     Vec ns = {1, 2, 3};
     auto sl = slice(ns, 10);

From b96ef0b1dc89e1630b99a23303fc7845573eebf0 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 28 Jan 2015 17:12:34 -0500
Subject: [PATCH 0887/1866] uses vector instead of set so it's printable

---
 catchtest/test_combinations.cpp | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/catchtest/test_combinations.cpp b/catchtest/test_combinations.cpp
index c366cdba..a3149edf 100644
--- a/catchtest/test_combinations.cpp
+++ b/catchtest/test_combinations.cpp
@@ -12,14 +12,13 @@
 using iter::combinations;
 using itertest::BasicIterable;
 using itertest::SolidInt;
-using CharCombSet = std::multiset<std::vector<char>>;
+using CharCombSet = std::vector<std::vector<char>>;
 
 TEST_CASE("combinations: Simple combination of 4", "[combinations]") {
     std::string s{"ABCD"};
     CharCombSet sc;
     for (auto v : combinations(s, 2)) {
-        std::vector<char> vcopy(std::begin(v), std::end(v));
-        sc.insert(vcopy);
+        sc.emplace_back(std::begin(v), std::end(v));
     }
 
     CharCombSet ans = 

From 20c44c151cb5363431a2308696f06ea6c7d31ea5 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 28 Jan 2015 17:27:52 -0500
Subject: [PATCH 0888/1866] tests that comb iters compare for real

---
 catchtest/test_combinations.cpp | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/catchtest/test_combinations.cpp b/catchtest/test_combinations.cpp
index a3149edf..e5c015df 100644
--- a/catchtest/test_combinations.cpp
+++ b/catchtest/test_combinations.cpp
@@ -26,6 +26,17 @@ TEST_CASE("combinations: Simple combination of 4", "[combinations]") {
     REQUIRE( ans == sc );
 }
 
+TEST_CASE("combinations: iterators can be compared", "[combinations]") {
+    std::string s{"ABCD"};
+    auto c = combinations(s, 2);
+    auto it = std::begin(c);
+    REQUIRE( it == std::begin(c) );
+    REQUIRE_FALSE( it != std::begin(c) );
+    ++it;
+    REQUIRE( it != std::begin(c) );
+    REQUIRE_FALSE( it == std::begin(c) );
+}
+
 TEST_CASE("combinations: size too large gives no results", "[combinations]") {
     std::string s{"ABCD"};
     auto c = combinations(s, 5);

From e467b37506c273a285eeae175f93ef79adafc4d1 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 28 Jan 2015 17:28:30 -0500
Subject: [PATCH 0889/1866] lets comb iters compare for real

---
 combinations.hpp | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/combinations.hpp b/combinations.hpp
index c7c36724..ecacfa35 100644
--- a/combinations.hpp
+++ b/combinations.hpp
@@ -45,7 +45,8 @@ namespace iter {
             private:
                 typename std::remove_reference<Container>::type *container_p;
                 std::vector<iterator_type<Container>> indicies;
-                bool not_done = true;
+                int steps = 0;
+                bool done = false;
 
             public:
                 Iterator(Container& in_container, std::size_t n)
@@ -53,7 +54,8 @@ namespace iter {
                     indicies{n}
                 {
                     if (n == 0) {
-                        not_done = false;
+                        this->done = true;
+                        this->steps = -1;
                         return;
                     }
                     size_t inc = 0;
@@ -64,7 +66,7 @@ namespace iter {
                             iter = it;
                             ++inc;
                         } else {
-                            not_done = false;
+                            done = true;
                             break;
                         }
                     }
@@ -102,7 +104,7 @@ namespace iter {
                                     ++inc;
                                 }
                             } else {
-                                not_done = false;
+                                done = true;
                                 break;
                             }
                         } else {
@@ -111,6 +113,7 @@ namespace iter {
                         //we break because none of the rest of the items need
                         //to be incremented
                     }
+                    ++this->steps;
                     return *this;
                 }
 
@@ -120,16 +123,13 @@ namespace iter {
                     return ret;
                 }
 
-                bool operator!=(const Iterator&) const {
-                    //because of the way this is done you have to start from
-                    //the begining of the range and end at the end, you could
-                    //break in the middle of the loop though, it's not
-                    //different from the way that python's works
-                    return not_done;
+                bool operator!=(const Iterator& other) const {
+                    return !(*this == other);
                 }
 
                 bool operator==(const Iterator& other) const {
-                    return !(*this != other);
+                    return (this->done && (this->done == other.done))
+                        || this->steps == other.steps;
                 }
         };
 
@@ -138,7 +138,7 @@ namespace iter {
         }
         
         Iterator end() {
-            return {this->container, this->length};
+            return {this->container, 0};
         }
     };
 

From c3c9d1d029a0d274b5747eedb0912339c5a79f78 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 28 Jan 2015 17:39:50 -0500
Subject: [PATCH 0890/1866] removes `done` datamember from Combinator

just uses the `steps` to figure out when it's done
---
 combinations.hpp | 19 +++++++++++--------
 1 file changed, 11 insertions(+), 8 deletions(-)

diff --git a/combinations.hpp b/combinations.hpp
index ecacfa35..18475099 100644
--- a/combinations.hpp
+++ b/combinations.hpp
@@ -43,10 +43,14 @@ namespace iter {
             public std::iterator<std::input_iterator_tag, CombIteratorDeref>
         {
             private:
+                constexpr static const int COMPLETE = -1;
                 typename std::remove_reference<Container>::type *container_p;
                 std::vector<iterator_type<Container>> indicies;
-                int steps = 0;
-                bool done = false;
+                int steps{};
+
+                bool done() const {
+                    return this->steps == COMPLETE;
+                }
 
             public:
                 Iterator(Container& in_container, std::size_t n)
@@ -54,8 +58,7 @@ namespace iter {
                     indicies{n}
                 {
                     if (n == 0) {
-                        this->done = true;
-                        this->steps = -1;
+                        this->steps = COMPLETE;
                         return;
                     }
                     size_t inc = 0;
@@ -66,7 +69,7 @@ namespace iter {
                             iter = it;
                             ++inc;
                         } else {
-                            done = true;
+                            this->steps = COMPLETE;
                             break;
                         }
                     }
@@ -104,7 +107,7 @@ namespace iter {
                                     ++inc;
                                 }
                             } else {
-                                done = true;
+                                this->steps = COMPLETE;
                                 break;
                             }
                         } else {
@@ -113,7 +116,7 @@ namespace iter {
                         //we break because none of the rest of the items need
                         //to be incremented
                     }
-                    ++this->steps;
+                    if (!this->done()) ++this->steps;
                     return *this;
                 }
 
@@ -128,7 +131,7 @@ namespace iter {
                 }
 
                 bool operator==(const Iterator& other) const {
-                    return (this->done && (this->done == other.done))
+                    return (this->done() && other.done())
                         || this->steps == other.steps;
                 }
         };

From 66bd897805cfac683e27a67f13a3961a277f5e75 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 28 Jan 2015 18:45:41 -0500
Subject: [PATCH 0891/1866] grouper basic test

---
 catchtest/test_grouper.cpp | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 catchtest/test_grouper.cpp

diff --git a/catchtest/test_grouper.cpp b/catchtest/test_grouper.cpp
new file mode 100644
index 00000000..90457ba7
--- /dev/null
+++ b/catchtest/test_grouper.cpp
@@ -0,0 +1,25 @@
+#include <grouper.hpp>
+
+#include <vector>
+#include <array>
+#include <string>
+#include <utility>
+
+#include "helpers.hpp"
+#include "catch.hpp"
+
+using iter::grouper;
+using Vec = std::vector<int>;
+using ResVec = std::vector<Vec>;
+
+TEST_CASE("grouper: basic test", "[grouper]") {
+    Vec ns = {1,2,3,4,5,6};
+    ResVec results;
+    for (auto&& g : grouper(ns, 2)) {
+        results.emplace_back(std::begin(g), std::end(g));
+    }
+
+    ResVec rc = { {1, 2}, {3, 4}, {5, 6} };
+
+    REQUIRE( results == rc );
+}

From 741ad83206a9f3244e5e10f7e603cbdf41af9600 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 28 Jan 2015 18:47:44 -0500
Subject: [PATCH 0892/1866] tests grouper when last group isn't full

---
 catchtest/test_grouper.cpp | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/catchtest/test_grouper.cpp b/catchtest/test_grouper.cpp
index 90457ba7..397ebbd8 100644
--- a/catchtest/test_grouper.cpp
+++ b/catchtest/test_grouper.cpp
@@ -23,3 +23,15 @@ TEST_CASE("grouper: basic test", "[grouper]") {
 
     REQUIRE( results == rc );
 }
+
+TEST_CASE("grouper: len(iterable) % groupsize != 0", "[grouper]") {
+    Vec ns = {1,2,3,4,5,6,7};
+    ResVec results;
+    for (auto&& g : grouper(ns, 3)) {
+        results.emplace_back(std::begin(g), std::end(g));
+    }
+
+    ResVec rc = { {1, 2, 3}, {4, 5, 6}, {7} };
+
+    REQUIRE( results == rc );
+}

From 6759f024c8466e5af6029ad72a9984c07f0166c7 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 28 Jan 2015 18:48:04 -0500
Subject: [PATCH 0893/1866] a lot of changes to grouper

iterator inherits from std::iterator
operator== and postfix ++ for the iterator
no more reference data member in iterator (iterators are assignable)
iterators can actually be compared
no more not_done
operator* doesn't construct a temporary, it lives between calls
---
 grouper.hpp | 107 +++++++++++++++++++++++++---------------------------
 1 file changed, 52 insertions(+), 55 deletions(-)

diff --git a/grouper.hpp b/grouper.hpp
index 4fdcfec7..095edc0f 100644
--- a/grouper.hpp
+++ b/grouper.hpp
@@ -38,84 +38,81 @@ namespace iter {
             friend Grouper<std::initializer_list<T>> grouper(
                     std::initializer_list<T>, std::size_t);
 
+            using DerefVec = std::vector<collection_item_type<Container>>;
         public:
-            class Iterator {
+            class Iterator :
+                public std::iterator<std::input_iterator_tag, DerefVec>
+            {
                 private:
-                    Container& container;
-                    std::vector<iterator_type<Container>> group;
+                    iterator_type<Container> sub_iter;
+                    iterator_type<Container> sub_end;
+                    DerefVec group;
                     std::size_t group_size = 0;
-                    bool not_done = true;
-
-                    using Deref_type =
-                        std::vector<
-                            std::reference_wrapper<
-                                typename std::remove_reference<
-                                    iterator_deref<Container>>::type>>;
 
+                    bool done() const {
+                        return this->group.empty();
+                    }
 
-                public: 
-                    Iterator(Container& c, std::size_t s)
-                        : container(c),
-                        group_size(s) 
-                    {
-                        // if the group size is 0 or the container is empty produce
-                        // nothing
-                        if (this->group_size == 0
-                                || (!(std::begin(this->container)
-                                        != std::end(this->container)))) {
-                            this->not_done = false;
-                            return;
-                        }
-                        std::size_t i = 0;
-                        for (auto iter = std::begin(container);
-                                i < group_size;
-                                ++i, ++iter) {
-                            group.push_back(iter);
+                    void refill_group() {
+                        this->group.clear();
+                        std::size_t i{0};
+                        while (i < group_size
+                                    && this->sub_iter != this->sub_end) {
+                            group.emplace_back(*this->sub_iter);
+                            ++this->sub_iter;
+                            ++i;
                         }
                     }
 
-                    //seems like conclassor is same as sliding_window_iter
-                    Iterator(Container& c)
-                        : container(c)
+                public: 
+                    Iterator(iterator_type<Container> in_iter,
+                            iterator_type<Container> in_end,
+                            std::size_t s)
+                        : sub_iter{std::move(in_iter)},
+                        sub_end{std::move(in_end)},
+                        group_size{s} 
                     {
-                        //creates the end iterator
-                        group.push_back(std::end(container));
+                        this->group.reserve(this->group_size);
+                        this->refill_group();
                     }
 
-                    //plan to conditionally check for existence of +=
-                    Iterator & operator++() {
-                        for (auto & iter : this->group) {
-                            std::advance(iter,this->group_size);
-                        }
+                    Iterator& operator++() {
+                        this->refill_group();
                         return *this;
                     }
 
-                    bool operator!=(const Iterator &) const {
-                        return this->not_done;
+                    Iterator operator++(int) {
+                        auto ret = *this;
+                        ++*this;
+                        return ret;
                     }
 
-                    Deref_type operator*() {
-                        Deref_type vec;
-                        for (auto i : this->group) {
-                            if(!(i != std::end(this->container))) {
-                                this->not_done = false;
-                                break;
-                            } 
-                            //if the group is at the end the vector will be smaller 
-                            else { 
-                                vec.push_back(*i);
-                            }
-                        }
-                        return vec;
+                    bool operator!=(const Iterator& other) const {
+                        return !(*this == other);
+                    }
+
+                    bool operator==(const Iterator& other) const {
+                        return this->done() == other.done()
+                            && (this->done()
+                                    || !(this->sub_iter != other.sub_iter));
+                    }
+
+
+                    DerefVec& operator*() {
+                        return this->group;
                     }
             };
 
             Iterator begin() {
-                return {this->container, group_size};
+                return {std::begin(this->container),
+                    std::end(this->container),
+                    group_size};
             }
 
             Iterator end() {
-                return {this->container};
+                return {std::end(this->container),
+                    std::end(this->container),
+                    group_size};
             }
     };
 

From 2982bd74aee460c5967bca629f96dc1bc9d56c26 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 28 Jan 2015 18:51:52 -0500
Subject: [PATCH 0894/1866] builds grouper test

---
 catchtest/SConstruct | 1 +
 1 file changed, 1 insertion(+)

diff --git a/catchtest/SConstruct b/catchtest/SConstruct
index f05eecea..42bafa24 100644
--- a/catchtest/SConstruct
+++ b/catchtest/SConstruct
@@ -27,6 +27,7 @@ progs = Split(
     filter
     filterfalse
     groupby
+    grouper
     imap
     permutations
     powerset

From 91cb5f4222324a85f07b2c67cdbc6da5e80d2ad4 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 28 Jan 2015 18:58:16 -0500
Subject: [PATCH 0895/1866] tests grouper iterator comparisons

---
 catchtest/test_grouper.cpp | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/catchtest/test_grouper.cpp b/catchtest/test_grouper.cpp
index 397ebbd8..917460c1 100644
--- a/catchtest/test_grouper.cpp
+++ b/catchtest/test_grouper.cpp
@@ -35,3 +35,15 @@ TEST_CASE("grouper: len(iterable) % groupsize != 0", "[grouper]") {
 
     REQUIRE( results == rc );
 }
+
+TEST_CASE("grouper: iterators can be compared", "[grouper]") {
+    Vec ns = {1,2,3,4,5,6,7};
+    auto g = grouper(ns, 3);
+    auto it = std::begin(g);
+    REQUIRE( it == std::begin(g) );
+    REQUIRE_FALSE( it != std::begin(g) );
+    ++it;
+    REQUIRE( it != std::begin(g) );
+    REQUIRE_FALSE( it == std::begin(g) );
+}
+

From 79d0953b4296140d5028aa4892362825dde6377b Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 28 Jan 2015 19:01:35 -0500
Subject: [PATCH 0896/1866] simplifies combinatons iterator comparison

---
 combinations.hpp | 9 ++-------
 1 file changed, 2 insertions(+), 7 deletions(-)

diff --git a/combinations.hpp b/combinations.hpp
index 18475099..f42cb778 100644
--- a/combinations.hpp
+++ b/combinations.hpp
@@ -48,10 +48,6 @@ namespace iter {
                 std::vector<iterator_type<Container>> indicies;
                 int steps{};
 
-                bool done() const {
-                    return this->steps == COMPLETE;
-                }
-
             public:
                 Iterator(Container& in_container, std::size_t n)
                     : container_p{&in_container},
@@ -116,7 +112,7 @@ namespace iter {
                         //we break because none of the rest of the items need
                         //to be incremented
                     }
-                    if (!this->done()) ++this->steps;
+                    if (this->steps != COMPLETE) ++this->steps;
                     return *this;
                 }
 
@@ -131,8 +127,7 @@ namespace iter {
                 }
 
                 bool operator==(const Iterator& other) const {
-                    return (this->done() && other.done())
-                        || this->steps == other.steps;
+                    return this->steps == other.steps;
                 }
         };
 

From c3574a2394b289dc8f3f47fe8d104736554674c3 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 28 Jan 2015 19:03:07 -0500
Subject: [PATCH 0897/1866] tests grouper with group size of 0

---
 catchtest/test_grouper.cpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/catchtest/test_grouper.cpp b/catchtest/test_grouper.cpp
index 917460c1..3397b307 100644
--- a/catchtest/test_grouper.cpp
+++ b/catchtest/test_grouper.cpp
@@ -47,3 +47,8 @@ TEST_CASE("grouper: iterators can be compared", "[grouper]") {
     REQUIRE_FALSE( it == std::begin(g) );
 }
 
+TEST_CASE("grouper: size 0 is empty", "[grouper]") {
+    Vec ns{1, 2, 3};
+    auto g = grouper(ns, 0);
+    REQUIRE( std::begin(g) == std::end(g) );
+}

From 57f1e094b2160d1d79cafe885ceb29f0d0faab93 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 28 Jan 2015 19:07:53 -0500
Subject: [PATCH 0898/1866] tests grouper with empty iterable

---
 catchtest/test_grouper.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/catchtest/test_grouper.cpp b/catchtest/test_grouper.cpp
index 3397b307..27032464 100644
--- a/catchtest/test_grouper.cpp
+++ b/catchtest/test_grouper.cpp
@@ -52,3 +52,9 @@ TEST_CASE("grouper: size 0 is empty", "[grouper]") {
     auto g = grouper(ns, 0);
     REQUIRE( std::begin(g) == std::end(g) );
 }
+
+TEST_CASE("grouper: empty iterable gives empty grouper", "[grouper]") {
+    Vec ns{};
+    auto g = grouper(ns, 1);
+    REQUIRE( std::begin(g) == std::end(g) );
+}

From a5b5918b3b9b740d3150dc274b9740dc46ecfa76 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 28 Jan 2015 19:37:42 -0500
Subject: [PATCH 0899/1866] makes comp_w_repl iterators actually compare

---
 combinations_with_replacement.hpp | 23 +++++++++++++----------
 1 file changed, 13 insertions(+), 10 deletions(-)

diff --git a/combinations_with_replacement.hpp b/combinations_with_replacement.hpp
index 62e24db8..8a657d7c 100644
--- a/combinations_with_replacement.hpp
+++ b/combinations_with_replacement.hpp
@@ -50,15 +50,19 @@ namespace iter {
                     CombIteratorDeref>
             {
                private:
+                   constexpr static const int COMPLETE = -1;
                    typename std::remove_reference<Container>::type *container_p;
                    std::vector<iterator_type<Container>> indicies;
-                   bool not_done;
+                   int steps;
 
                public:
                    Iterator(Container& in_container, std::size_t n)
                        : container_p{&in_container},
                        indicies(n, std::begin(in_container)),
-                       not_done{n != 0}
+                       steps{(std::begin(in_container)
+                               != std::end(in_container)
+                               && n)
+                           ? 0 : COMPLETE}
                    { }
 
                    CombIteratorDeref operator*() {
@@ -83,7 +87,7 @@ namespace iter {
                                        (*down) = dumb_next(*(iter + 1)); 
                                    }
                                } else {
-                                   not_done = false;
+                                   this->steps = COMPLETE;
                                    break;
                                }
                            } else {
@@ -92,6 +96,9 @@ namespace iter {
                                break; 
                            }
                        }
+                       if (this->steps != COMPLETE) {
+                           ++this->steps;
+                       }
                        return *this;
                    }
 
@@ -102,16 +109,12 @@ namespace iter {
                        return ret;
                    }
 
-                   bool operator!=(const Iterator&) const {
-                       //because of the way this is done you have to start from
-                       //the begining of the range and end at the end, you
-                       //could break in the middle of the loop though, it's not
-                       //different from the way that python's works
-                       return not_done;
+                   bool operator!=(const Iterator& other) const {
+                       return !(*this == other);
                    }
 
                    bool operator==(const Iterator& other) const {
-                       return !(*this != other);
+                       return this->steps == other.steps;
                    }
 
            };

From 4f5628c00bf0f430adb56e2752998760a31dd072 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Wed, 28 Jan 2015 19:42:24 -0500
Subject: [PATCH 0900/1866] test that comb_with_repl moves and binds correctly

---
 .../test_combinations_with_replacement.cpp    | 35 +++++++++++++++----
 1 file changed, 28 insertions(+), 7 deletions(-)

diff --git a/catchtest/test_combinations_with_replacement.cpp b/catchtest/test_combinations_with_replacement.cpp
index 6677009e..bfa688f1 100644
--- a/catchtest/test_combinations_with_replacement.cpp
+++ b/catchtest/test_combinations_with_replacement.cpp
@@ -10,30 +10,38 @@
 
 using iter::combinations_with_replacement;
 using itertest::BasicIterable;
-using CharCombSet = std::multiset<std::vector<char>>;
+using CharCombSet = std::vector<std::vector<char>>;
 
 TEST_CASE("combinations_with_replacement: Simple combination",
         "[combinations_with_replacement]") {
     std::string s{"ABC"};
     CharCombSet sc;
     for (auto v : combinations_with_replacement(s, 2)) {
-        std::vector<char> vcopy(std::begin(v), std::end(v));
-        sc.insert(vcopy);
+        sc.emplace_back(std::begin(v), std::end(v));
     }
     CharCombSet ans =
         {{'A','A'}, {'A','B'}, {'A','C'}, {'B','B'}, {'B','C'}, {'C','C'}};
     REQUIRE( ans == sc );
 }
 
-
+TEST_CASE("combinations_with_replacement: iterators can be compared",
+        "[combinations_with_replacement]") {
+    std::string s{"ABCD"};
+    auto c = combinations_with_replacement(s, 2);
+    auto it = std::begin(c);
+    REQUIRE( it == std::begin(c) );
+    REQUIRE_FALSE( it != std::begin(c) );
+    ++it;
+    REQUIRE( it != std::begin(c) );
+    REQUIRE_FALSE( it == std::begin(c) );
+}
 
 TEST_CASE("combinations_with_replacement: big size is no problem",
         "[combinations_with_replacement]") {
     std::string s{"AB"};
     CharCombSet sc;
     for (auto v : combinations_with_replacement(s, 3)) {
-        std::vector<char> vcopy(std::begin(v), std::end(v));
-        sc.insert(vcopy);
+        sc.emplace_back(std::begin(v), std::end(v));
     }
     CharCombSet ans =
         {{'A', 'A', 'A'}, {'A', 'A', 'B'}, {'A', 'B', 'B'}, {'B', 'B', 'B'}};
@@ -47,8 +55,21 @@ TEST_CASE("combinations_with_replacement: 0 size is empty",
     REQUIRE( std::begin(cwr) == std::end(cwr) );
 }
 
+TEST_CASE("combinations_with_replacement: binds to lvalues, moves rvalues",
+        "[combinations_with_replacement]") {
+    BasicIterable<char> bi{'x', 'y', 'z'};
+    SECTION("binds to lvalues") {
+        combinations_with_replacement(bi, 1);
+        REQUIRE_FALSE( bi.was_moved_from() );
+    }
+    SECTION("moves rvalues") {
+        combinations_with_replacement(std::move(bi), 1);
+        REQUIRE( bi.was_moved_from() );
+    }
+}
 
-TEST_CASE("combinations_with_replacement: doesn't move or copy elements of iterable",
+TEST_CASE("combinations_with_replacement: "
+        "doesn't move or copy elements of iterable",
         "[combinations_with_replacement]") {
     constexpr itertest::SolidInt arr[] = {{6}, {7}, {8}};
     for (auto&& i : combinations_with_replacement(arr, 1)) {

From 5eb242eaf3c85f72447832782a94346c0737dba9 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 1 Feb 2015 17:09:34 -0500
Subject: [PATCH 0901/1866] tests permutations iterator comparisons

---
 catchtest/test_permutations.cpp | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/catchtest/test_permutations.cpp b/catchtest/test_permutations.cpp
index d6af74fb..23eec08f 100644
--- a/catchtest/test_permutations.cpp
+++ b/catchtest/test_permutations.cpp
@@ -35,6 +35,25 @@ TEST_CASE("permutations: empty sequence has one empy permutation",
     REQUIRE( it == std::end(p) );
 }
 
+TEST_CASE("permutations: iterators can be compared", "[permutations]") {
+    const std::vector<int> ns = {1, 2};
+    auto p = permutations(ns);
+    auto it = std::begin(p);
+    REQUIRE( it == std::begin(p) );
+    REQUIRE_FALSE( it != std::begin(p) );
+    REQUIRE( it != std::end(p) );
+    REQUIRE_FALSE( it == std::end(p) );
+    ++it;
+    REQUIRE_FALSE( it == std::begin(p) );
+    REQUIRE( it != std::begin(p) );
+    REQUIRE_FALSE( it == std::end(p) );
+    REQUIRE( it != std::end(p) );
+    ++it;
+    REQUIRE( it == std::end(p) );
+    REQUIRE_FALSE( it != std::end(p) );
+}
+
+
 TEST_CASE("permutations: binds to lvalues, moves rvalues", "[permutations]") {
     itertest::BasicIterable<int> bi{1, 2};
     SECTION("binds to lvalues") {

From a6e586bdff87cf3a69084d33a377c540c570a7b6 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 1 Feb 2015 17:09:52 -0500
Subject: [PATCH 0902/1866] makes permutations iterators actually comparable

---
 permutations.hpp | 33 +++++++++++++++++++++------------
 1 file changed, 21 insertions(+), 12 deletions(-)

diff --git a/permutations.hpp b/permutations.hpp
index 97ae6639..0db2af62 100644
--- a/permutations.hpp
+++ b/permutations.hpp
@@ -27,17 +27,22 @@ namespace iter {
                 : public std::iterator<std::input_iterator_tag, Permutable>
             {
                 private:
+                    constexpr static const int COMPLETE = -1;
+
                     Permutable working_set;
-                    bool is_not_last = true;
+                    int steps{};
 
                 public:
-                    Iterator(Container& c)
+                    Iterator(iterator_type<Container> sub_iter,
+                            iterator_type<Container> sub_end)
+                        : steps{ sub_iter != sub_end ? 0 : COMPLETE }
                     {
                         // done like this instead of using vector ctor with
                         // two iterators because that causes a substitution
                         // failure when the iterator is minimal
-                        for (auto&& i : c) {
-                            working_set.emplace_back(i);
+                        while (sub_iter != sub_end) {
+                            this->working_set.emplace_back(*sub_iter);
+                            ++sub_iter;
                         }
                         std::sort(std::begin(working_set),
                                 std::end(working_set));
@@ -48,9 +53,11 @@ namespace iter {
                     }
 
                     Iterator& operator++() {
-                        is_not_last =
-                            std::next_permutation(std::begin(working_set),
-                                    std::end(working_set));
+                        ++this->steps;
+                        if (!std::next_permutation(std::begin(working_set),
+                                    std::end(working_set))) {
+                            this->steps = COMPLETE;
+                        }
                         return *this;
                     }
 
@@ -60,21 +67,23 @@ namespace iter {
                         return ret;
                     }
 
-                    bool operator!=(const Iterator&) const {
-                        return is_not_last;
+                    bool operator!=(const Iterator& other) const {
+                        return !(*this == other);
                     }
 
                     bool operator==(const Iterator& other) const {
-                        return !(*this != other);
+                        return this->steps == other.steps;
                     }
             };
 
             Iterator begin() {
-                return {this->container};
+                return {std::begin(this->container),
+                    std::end(this->container)};
             }
 
             Iterator end() {
-                return {this->container};
+                return {std::end(this->container),
+                    std::end(this->container)};
             }
 
 

From fb438981ed1d2b4b3d2d0dbdaa35c5e8ba73ad5e Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 1 Feb 2015 17:24:00 -0500
Subject: [PATCH 0903/1866] tests that powerset iterators can be compared

---
 catchtest/test_powerset.cpp | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/catchtest/test_powerset.cpp b/catchtest/test_powerset.cpp
index 7c22d558..1b4faeb7 100644
--- a/catchtest/test_powerset.cpp
+++ b/catchtest/test_powerset.cpp
@@ -31,6 +31,27 @@ TEST_CASE("powerset: empty sequence gives only empty set", "[powerset]") {
     REQUIRE( it == std::end(ps) );
 }
 
+TEST_CASE("powerset: iterators can be compared", "[powerset]") {
+    const std::vector<int> ns = {1, 2};
+    auto p = powerset(ns);
+    auto it = std::begin(p);
+    REQUIRE( it == std::begin(p) );
+    REQUIRE_FALSE( it != std::begin(p) );
+    REQUIRE( it != std::end(p) );
+    REQUIRE_FALSE( it == std::end(p) );
+    ++it;
+    REQUIRE_FALSE( it == std::begin(p) );
+    REQUIRE( it != std::begin(p) );
+    REQUIRE_FALSE( it == std::end(p) );
+    REQUIRE( it != std::end(p) );
+    ++it;
+    ++it;
+    ++it;
+    REQUIRE( it == std::end(p) );
+    REQUIRE_FALSE( it != std::end(p) );
+}
+
+
 TEST_CASE("powerset: binds to lvalues, moves rvalues", "[powerset]") {
     itertest::BasicIterable<int> bi{1, 2};
     SECTION("binds to lvalues") {

From 91ea563d546c92dac8c741483dcc0e22dbbf6dc5 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 1 Feb 2015 17:28:48 -0500
Subject: [PATCH 0904/1866] removes commented out code

---
 groupby.hpp | 8 --------
 1 file changed, 8 deletions(-)

diff --git a/groupby.hpp b/groupby.hpp
index 718b4abc..81332e92 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -189,14 +189,6 @@ namespace iter {
 
                             bool operator!=(const GroupIterator&) const {
                                 return !this->group.completed;
-#if 0
-                                if (this->not_at_end()) {
-                                    return true;
-                                } else {
-                                    this->group.completed = true;
-                                    return false;
-                                }
-#endif
                             }
 
                             bool operator==(const GroupIterator& other) const {

From 00b3bfe7f2742e09f241c2523a3fc98658a355fb Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 1 Feb 2015 17:33:07 -0500
Subject: [PATCH 0905/1866] removes reference member in groupiterator

So that the iterators are assignable.
---
 groupby.hpp | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/groupby.hpp b/groupby.hpp
index 81332e92..3af031d5 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -171,24 +171,24 @@ namespace iter {
                     {
                         private:
                             const key_func_ret key;
-                            const Group& group;
+                            const Group* group_p;
 
                             bool not_at_end() {
-                                return !this->group.owner.exhausted()&&
-                                    this->group.owner.next_key() == this->key;
+                                return !this->group_p->owner.exhausted()&&
+                                    this->group_p->owner.next_key() == this->key;
                             }
 
                         public:
-                            GroupIterator(const Group& group,
+                            GroupIterator(const Group& in_group,
                                           key_func_ret key)
                                 : key{key},
-                                group{group}
+                                group_p{&in_group}
                             { }
 
                             GroupIterator(const GroupIterator&) = default;
 
                             bool operator!=(const GroupIterator&) const {
-                                return !this->group.completed;
+                                return !this->group_p->completed;
                             }
 
                             bool operator==(const GroupIterator& other) const {
@@ -196,9 +196,9 @@ namespace iter {
                             }
 
                             GroupIterator& operator++() {
-                                this->group.owner.increment_iterator();
+                                this->group_p->owner.increment_iterator();
                                 if (!this->not_at_end()) {
-                                    this->group.completed = true;
+                                    this->group_p->completed = true;
                                 }
                                 return *this;
                             }
@@ -210,7 +210,7 @@ namespace iter {
                             }
 
                             iterator_deref<Container> operator*() {
-                                return this->group.owner.current();
+                                return this->group_p->owner.current();
                             }
                     };
 

From 91b90b9b21ab2a85ef0938bc2ccb1cf8af06d82b Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 1 Feb 2015 17:52:01 -0500
Subject: [PATCH 0906/1866] actually compares in groupiter !=

once the group is complete, it's marked as completed and the iterator
has its pointer set to nullptr.  An end iterator always has a nullptr.
---
 groupby.hpp | 20 +++++++++++---------
 1 file changed, 11 insertions(+), 9 deletions(-)

diff --git a/groupby.hpp b/groupby.hpp
index 3af031d5..e5ad6988 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -152,7 +152,8 @@ namespace iter {
                         }
                     }
                            
-                    // movable, non-copyable
+                    // move-constructible, non-copy-constructible,
+                    // non-assignable
                     Group() = delete;
                     Group(const Group&) = delete;
                     Group& operator=(const Group&) = delete;
@@ -171,7 +172,7 @@ namespace iter {
                     {
                         private:
                             const key_func_ret key;
-                            const Group* group_p;
+                            const Group *group_p;
 
                             bool not_at_end() {
                                 return !this->group_p->owner.exhausted()&&
@@ -179,26 +180,27 @@ namespace iter {
                             }
 
                         public:
-                            GroupIterator(const Group& in_group,
+                            GroupIterator(const Group *in_group_p,
                                           key_func_ret key)
                                 : key{key},
-                                group_p{&in_group}
+                                group_p{in_group_p}
                             { }
 
                             GroupIterator(const GroupIterator&) = default;
 
-                            bool operator!=(const GroupIterator&) const {
-                                return !this->group_p->completed;
+                            bool operator!=(const GroupIterator& other) const {
+                                return !(*this == other);
                             }
 
                             bool operator==(const GroupIterator& other) const {
-                                return !(*this != other);
+                                return this->group_p == other.group_p;
                             }
 
                             GroupIterator& operator++() {
                                 this->group_p->owner.increment_iterator();
                                 if (!this->not_at_end()) {
                                     this->group_p->completed = true;
+                                    this->group_p = nullptr;
                                 }
                                 return *this;
                             }
@@ -215,11 +217,11 @@ namespace iter {
                     };
 
                     GroupIterator begin() {
-                        return {*this, key};
+                        return {this, key};
                     }
 
                     GroupIterator end() {
-                        return {*this, key};
+                        return {nullptr, key};
                     }
 
             };

From edcc49d3a7354f482c3c91519bb1fda20ec186ec Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 1 Feb 2015 17:54:41 -0500
Subject: [PATCH 0907/1866] removes const on key it groupiterator

---
 groupby.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/groupby.hpp b/groupby.hpp
index e5ad6988..ce12ae6c 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -171,7 +171,7 @@ namespace iter {
                                 iterator_traits_deref<Container>>
                     {
                         private:
-                            const key_func_ret key;
+                            key_func_ret key;
                             const Group *group_p;
 
                             bool not_at_end() {

From 7106a45979f13c2c28cf4ee0f22f9ace2a4737f9 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 1 Feb 2015 17:57:54 -0500
Subject: [PATCH 0908/1866] const corrector in groupiter and group

---
 groupby.hpp | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/groupby.hpp b/groupby.hpp
index ce12ae6c..c9cb15f2 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -136,7 +136,7 @@ namespace iter {
                     // The move constructor sets the rvalue's completed
                     // attribute to true, so its destructor doesn't do anything
                     // when called.
-                    mutable bool completed = false;
+                    bool completed = false;
 
                     Group(Iterator& owner, key_func_ret key) :
                         owner(owner),
@@ -172,7 +172,7 @@ namespace iter {
                     {
                         private:
                             key_func_ret key;
-                            const Group *group_p;
+                            Group *group_p;
 
                             bool not_at_end() {
                                 return !this->group_p->owner.exhausted()&&
@@ -180,14 +180,12 @@ namespace iter {
                             }
 
                         public:
-                            GroupIterator(const Group *in_group_p,
+                            GroupIterator(Group *in_group_p,
                                           key_func_ret key)
                                 : key{key},
                                 group_p{in_group_p}
                             { }
 
-                            GroupIterator(const GroupIterator&) = default;
-
                             bool operator!=(const GroupIterator& other) const {
                                 return !(*this == other);
                             }

From 8aefcc7e71feb56e67bb451ce8b83ed102e74179 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 1 Feb 2015 18:04:00 -0500
Subject: [PATCH 0909/1866] uses std::result_of for key_func_ret

---
 groupby.hpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/groupby.hpp b/groupby.hpp
index c9cb15f2..740a5162 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -3,6 +3,7 @@
 
 #include "iterbase.hpp"
 
+#include <type_traits>
 #include <utility>
 #include <iterator>
 #include <initializer_list>
@@ -31,9 +32,8 @@ namespace iter {
             friend GroupBy<std::initializer_list<T>, KF> groupby(
                     std::initializer_list<T>, KF);
 
-            using key_func_ret =
-                decltype(std::declval<KeyFunc>()(
-                            std::declval<iterator_deref<Container>>()));
+            using key_func_ret = typename
+                std::result_of<KeyFunc(iterator_deref<Container>)>::type;
 
             GroupBy(Container&& container, KeyFunc key_func)
                 : container(std::forward<Container>(container)),

From 14b3cd49982d3a3a9dc6fc0acb150c6df3f136e2 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 1 Feb 2015 19:40:59 -0500
Subject: [PATCH 0910/1866] tests groupby with different functor types

---
 catchtest/test_groupby.cpp | 33 ++++++++++++++++++++++++++++-----
 1 file changed, 28 insertions(+), 5 deletions(-)

diff --git a/catchtest/test_groupby.cpp b/catchtest/test_groupby.cpp
index a1fbae32..6b67f16d 100644
--- a/catchtest/test_groupby.cpp
+++ b/catchtest/test_groupby.cpp
@@ -15,20 +15,43 @@ namespace {
         return s.size();
     }
 
+    struct Sizer {
+        int operator()(const std::string& s) {
+            return s.size();
+        }
+    };
+
     const std::vector<std::string> vec = {
         "hi", "ab", "ho",
         "abc", "def",
         "abcde", "efghi"
     };
-
 }
 
-TEST_CASE("groupby: groups words by length") {
+TEST_CASE("groupby: works with lambda, callable, and function pointer") {
     std::vector<int> keys;
     std::vector<std::vector<std::string>> groups;
-    for (auto&& gb : groupby(vec, &length)) {
-        keys.push_back(gb.first);
-        groups.emplace_back(std::begin(gb.second), std::end(gb.second));
+
+    SECTION("Function pointer") {
+        for (auto&& gb : groupby(vec, length)) {
+            keys.push_back(gb.first);
+            groups.emplace_back(std::begin(gb.second), std::end(gb.second));
+        }
+    }
+
+    SECTION("Callable object") {
+        for (auto&& gb : groupby(vec, Sizer{})) {
+            keys.push_back(gb.first);
+            groups.emplace_back(std::begin(gb.second), std::end(gb.second));
+        }
+    }
+
+    SECTION("lambda function") {
+        for (auto&& gb : groupby(vec, 
+                    [](const std::string& s){return s.size();})) {
+            keys.push_back(gb.first);
+            groups.emplace_back(std::begin(gb.second), std::end(gb.second));
+        }
     }
 
     const std::vector<int> kc = {2, 3, 5};

From 46234fabb40c3c78a8adba435447d5e0353b6124 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 1 Feb 2015 20:06:56 -0500
Subject: [PATCH 0911/1866] iterators are actually compared

---
 groupby.hpp | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/groupby.hpp b/groupby.hpp
index 740a5162..42768202 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -75,11 +75,10 @@ namespace iter {
                     { }
 
                     KeyGroupPair operator*() {
-                        return KeyGroupPair(
-                                this->key_func(*this->sub_iter),
-                                Group(
-                                    *this, 
-                                    this->key_func(*this->sub_iter)));
+                        return {
+                            this->key_func(*this->sub_iter),
+                            Group{*this, this->key_func(*this->sub_iter)}
+                        };
                     }
 
                     Iterator& operator++() { 
@@ -92,8 +91,8 @@ namespace iter {
                         return ret;
                     }
 
-                    bool operator!=(const Iterator&) const {
-                        return !this->exhausted();
+                    bool operator!=(const Iterator& other) const {
+                        return this->sub_iter != other.sub_iter;
                     }
 
                     bool operator==(const Iterator& other) const {

From 25342c0cfdc62b006686df272bdfec4f39d66558 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 1 Feb 2015 20:58:37 -0500
Subject: [PATCH 0912/1866] combinations build vectors in * instead of ++

---
 combinations.hpp                  | 24 +++++++++++++++++-------
 combinations_with_replacement.hpp | 21 ++++++++++++++-------
 2 files changed, 31 insertions(+), 14 deletions(-)

diff --git a/combinations.hpp b/combinations.hpp
index f42cb778..4f560ef1 100644
--- a/combinations.hpp
+++ b/combinations.hpp
@@ -46,8 +46,16 @@ namespace iter {
                 constexpr static const int COMPLETE = -1;
                 typename std::remove_reference<Container>::type *container_p;
                 std::vector<iterator_type<Container>> indicies;
+                CombIteratorDeref working_set;
                 int steps{};
 
+                void compute_working_set() {
+                    this->working_set.clear();
+                    for (auto&& i : this->indicies) {
+                        this->working_set.emplace_back(*i);
+                    }
+                }
+
             public:
                 Iterator(Container& in_container, std::size_t n)
                     : container_p{&in_container},
@@ -69,14 +77,13 @@ namespace iter {
                             break;
                         }
                     }
+                    if (this->steps != COMPLETE) {
+                        this->compute_working_set();
+                    }
                 }
 
-                CombIteratorDeref operator*() {
-                    CombIteratorDeref values;
-                    for (auto i : indicies) {
-                        values.push_back(*i);
-                    }
-                    return values;
+                CombIteratorDeref& operator*() {
+                    return this->working_set;
                 }
 
 
@@ -112,7 +119,10 @@ namespace iter {
                         //we break because none of the rest of the items need
                         //to be incremented
                     }
-                    if (this->steps != COMPLETE) ++this->steps;
+                    if (this->steps != COMPLETE) {
+                        ++this->steps;
+                        this->compute_working_set();
+                    }
                     return *this;
                 }
 
diff --git a/combinations_with_replacement.hpp b/combinations_with_replacement.hpp
index 8a657d7c..429a0c5a 100644
--- a/combinations_with_replacement.hpp
+++ b/combinations_with_replacement.hpp
@@ -53,8 +53,16 @@ namespace iter {
                    constexpr static const int COMPLETE = -1;
                    typename std::remove_reference<Container>::type *container_p;
                    std::vector<iterator_type<Container>> indicies;
+                   CombIteratorDeref working_set;
                    int steps;
 
+                   void compute_working_set() {
+                       this->working_set.clear();
+                       for (auto&& i : indicies) {
+                           this->working_set.emplace_back(*i);
+                       }
+                   }
+
                public:
                    Iterator(Container& in_container, std::size_t n)
                        : container_p{&in_container},
@@ -63,14 +71,12 @@ namespace iter {
                                != std::end(in_container)
                                && n)
                            ? 0 : COMPLETE}
-                   { }
+                   {
+                       this->compute_working_set();
+                   }
 
-                   CombIteratorDeref operator*() {
-                       std::vector<collection_item_type<Container>> values;
-                       for (auto i : indicies) {
-                           values.push_back(*i);
-                       }
-                       return values;
+                   CombIteratorDeref& operator*() {
+                       return this->working_set;
                    }
 
 
@@ -98,6 +104,7 @@ namespace iter {
                        }
                        if (this->steps != COMPLETE) {
                            ++this->steps;
+                           this->compute_working_set();
                        }
                        return *this;
                    }

From fefc24241da036352d8cb45ef18304a45985f455 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 8 Feb 2015 12:58:45 -0500
Subject: [PATCH 0913/1866] adds test for iteratoriterator

---
 catchtest/test_iteratoriterator.cpp | 54 +++++++++++++++++++++++++++++
 1 file changed, 54 insertions(+)
 create mode 100644 catchtest/test_iteratoriterator.cpp

diff --git a/catchtest/test_iteratoriterator.cpp b/catchtest/test_iteratoriterator.cpp
new file mode 100644
index 00000000..e034cc71
--- /dev/null
+++ b/catchtest/test_iteratoriterator.cpp
@@ -0,0 +1,54 @@
+#include <iteratoriterator.hpp>
+
+#include <vector>
+#include <string>
+
+#include "catch.hpp"
+
+using iter::IterIterWrapper;
+
+TEST_CASE("Iterator over a vector of vector iterators", "[iteratoriterator]") {
+    using std::vector;
+    vector<int> v = {2, 4, 6, 8};
+
+    IterIterWrapper<vector<vector<int>::iterator>> itr;
+    itr.get().push_back(std::begin(v) + 1);
+    itr.get().push_back(std::end(v) - 1);
+    itr.get().push_back(std::begin(v));
+
+    auto it = std::begin(itr);
+    REQUIRE( *it == 4 );
+    REQUIRE( it != std::end(itr) );
+    ++it;
+    REQUIRE( *it == 8 );
+    it++;
+    REQUIRE( *it == 2 );
+    ++it;
+    REQUIRE( it == std::end(itr) );
+
+    REQUIRE( itr[0] == 4 );
+    REQUIRE( itr[1] == 8 );
+    REQUIRE( itr[2] == 2 );
+
+    auto rit = itr.rbegin();
+
+    REQUIRE( *rit == 2 );
+    REQUIRE( rit != itr.rend() );
+    ++rit;
+    REQUIRE( *rit == 8 );
+    ++rit;
+    REQUIRE( *rit == 4 );
+    ++rit;
+    REQUIRE( rit == itr.rend() );
+}
+
+TEST_CASE("IteratorIterator operator->", "[iteratoriterator]") {
+    using std::vector;
+    using std::string;
+    vector<string> v = {"hello", "everyone"};
+    IterIterWrapper<vector<vector<string>::iterator>> itritr;
+    itritr.get().push_back(std::end(v) - 1);
+    itritr.get().push_back(std::begin(v));
+    auto it = std::begin(itritr);
+    REQUIRE( it->size() == 8 );
+}

From 8d56fd47a32511c9671b2fe74a98238504a6cebd Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 8 Feb 2015 12:58:58 -0500
Subject: [PATCH 0914/1866] adds iteratoriterator

---
 iteratoriterator.hpp | 219 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 219 insertions(+)
 create mode 100644 iteratoriterator.hpp

diff --git a/iteratoriterator.hpp b/iteratoriterator.hpp
new file mode 100644
index 00000000..cb0d0143
--- /dev/null
+++ b/iteratoriterator.hpp
@@ -0,0 +1,219 @@
+#ifndef ITERATOR_ITERATOR_HPP_
+#define ITERATOR_ITERATOR_HPP_
+
+#include "iterbase.hpp"
+#include "zip.hpp"
+#include <iterator>
+#include <type_traits>
+#include <utility>
+
+// IterIterWrapper and IteratorIterator provide a means to have a container
+// of iterators act like a container of the pointed to objects. This is useful
+// for combinatorics and similar itertools which need to keep track of
+// more than one element at a time.
+// an IterIterWrapper<some_collection_type<collection<T>::iterator>>
+// behave like some_collection<T> when iterated over or indexed
+
+namespace iter {
+    template <typename Iter,
+         typename Diff =typename std::iterator_traits<Iter>::difference_type>
+    class IteratorIterator : public std::iterator<
+        std::random_access_iterator_tag,
+        typename std::iterator_traits<Iter>::value_type,
+        Diff,
+        typename std::iterator_traits<Iter>::pointer,
+        typename std::iterator_traits<Iter>::reference
+     >
+    {
+        static_assert(std::is_same<
+            typename std::iterator_traits<Iter>::iterator_category,
+            std::random_access_iterator_tag>::value,
+            "IteratorIterator only works with random access iterators");
+        private:
+            Iter sub_iter;
+        public:
+            IteratorIterator() = default;
+            IteratorIterator(const Iter& it)
+                : sub_iter{it}
+            { }
+
+            bool operator==(const IteratorIterator& other) const {
+                return !(*this != other);
+            }
+
+            bool operator!=(const IteratorIterator& other) const {
+                return this->sub_iter != other.sub_iter;
+            }
+
+            IteratorIterator& operator++() {
+                ++this->sub_iter;
+                return *this;
+            }
+
+            IteratorIterator operator++(int) {
+                auto ret = *this;
+                ++*this;
+                return ret;
+            }
+
+            IteratorIterator& operator--() {
+                --this->sub_iter;
+                return *this;
+            }
+
+            IteratorIterator operator--(int) {
+                auto ret = *this;
+                --*this;
+                return ret;
+            }
+
+            auto operator*() -> decltype(**sub_iter) {
+                return **this->sub_iter;
+            }
+
+            auto operator->() -> decltype(*sub_iter) {
+                return *this->sub_iter;
+            }
+            
+
+            IteratorIterator& operator+=(Diff n) {
+                this->sub_iter += n;
+                return *this;
+            }
+
+            IteratorIterator operator+(Diff n) const {
+                auto it = *this;
+                it += n;
+                return it;
+            }
+
+            friend IteratorIterator operator+(Diff n, IteratorIterator it) {
+                it += n;
+                return it;
+            }
+
+            IteratorIterator& operator-=(Diff n) {
+                this->sub_iter -= n;
+                return *this;
+            }
+
+            IteratorIterator operator-(Diff n) const {
+                auto it = *this;
+                it -= n;
+                return it;
+            }
+
+            friend IteratorIterator operator-(Diff n, IteratorIterator it) {
+                it -= n;
+                return it;
+            }
+
+            Diff operator-(const IteratorIterator& rhs) const {
+                return this->sub_iter - rhs.sub_iter;
+            }
+
+            auto operator[](Diff idx) -> decltype(*sub_iter[idx]) {
+                return *sub_iter[idx];
+            }
+
+            bool operator<(const IteratorIterator& rhs) const {
+                return this->sub_iter < rhs.sub_iter;
+            }
+
+            bool operator>(const IteratorIterator& rhs) const {
+                return this->sub_iter > rhs.sub_iter;
+            }
+
+            bool operator<=(const IteratorIterator& rhs) const {
+                return this->sub_iter <= rhs.sub_iter;
+            }
+
+            bool operator>=(const IteratorIterator& rhs) const {
+                return this->sub_iter >= rhs.sub_iter;
+            }
+    };
+
+    template <typename Container>
+    class IterIterWrapper {
+        private:
+            Container container;
+
+            using contained_iter = typename Container::value_type;
+            using size_type = typename Container::size_type;
+            using iterator =
+                IteratorIterator<typename Container::iterator>;
+            using reverse_iterator =
+                IteratorIterator<typename Container::reverse_iterator>;
+
+        public:
+            IterIterWrapper() = default;
+
+            explicit IterIterWrapper(size_type sz)
+                : container(sz)
+            { }
+
+            IterIterWrapper(size_type sz, const contained_iter& val)
+                : container(sz, val)
+            { }
+
+            auto at(size_type pos) -> decltype(*container.at(pos)) {
+                return *container.at(pos);
+            }
+
+            auto at(size_type pos) const -> decltype(*container.at(pos)) {
+                return *container.at(pos);
+            }
+
+            auto operator[](size_type pos) 
+                noexcept(noexcept(*container[pos]))
+                -> decltype(*container[pos])
+            {
+                return *container[pos];
+            }
+
+            auto operator[](size_type pos) const
+                noexcept(noexcept(*container[pos]))
+                -> decltype(*container[pos])
+            {
+                return *container[pos];
+            }
+
+            bool empty() const noexcept {
+                return container.empty();
+            }
+
+            size_type size() const noexcept {
+                return container.size();
+            }
+
+            iterator begin() noexcept {
+                return {container.begin()};
+            }
+
+            iterator end() noexcept {
+                return {container.end()};
+            }
+
+            reverse_iterator rbegin() noexcept {
+                return {container.rbegin()};
+            }
+
+            reverse_iterator rend() noexcept {
+                return {container.rend()};
+            }
+
+            // get() exposes the underlying container.  this allows the
+            // itertools to manipulate the iterators in the container
+            // and should not be depended on anywhere else.
+            Container& get() noexcept {
+                return container;
+            }
+
+            const Container& get() const noexcept {
+                return container;
+            }
+
+    };
+}
+
+#endif

From 916b46f97225f021e0285108f659512f471dc349 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 8 Feb 2015 12:59:11 -0500
Subject: [PATCH 0915/1866] bulids iteratoriterator tests

---
 catchtest/SConstruct | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/catchtest/SConstruct b/catchtest/SConstruct
index 42bafa24..0a8c1e35 100644
--- a/catchtest/SConstruct
+++ b/catchtest/SConstruct
@@ -43,6 +43,8 @@ progs = Split(
     unique_justseen
     zip
     zip_longest
+
+    iteratoriterator
     '''
 )
 

From 84d75a345692e68f4a52c6864e43bbab65f4a5d7 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 8 Feb 2015 12:59:45 -0500
Subject: [PATCH 0916/1866] combinations uses iteratoriterator

---
 combinations.hpp | 38 ++++++++++++++------------------------
 1 file changed, 14 insertions(+), 24 deletions(-)

diff --git a/combinations.hpp b/combinations.hpp
index 4f560ef1..a2cfeda2 100644
--- a/combinations.hpp
+++ b/combinations.hpp
@@ -2,6 +2,7 @@
 #define ITER_COMBINATIONS_HPP_
 
 #include "iterbase.hpp"
+#include "iteratoriterator.hpp"
 
 #include <vector>
 #include <type_traits>
@@ -35,8 +36,9 @@ namespace iter {
                 length{in_length}
             { }
 
-            using CombIteratorDeref =
-                std::vector<collection_item_type<Container>>;
+            using IndexVector = std::vector<iterator_type<Container>>;
+            using CombIteratorDeref = IterIterWrapper<IndexVector>;
+
         public:
 
         class Iterator :
@@ -45,28 +47,20 @@ namespace iter {
             private:
                 constexpr static const int COMPLETE = -1;
                 typename std::remove_reference<Container>::type *container_p;
-                std::vector<iterator_type<Container>> indicies;
-                CombIteratorDeref working_set;
+                CombIteratorDeref indices;
                 int steps{};
 
-                void compute_working_set() {
-                    this->working_set.clear();
-                    for (auto&& i : this->indicies) {
-                        this->working_set.emplace_back(*i);
-                    }
-                }
-
             public:
                 Iterator(Container& in_container, std::size_t n)
                     : container_p{&in_container},
-                    indicies{n}
+                    indices{n}
                 {
                     if (n == 0) {
                         this->steps = COMPLETE;
                         return;
                     }
                     size_t inc = 0;
-                    for (auto& iter : this->indicies) {
+                    for (auto& iter : this->indices.get()) {
                         auto it = std::begin(*this->container_p);
                         dumb_advance(it, std::end(*this->container_p), inc);
                         if (it != std::end(*this->container_p)) {
@@ -77,34 +71,31 @@ namespace iter {
                             break;
                         }
                     }
-                    if (this->steps != COMPLETE) {
-                        this->compute_working_set();
-                    }
                 }
 
                 CombIteratorDeref& operator*() {
-                    return this->working_set;
+                    return this->indices;
                 }
 
 
                 Iterator& operator++() {
-                    for (auto iter = indicies.rbegin();
-                            iter != indicies.rend();
+                    for (auto iter = indices.get().rbegin();
+                            iter != indices.get().rend();
                             ++iter) {
                         ++(*iter);
 
                         //what we have to check here is if the distance between
-                        //the index and the end of indicies is >= the distance
+                        //the index and the end of indices is >= the distance
                         //between the item and end of item
                         auto dist = std::distance(
-                                this->indicies.rbegin(),iter);
+                                this->indices.get().rbegin(),iter);
 
                         if (!(dumb_next(*iter, dist) !=
                                 std::end(*this->container_p))) {
-                            if ( (iter + 1) != indicies.rend()) {
+                            if ( (iter + 1) != indices.get().rend()) {
                                 size_t inc = 1;
                                 for (auto down = iter;
-                                        down != indicies.rbegin()-1;
+                                        down != indices.get().rbegin()-1;
                                         --down) {
                                     (*down) = dumb_next(*(iter + 1), 1 + inc);
                                     ++inc;
@@ -121,7 +112,6 @@ namespace iter {
                     }
                     if (this->steps != COMPLETE) {
                         ++this->steps;
-                        this->compute_working_set();
                     }
                     return *this;
                 }

From 0100c4fe796bcf42d128a4d1e0b07d48277a7ff8 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 8 Feb 2015 12:59:59 -0500
Subject: [PATCH 0917/1866] comb_w_repl uses iteratoriterator

---
 combinations_with_replacement.hpp | 32 +++++++++++--------------------
 1 file changed, 11 insertions(+), 21 deletions(-)

diff --git a/combinations_with_replacement.hpp b/combinations_with_replacement.hpp
index 429a0c5a..bfb8a9b1 100644
--- a/combinations_with_replacement.hpp
+++ b/combinations_with_replacement.hpp
@@ -2,6 +2,7 @@
 #define ITER_COMBINATIONS_WITH_REPLACEMENT_HPP_
 
 #include "iterbase.hpp"
+#include "iteratoriterator.hpp"
 
 #include <iterator>
 #include <vector>
@@ -41,8 +42,8 @@ namespace iter {
                length{n}
            { }
 
-            using CombIteratorDeref =
-                std::vector<collection_item_type<Container>>;
+            using IndexVector = std::vector<iterator_type<Container>>;
+            using CombIteratorDeref = IterIterWrapper<IndexVector>;
 
         public:
             class Iterator :
@@ -52,43 +53,33 @@ namespace iter {
                private:
                    constexpr static const int COMPLETE = -1;
                    typename std::remove_reference<Container>::type *container_p;
-                   std::vector<iterator_type<Container>> indicies;
-                   CombIteratorDeref working_set;
+                   CombIteratorDeref indices;
                    int steps;
 
-                   void compute_working_set() {
-                       this->working_set.clear();
-                       for (auto&& i : indicies) {
-                           this->working_set.emplace_back(*i);
-                       }
-                   }
-
                public:
                    Iterator(Container& in_container, std::size_t n)
                        : container_p{&in_container},
-                       indicies(n, std::begin(in_container)),
+                       indices(n, std::begin(in_container)),
                        steps{(std::begin(in_container)
                                != std::end(in_container)
                                && n)
                            ? 0 : COMPLETE}
-                   {
-                       this->compute_working_set();
-                   }
+                   { }
 
                    CombIteratorDeref& operator*() {
-                       return this->working_set;
+                       return this->indices;
                    }
 
 
                    Iterator& operator++() {
-                       for (auto iter = indicies.rbegin();
-                               iter != indicies.rend();
+                       for (auto iter = indices.get().rbegin();
+                               iter != indices.get().rend();
                                ++iter) {
                            ++(*iter);
                            if (!(*iter != std::end(*this->container_p))) {
-                               if ( (iter + 1) != indicies.rend()) {
+                               if ( (iter + 1) != indices.get().rend()) {
                                    for (auto down = iter;
-                                           down != indicies.rbegin()-1;
+                                           down != indices.get().rbegin()-1;
                                            --down) {
                                        (*down) = dumb_next(*(iter + 1)); 
                                    }
@@ -104,7 +95,6 @@ namespace iter {
                        }
                        if (this->steps != COMPLETE) {
                            ++this->steps;
-                           this->compute_working_set();
                        }
                        return *this;
                    }

From d3875a5bed5cdbe426f2b4fe5b62fa162a03600b Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 8 Feb 2015 13:01:06 -0500
Subject: [PATCH 0918/1866] perumations uses iteratoriterator

---
 permutations.hpp | 24 ++++++++++++++++--------
 1 file changed, 16 insertions(+), 8 deletions(-)

diff --git a/permutations.hpp b/permutations.hpp
index 0db2af62..c16a8f4e 100644
--- a/permutations.hpp
+++ b/permutations.hpp
@@ -1,6 +1,8 @@
 #ifndef ITER_PERMUTATIONS_HPP_
 #define ITER_PERMUTATIONS_HPP_
+
 #include "iterbase.hpp"
+#include "iteratoriterator.hpp"
 
 #include <algorithm>
 #include <initializer_list>
@@ -15,8 +17,8 @@ namespace iter {
         private:
             Container container;
 
-            using Permutable =
-                std::vector<collection_item_type<Container>>;
+            using IndexVector = std::vector<iterator_type<Container>>;
+            using Permutable = IterIterWrapper<IndexVector>;
 
         public:
             Permuter(Container&& in_container)
@@ -27,7 +29,12 @@ namespace iter {
                 : public std::iterator<std::input_iterator_tag, Permutable>
             {
                 private:
-                    constexpr static const int COMPLETE = -1;
+                    static constexpr const int COMPLETE = -1;
+                    static bool cmp_iters(
+                            const iterator_type<Container>& lhs,
+                            const iterator_type<Container>& rhs) noexcept {
+                        return *lhs < *rhs;
+                    }
 
                     Permutable working_set;
                     int steps{};
@@ -41,11 +48,12 @@ namespace iter {
                         // two iterators because that causes a substitution
                         // failure when the iterator is minimal
                         while (sub_iter != sub_end) {
-                            this->working_set.emplace_back(*sub_iter);
+                            this->working_set.get().push_back(sub_iter);
                             ++sub_iter;
                         }
-                        std::sort(std::begin(working_set),
-                                std::end(working_set));
+                        std::sort(std::begin(working_set.get()),
+                                std::end(working_set.get()),
+                                cmp_iters);
                     }
 
                     Permutable& operator*() {
@@ -54,8 +62,8 @@ namespace iter {
 
                     Iterator& operator++() {
                         ++this->steps;
-                        if (!std::next_permutation(std::begin(working_set),
-                                    std::end(working_set))) {
+                        if (!std::next_permutation(std::begin(working_set.get()),
+                                    std::end(working_set.get()), cmp_iters)) {
                             this->steps = COMPLETE;
                         }
                         return *this;

From cebf14704171d0a2ef0bb0f651572fd04c8b42c7 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 8 Feb 2015 13:01:21 -0500
Subject: [PATCH 0919/1866] sliding window uses iteratoriterator

---
 sliding_window.hpp | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/sliding_window.hpp b/sliding_window.hpp
index 4efdf7d1..94cc66e7 100644
--- a/sliding_window.hpp
+++ b/sliding_window.hpp
@@ -2,6 +2,7 @@
 #define ITER_SLIDING_WINDOW_HPP_
 
 #include "iterbase.hpp"
+#include "iteratoriterator.hpp"
 
 #include <deque>
 #include <utility>
@@ -35,7 +36,8 @@ namespace iter {
                 window_size{win_sz}
             { }
 
-            using DerefVec = std::deque<collection_item_type<Container>>;
+            using IndexVector = std::deque<iterator_type<Container>>;
+            using DerefVec = IterIterWrapper<IndexVector>;
         public:
 
             class Iterator
@@ -53,7 +55,7 @@ namespace iter {
                     {
                         std::size_t i{0};
                         while (i < window_sz && this->sub_iter != in_end) {
-                            this->window.push_back(*this->sub_iter);
+                            this->window.get().push_back(this->sub_iter);
                             ++i;
                             if (i != window_sz) ++this->sub_iter;
                         }
@@ -73,8 +75,8 @@ namespace iter {
 
                     Iterator& operator++() {
                         ++this->sub_iter;
-                        this->window.pop_front();
-                        this->window.push_back(*this->sub_iter);
+                        this->window.get().pop_front();
+                        this->window.get().push_back(this->sub_iter);
                         return *this;
                     }
 

From c5e606d982d1db9867734632a3a42b907b130d8d Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 8 Feb 2015 13:01:32 -0500
Subject: [PATCH 0920/1866] grouper uses iteratoriterator

---
 grouper.hpp | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/grouper.hpp b/grouper.hpp
index 095edc0f..3cb69fe1 100644
--- a/grouper.hpp
+++ b/grouper.hpp
@@ -2,6 +2,7 @@
 #define ITER_GROUPER_HPP_
 
 #include "iterbase.hpp"
+#include "iteratoriterator.hpp"
 
 #include <vector>
 #include <algorithm>
@@ -38,7 +39,8 @@ namespace iter {
             friend Grouper<std::initializer_list<T>> grouper(
                     std::initializer_list<T>, std::size_t);
 
-            using DerefVec = std::vector<collection_item_type<Container>>;
+            using IndexVector = std::vector<iterator_type<Container>>;
+            using DerefVec = IterIterWrapper<IndexVector>;
         public:
             class Iterator :
                 public std::iterator<std::input_iterator_tag, DerefVec>
@@ -54,11 +56,11 @@ namespace iter {
                     }
 
                     void refill_group() {
-                        this->group.clear();
+                        this->group.get().clear();
                         std::size_t i{0};
                         while (i < group_size
                                     && this->sub_iter != this->sub_end) {
-                            group.emplace_back(*this->sub_iter);
+                            group.get().push_back(this->sub_iter);
                             ++this->sub_iter;
                             ++i;
                         }
@@ -72,7 +74,7 @@ namespace iter {
                         sub_end{std::move(in_end)},
                         group_size{s} 
                     {
-                        this->group.reserve(this->group_size);
+                        this->group.get().reserve(this->group_size);
                         this->refill_group();
                     }
 

From a070c151c71a7a42f2723e03f8bdb784c4743fca Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 8 Feb 2015 13:01:45 -0500
Subject: [PATCH 0921/1866] removes collection_item_type (now unused)

---
 iterbase.hpp | 13 -------------
 1 file changed, 13 deletions(-)

diff --git a/iterbase.hpp b/iterbase.hpp
index 81f6ff95..0f0fe1bc 100644
--- a/iterbase.hpp
+++ b/iterbase.hpp
@@ -42,19 +42,6 @@ namespace iter {
     using reverse_iterator_deref = 
         decltype(*std::declval<reverse_iterator_type<Container>&>());
 
-    // For combinatoric functions, if the Containers iterator dereferences
-    // to a reference, then this is a std::reference_wrapper for that type
-    // otherwise it's a non-const of that type
-    template <typename Container>
-    using collection_item_type =
-        typename std::conditional<
-        std::is_reference<iterator_deref<Container>>::value,
-        std::reference_wrapper<
-            typename std::remove_reference<
-            iterator_deref<Container>>::type>,
-        typename std::remove_const<
-            iterator_deref<Container>>::type>::type;
-
     template <typename, typename =void>
     struct is_random_access_iter : std::false_type { };
 

From 8a9eb9802efe146bc94a84f31899fe2fe6054740 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 8 Feb 2015 13:10:24 -0500
Subject: [PATCH 0922/1866] sorted uses stock iteratoriterator

---
 iteratoriterator.hpp |  2 +-
 sorted.hpp           | 45 ++++++++++++++------------------------------
 2 files changed, 15 insertions(+), 32 deletions(-)

diff --git a/iteratoriterator.hpp b/iteratoriterator.hpp
index cb0d0143..5bd807bc 100644
--- a/iteratoriterator.hpp
+++ b/iteratoriterator.hpp
@@ -74,7 +74,7 @@ namespace iter {
             auto operator->() -> decltype(*sub_iter) {
                 return *this->sub_iter;
             }
-            
+
 
             IteratorIterator& operator+=(Diff n) {
                 this->sub_iter += n;
diff --git a/sorted.hpp b/sorted.hpp
index 05c5a3e3..5dbbdc9b 100644
--- a/sorted.hpp
+++ b/sorted.hpp
@@ -2,6 +2,7 @@
 #define ITER_SORTED_HPP_
 
 #include "iterbase.hpp"
+#include "iteratoriterator.hpp"
 
 #include <iterator>
 #include <algorithm>
@@ -17,17 +18,15 @@ namespace iter {
     template <typename Container, typename CompareFunc>
     class Sorted  {
         private:
-            Container container;
-            std::vector<iterator_type<Container>> sorted_iters;
-
+            using IterIterWrap =
+                IterIterWrapper<std::vector<iterator_type<Container>>>;
+            using ItIt = iterator_type<IterIterWrap>;
             friend Sorted
                 sorted<Container, CompareFunc>(Container&&, CompareFunc);
 
-            using sorted_iter_type = iterator_type<decltype(sorted_iters)>;
-
+            Container container;
+            IterIterWrap sorted_iters;
 
-            Sorted() = delete;
-            Sorted& operator=(const Sorted&) = delete;
 
             Sorted(Container&& in_container, CompareFunc compare_func)
                 : container(std::forward<Container>(in_container))
@@ -37,42 +36,26 @@ namespace iter {
                 for (auto iter = std::begin(this->container);
                         iter != std::end(this->container);
                         ++iter) {
-                    this->sorted_iters.push_back(iter);
+                    this->sorted_iters.get().push_back(iter);
                 }
 
                 // sort by comparing the elements that the iterators point to
-                std::sort(std::begin(sorted_iters), std::end(sorted_iters),
-                        [&] (const iterator_type<Container>& it1,
+                std::sort(std::begin(sorted_iters.get()),
+                        std::end(sorted_iters.get()),
+                        [compare_func] (const iterator_type<Container>& it1,
                             const iterator_type<Container>& it2)
                         { return compare_func(*it1, *it2); });
             }
 
         public:
 
-            Sorted(const Sorted&) = default;
-
-            // Iterates over a series of Iterators, automatically dereferencing
-            // them when accessed with operator *
-            class IteratorIterator : public sorted_iter_type {
-                public:
-                    IteratorIterator(sorted_iter_type iter)
-                        : sorted_iter_type{iter}
-                    { }
-                    IteratorIterator(const IteratorIterator&) = default;
-
-                    // Dereference the current iterator before returning
-                    iterator_deref<Container> operator*() {
-                        return *sorted_iter_type::operator*();
-                    }
-            };
-
-            IteratorIterator begin() {
-                return {std::begin(sorted_iters)};
+            ItIt begin() {
+                return std::begin(sorted_iters);
                 
             }
 
-            IteratorIterator end() {
-                return {std::end(sorted_iters)};
+            ItIt end() {
+                return std::end(sorted_iters);
             }
     };
 

From 13924b0724677e4af38a03d86272172d31244a79 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 8 Feb 2015 17:03:19 -0500
Subject: [PATCH 0923/1866] uses -std=c++14

---
 catchtest/SConstruct | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/catchtest/SConstruct b/catchtest/SConstruct
index 0a8c1e35..cd23626e 100644
--- a/catchtest/SConstruct
+++ b/catchtest/SConstruct
@@ -4,7 +4,7 @@ env = Environment(
     ENV = os.environ,
     CXX='c++',
     CXXFLAGS= ['-g', '-Wall', '-Wextra',
-               '-pedantic', '-std=c++11',
+               '-pedantic', '-std=c++14',
                 '-fdiagnostics-color=always',
                '-I/usr/local/include'],
     CPPPATH='..',

From 79b89521e50e2b1ca1f0d681c1c6f5efd1b47743 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 8 Feb 2015 17:03:46 -0500
Subject: [PATCH 0924/1866] corrects error in section description

---
 catchtest/test_imap.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/catchtest/test_imap.cpp b/catchtest/test_imap.cpp
index ba9ae171..9f7b8e4d 100644
--- a/catchtest/test_imap.cpp
+++ b/catchtest/test_imap.cpp
@@ -48,7 +48,7 @@ TEST_CASE("imap: works with lambda, callable, and function", "[imap]") {
         REQUIRE( v == vc );
     }
 
-    SECTION("with function") {
+    SECTION("with callable") {
         auto im = imap(PlusOner{}, ns);
         Vec v(std::begin(im), std::end(im));
         Vec vc = {11, 21, 31};

From bb76192dafeb4555f1937b326c779e7a13d7bbbe Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 8 Feb 2015 17:08:08 -0500
Subject: [PATCH 0925/1866] drops references to functions, derives stditerator

---
 starmap.hpp | 41 +++++++++++++++++++++++++++++------------
 1 file changed, 29 insertions(+), 12 deletions(-)

diff --git a/starmap.hpp b/starmap.hpp
index 4a41cba9..8ff04994 100644
--- a/starmap.hpp
+++ b/starmap.hpp
@@ -4,30 +4,39 @@
 #include "iterbase.hpp"
 
 #include <utility>
+#include <iterator>
 #include <type_traits>
 #include <array>
 #include <cassert>
 #include <memory>
 
 namespace iter {
+
     // starmap with a container<T> where T is one of tuple, pair, array
     template <typename Func, typename Container>
     class StarMapper {
         private:
             Func func;
             Container container;
+
+            using StarIterDeref =
+                std::remove_reference_t<decltype(call_with_tuple(func,
+                            std::declval<iterator_deref<Container>>()))>;
+
         public:
-            StarMapper(Func f, Container c)
-                : func(f),
+            StarMapper(Func f, Container&& c)
+                : func(std::forward<Func>(f)),
                 container(std::forward<Container>(c))
             { }
 
-            class Iterator {
+            class Iterator
+                : public std::iterator<std::input_iterator_tag, StarIterDeref>
+            {
                 private:
                     Func func;
                     iterator_type<Container> sub_iter;
                 public:
-                    Iterator(Func f, iterator_type<Container> iter)
+                    Iterator(Func& f, iterator_type<Container> iter)
                         : func(f),
                         sub_iter(iter)
                     { }
@@ -36,11 +45,21 @@ namespace iter {
                         return this->sub_iter != other.sub_iter;
                     }
 
+                    bool operator==(const Iterator& other) const {
+                        return !(*this != other);
+                    }
+
                     Iterator operator++() {
                         ++this->sub_iter;
                         return *this;
                     }
 
+                    Iterator operator++(int) {
+                        auto ret = *this;
+                        ++*this;
+                        return ret;
+                    }
+
                     decltype(auto) operator*() {
                         return call_with_tuple(this->func, *this->sub_iter);
                     }
@@ -59,7 +78,7 @@ namespace iter {
 
     template <typename Func, typename Container>
     StarMapper<Func, Container> starmap_helper(
-            Func&& func, Container&& container, std::false_type) {
+            Func func, Container&& container, std::false_type) {
         return {std::forward<Func>(func), std::forward<Container>(container)};
     }
 
@@ -92,6 +111,7 @@ namespace iter {
                 tup(std::forward<TupType>(t))
             { }
 
+            // TODO inherit from std::iterator
             class Iterator {
                 private:
                     Func& func;
@@ -137,14 +157,14 @@ namespace iter {
 
     template <typename Func, typename TupType, std::size_t... Is>
     TupleStarMapper<Func, TupType, Is...> starmap_helper_impl(
-            Func&& func, TupType&& tup, std::index_sequence<Is...>)
+            Func func, TupType&& tup, std::index_sequence<Is...>)
     {
         return {std::forward<Func>(func), std::forward<TupType>(tup)};
     }
 
     template <typename Func, typename TupType>
     auto starmap_helper(
-            Func&& func, TupType&& tup, std::true_type) {
+            Func func, TupType&& tup, std::true_type) {
         return starmap_helper_impl(
             std::forward<Func>(func),
             std::forward<TupType>(tup),
@@ -163,7 +183,7 @@ namespace iter {
         : public std::true_type { };
 
     template <typename Func, typename Seq>
-    auto starmap(Func&& func, Seq&& sequence) {
+    auto starmap(Func func, Seq&& sequence) {
         return starmap_helper(
                 std::forward<Func>(func),
                 std::forward<Seq>(sequence),
@@ -171,7 +191,4 @@ namespace iter {
     }
 }
 
-
-
-
-#endif // #ifndef ITER_STARMAP_H_
+#endif

From b9c5e27e62b263405dd610282f409f0bc1191376 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 8 Feb 2015 17:24:57 -0500
Subject: [PATCH 0926/1866] adds basic starmap test

---
 catchtest/test_starmap.cpp | 42 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 catchtest/test_starmap.cpp

diff --git a/catchtest/test_starmap.cpp b/catchtest/test_starmap.cpp
new file mode 100644
index 00000000..015b966e
--- /dev/null
+++ b/catchtest/test_starmap.cpp
@@ -0,0 +1,42 @@
+#include <imap.hpp>
+
+#include "helpers.hpp"
+
+#include <vector>
+#include <string>
+#include <iterator>
+
+#include "catch.hpp"
+
+using iter::starmap;
+
+namespace {
+    long f(long d, int i) {
+        return d * i;
+    }
+
+    std::string g(const std::string& s, int i, double d) {
+        std::stringstream ss;
+        ss << s << ' ' << i << ' ' << d;
+        return ss.str();
+    }
+}
+
+TEST_CASE("starmap: works with function pointer and lambda", "[starmap]") {
+    using Vec = const std::vector<int>;
+    const std::vector<std::pair<double, int>> v1 =
+        {{1l, 2}, {3l, 11}, {6l, 7}};
+    Vec vc = {2l, 33l, 42l};
+
+    SECTION("with function") {
+        auto sm = starmap(f, v1);
+        Vec v(std::begin(sm), std::end(sm));
+        REQUIRE( v == vc );
+    }
+
+    SECTION("with lambda") {
+        auto sm = starmap([](long a, int b) { return a * b; }, v1);
+        Vec v(std::begin(sm), std::end(sm));
+        REQUIRE( v == vc );
+    }
+}

From 0a408fecc5900cfe6b09694d69ad0e4791cfb29f Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 8 Feb 2015 17:32:55 -0500
Subject: [PATCH 0927/1866] builds starmap test

---
 catchtest/SConstruct | 1 +
 1 file changed, 1 insertion(+)

diff --git a/catchtest/SConstruct b/catchtest/SConstruct
index cd23626e..36e14df3 100644
--- a/catchtest/SConstruct
+++ b/catchtest/SConstruct
@@ -38,6 +38,7 @@ progs = Split(
     slice
     sliding_window
     
+    starmap
     takewhile
     unique_everseen
     unique_justseen

From d248ba210a63182f0b60553750ec529a2d2c1591 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 8 Feb 2015 17:33:04 -0500
Subject: [PATCH 0928/1866] tests starmap a bit harder

---
 catchtest/test_starmap.cpp | 18 ++++++++++++++++--
 1 file changed, 16 insertions(+), 2 deletions(-)

diff --git a/catchtest/test_starmap.cpp b/catchtest/test_starmap.cpp
index 015b966e..e3e091a0 100644
--- a/catchtest/test_starmap.cpp
+++ b/catchtest/test_starmap.cpp
@@ -3,6 +3,7 @@
 #include "helpers.hpp"
 
 #include <vector>
+#include <list>
 #include <string>
 #include <iterator>
 
@@ -15,9 +16,9 @@ namespace {
         return d * i;
     }
 
-    std::string g(const std::string& s, int i, double d) {
+    std::string g(const std::string& s, int i, char c) {
         std::stringstream ss;
-        ss << s << ' ' << i << ' ' << d;
+        ss << s << ' ' << i << ' ' << c;
         return ss.str();
     }
 }
@@ -40,3 +41,16 @@ TEST_CASE("starmap: works with function pointer and lambda", "[starmap]") {
         REQUIRE( v == vc );
     }
 }
+
+TEST_CASE("starmap: list of tuples", "[starmap]") {
+    using Vec = const std::vector<std::string>;
+    using T = std::tuple<std::string, int, double>;
+    std::list<T> li =
+        {T{"hey", 42, 'a'}, T{"there", 3, 'b'}, T{"yall", 5, 'c'}};
+
+    auto sm = starmap(g, li);
+    Vec v(std::begin(sm), std::end(sm));
+    Vec vc = {"hey 42 a", "there 3 b", "yall 5 c"};
+
+    REQUIRE( v == vc );
+}

From d567e4513cfbd59c9b4428c9d938d161a7fd0401 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 8 Feb 2015 17:47:27 -0500
Subject: [PATCH 0929/1866] tests starmap with a tuple of tuples

---
 catchtest/test_starmap.cpp | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/catchtest/test_starmap.cpp b/catchtest/test_starmap.cpp
index e3e091a0..378a8286 100644
--- a/catchtest/test_starmap.cpp
+++ b/catchtest/test_starmap.cpp
@@ -21,6 +21,16 @@ namespace {
         ss << s << ' ' << i << ' ' << c;
         return ss.str();
     }
+
+    struct Callable {
+        int operator()(int a, int b, int c) {
+            return a + b + c;
+        }
+
+        int operator()(int a) {
+            return a;
+        }
+    };
 }
 
 TEST_CASE("starmap: works with function pointer and lambda", "[starmap]") {
@@ -54,3 +64,13 @@ TEST_CASE("starmap: list of tuples", "[starmap]") {
 
     REQUIRE( v == vc );
 }
+
+TEST_CASE("starmap: tuple of tuples", "[starmap]") {
+    using Vec = const std::vector<int>;
+    auto tup = std::make_tuple(std::make_tuple(10, 19, 60),std::make_tuple(7));
+    auto sm = starmap(Callable{}, tup);
+    Vec v(std::begin(sm), std::end(sm));
+    Vec vc = {89, 7};
+
+    REQUIRE( v == vc );
+}

From a39975c5334e809178205e03a1ac8f979d12bdcc Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 8 Feb 2015 17:47:41 -0500
Subject: [PATCH 0930/1866] TupleStarMapper iter derives std::iterator

---
 starmap.hpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/starmap.hpp b/starmap.hpp
index 8ff04994..3f8a64e2 100644
--- a/starmap.hpp
+++ b/starmap.hpp
@@ -105,14 +105,16 @@ namespace iter {
             constexpr static std::array<CallerFunc, sizeof...(Is)> callers{{
                 get_and_call_with_tuple<Is>...}};
 
+            using TraitsValue = std::remove_reference_t<ResultType>;
         public:
             TupleStarMapper(Func f, TupType t)
                 : func(std::forward<Func>(f)),
                 tup(std::forward<TupType>(t))
             { }
 
-            // TODO inherit from std::iterator
-            class Iterator {
+            class Iterator 
+                : public std::iterator<std::input_iterator_tag, TraitsValue> 
+            {
                 private:
                     Func& func;
                     TupType& tup;

From c7a08e30eb52d37bed0fee2e0c4dd2e3a2bb523b Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 8 Feb 2015 18:52:17 -0500
Subject: [PATCH 0931/1866] tests starmap with pair of array and tuple

---
 catchtest/test_starmap.cpp | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/catchtest/test_starmap.cpp b/catchtest/test_starmap.cpp
index 378a8286..fc59fd18 100644
--- a/catchtest/test_starmap.cpp
+++ b/catchtest/test_starmap.cpp
@@ -74,3 +74,16 @@ TEST_CASE("starmap: tuple of tuples", "[starmap]") {
 
     REQUIRE( v == vc );
 }
+
+TEST_CASE("starmap: tuple of pairs", "[starmap]") {
+    using Vec = const std::vector<int>;
+    auto p = std::make_pair(std::array<int, 3>{{15, 100, 2000}},
+                            std::make_tuple(16));
+    Callable c;
+    auto sm = starmap(c, p);
+
+    Vec v(std::begin(sm), std::end(sm));
+    Vec vc = {2115, 16};
+
+    REQUIRE( v == vc );
+}

From 1c63201569b195f3f3b05247444ac7c3f44cbae3 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 8 Feb 2015 20:21:13 -0500
Subject: [PATCH 0932/1866] flattens zip longest

---
 zip_longest.hpp | 161 +++++++++++++++++++-----------------------------
 1 file changed, 62 insertions(+), 99 deletions(-)

diff --git a/zip_longest.hpp b/zip_longest.hpp
index cc6705b9..98b20ec4 100644
--- a/zip_longest.hpp
+++ b/zip_longest.hpp
@@ -11,65 +11,51 @@
 
 namespace iter {
 
-    template <typename Container>
-    using OptIterDeref = boost::optional<iterator_deref<Container>>;
-
-    template <typename... RestContainers>
+    template <typename TupleType, std::size_t... Is>
     class ZippedLongest;
 
-    template <typename... Containers>
-    ZippedLongest<Containers...> zip_longest(Containers&&...);
+    template <typename TupleType, std::size_t... Is>
+    ZippedLongest<TupleType, Is...>
+        zip_longest_impl(TupleType&&, std::index_sequence<Is...>);
 
-    template <typename Container, typename... RestContainers>
-    class ZippedLongest <Container, RestContainers...> {
-        static_assert(!std::is_rvalue_reference<Container>::value,
-                "Itertools cannot be templated with rvalue references");
+    template <typename TupleType, std::size_t... Is>
+    class ZippedLongest {
+        private:
+            TupleType containers;
+            friend ZippedLongest zip_longest_impl<TupleType, Is...>(
+                    TupleType&&, std::index_sequence<Is...>);
 
-        friend ZippedLongest zip_longest<Container, RestContainers...>(
-                Container&&, RestContainers&&...);
+            template <std::size_t I>
+            using OptType = boost::optional<iterator_deref<
+                std::tuple_element_t<I, TupleType>>>;
 
-        template <typename... Cs>
-        friend class ZippedLongest;
+            using ZipIterDeref = std::tuple<OptType<Is>...>;
 
-        private:
-            using OptType = OptIterDeref<Container>;
-            using ZipIterDeref =
-                std::tuple<OptType, OptIterDeref<RestContainers>...>;
-
-            Container container;
-            ZippedLongest<RestContainers...> rest_zipped;
-            ZippedLongest(Container&& container, RestContainers&&... rest)
-                : container(std::forward<Container>(container)),
-                rest_zipped{std::forward<RestContainers>(rest)...}
+            ZippedLongest(TupleType&& in_containers)
+                : containers(std::move(in_containers))
             { }
-
         public:
             class Iterator
                 : public std::iterator<std::input_iterator_tag, ZipIterDeref>
             {
                 private:
-                    using RestIter =
-                        typename ZippedLongest<RestContainers...>::Iterator;
-
-                    iterator_type<Container> iter;
-                    iterator_type<Container> end;
-                    RestIter rest_iter;
+                    iterator_tuple_type<TupleType> iters;
+                    iterator_tuple_type<TupleType> ends;
 
                 public:
-                    Iterator(
-                            iterator_type<Container> it,
-                            iterator_type<Container> in_end,
-                            const RestIter& rest)
-                        : iter{it},
-                        end{in_end},
-                        rest_iter{rest}
+                    Iterator(iterator_tuple_type<TupleType>&& in_iters,
+                            iterator_tuple_type<TupleType>&& in_ends)
+                        : iters(std::move(in_iters)),
+                        ends(std::move(in_ends))
                     { }
 
                     Iterator& operator++() {
-                        if (this->iter != this->end) {
-                            ++this->iter;
-                        }
-                        ++this->rest_iter;
+                        // increment every iterator that's not already at
+                        // the end
+                        absorb(
+                            ((std::get<Is>(this->iters) !=
+                              std::get<Is>(this->ends)) ?
+                                (++std::get<Is>(this->iters), 0) : 0)...);
                         return *this;
                     }
 
@@ -80,8 +66,15 @@ namespace iter {
                     }
 
                     bool operator!=(const Iterator& other) const {
-                        return this->iter != other.iter ||
-                            this->rest_iter != other.rest_iter;
+                        if (sizeof...(Is) == 0) return false;
+
+                        bool results[] = { false,
+                            (std::get<Is>(this->iters) !=
+                                 std::get<Is>(other.iters))...
+                        };
+                        return std::any_of(
+                                std::begin(results), std::end(results),
+                                [](bool b){ return b; } );
                     }
 
                     bool operator==(const Iterator& other) const {
@@ -89,72 +82,42 @@ namespace iter {
                     }
 
                     ZipIterDeref operator*() {
-                        if (this->iter != this->end) {
-                            return std::tuple_cat(
-                                    std::tuple<OptType>{{*this->iter}},
-                                    *this->rest_iter);
-                        } else {
-                            return std::tuple_cat(
-                                    std::tuple<OptType>{{}},
-                                    *this->rest_iter);
-                        }
+                        return ZipIterDeref{ 
+                            ((std::get<Is>(this->iters) !=
+                              std::get<Is>(this->ends))
+                             ? OptType<Is>{*std::get<Is>(this->iters)}
+                                : OptType<Is>{})...};
                     }
             };
 
             Iterator begin() {
-                return {std::begin(this->container),
-                    std::end(this->container),
-                    std::begin(this->rest_zipped)};
+                return {
+                    iterator_tuple_type<TupleType>{
+                        std::begin(std::get<Is>(this->containers))...},
+                    iterator_tuple_type<TupleType>{
+                        std::end(std::get<Is>(this->containers))...}};
             }
 
             Iterator end() {
-                return {std::end(this->container),
-                    std::end(this->container),
-                    std::end(this->rest_zipped)};
+                return {
+                    iterator_tuple_type<TupleType>{
+                        std::end(std::get<Is>(this->containers))...},
+                    iterator_tuple_type<TupleType>{
+                        std::end(std::get<Is>(this->containers))...}};
             }
-    };
-
-
-    template <>
-    class ZippedLongest<> {
-        public:
-            class Iterator
-                : public std::iterator<std::input_iterator_tag, std::tuple<>> 
-            {
-                public:
-                    Iterator& operator++() {
-                        return *this;
-                    }
+};
 
-                    constexpr Iterator operator++(int) {
-                        return *this;
-                    }
-
-                    constexpr bool operator!=(const Iterator&) const {
-                        return false;
-                    }
-
-                    constexpr bool operator==(const Iterator&) const {
-                        return true;
-                    }
-
-                    constexpr std::tuple<> operator*() {
-                        return {};
-                    }
-            };
-
-            constexpr Iterator begin() {
-                return {};
-            }
-
-            constexpr Iterator end() {
-                return {};
-            }
-    };
+    template <typename TupleType, std::size_t... Is>
+    ZippedLongest<TupleType, Is...> zip_longest_impl(
+            TupleType&& in_containers, std::index_sequence<Is...>) {
+        return {std::move(in_containers)};
+    }
 
     template <typename... Containers>
-    ZippedLongest<Containers...> zip_longest(Containers&&... containers) {
-        return {std::forward<Containers>(containers)...};
+    auto zip_longest(Containers&&... containers) {
+        return zip_longest_impl(std::tuple<Containers...>{
+            std::forward<Containers>(containers)...},
+            std::index_sequence_for<Containers...>{});
     }
 }
 

From f95dba8572ec2600b1b83b95f5b39d415be45822 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 8 Feb 2015 20:40:05 -0500
Subject: [PATCH 0933/1866] uses c++14 type aliases

---
 accumulate.hpp | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/accumulate.hpp b/accumulate.hpp
index 8df2e409..c57d177c 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -38,10 +38,10 @@ namespace iter {
             
             // AccumVal must be default constructible
             using AccumVal =
-                typename std::remove_reference<
-                    typename std::result_of<AccumulateFunc(
+                std::remove_reference_t<
+                    std::result_of_t<AccumulateFunc(
                             iterator_deref<Container>,
-                            iterator_deref<Container>)>::type>::type;
+                            iterator_deref<Container>)>>;
             static_assert(
                     std::is_default_constructible<AccumVal>::value,
                     "Cannot accumulate a non-default constructible type");
@@ -125,12 +125,12 @@ namespace iter {
     template <typename Container>
     auto accumulate(Container&& container) -> 
         decltype(accumulate(std::forward<Container>(container),
-                    std::plus<typename std::remove_reference<
-                        iterator_deref<Container>>::type>{}))
+                    std::plus<std::remove_reference_t<
+                        iterator_deref<Container>>>{}))
     {
         return accumulate(std::forward<Container>(container),
-                    std::plus<typename std::remove_reference<
-                        iterator_deref<Container>>::type>{});
+                    std::plus<std::remove_reference_t<
+                        iterator_deref<Container>>>{});
     }
 
     template <typename T, typename AccumulateFunc>

From 0fd65dfc500c654823c977f0261fa456fab9c67b Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 8 Feb 2015 20:41:09 -0500
Subject: [PATCH 0934/1866] uses c++14 type aliases

---
 combinations.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/combinations.hpp b/combinations.hpp
index a2cfeda2..6f8b3dd9 100644
--- a/combinations.hpp
+++ b/combinations.hpp
@@ -46,7 +46,7 @@ namespace iter {
         {
             private:
                 constexpr static const int COMPLETE = -1;
-                typename std::remove_reference<Container>::type *container_p;
+                std::remove_reference_t<Container> *container_p;
                 CombIteratorDeref indices;
                 int steps{};
 

From 36f8e3856c71cb044bbe95e4a0f56dd15aacc6be Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 8 Feb 2015 20:41:58 -0500
Subject: [PATCH 0935/1866] uses c++14 type aliases

---
 combinations_with_replacement.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/combinations_with_replacement.hpp b/combinations_with_replacement.hpp
index bfb8a9b1..96ea9af0 100644
--- a/combinations_with_replacement.hpp
+++ b/combinations_with_replacement.hpp
@@ -52,7 +52,7 @@ namespace iter {
             {
                private:
                    constexpr static const int COMPLETE = -1;
-                   typename std::remove_reference<Container>::type *container_p;
+                   std::remove_reference_t<Container> *container_p;
                    CombIteratorDeref indices;
                    int steps;
 

From 516e707db264ee6544cab39e0a539547bc661bf0 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 8 Feb 2015 20:43:10 -0500
Subject: [PATCH 0936/1866] uses c++14 type aliases

---
 groupby.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/groupby.hpp b/groupby.hpp
index 42768202..dcda1fda 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -32,8 +32,8 @@ namespace iter {
             friend GroupBy<std::initializer_list<T>, KF> groupby(
                     std::initializer_list<T>, KF);
 
-            using key_func_ret = typename
-                std::result_of<KeyFunc(iterator_deref<Container>)>::type;
+            using key_func_ret = 
+                std::result_of_t<KeyFunc(iterator_deref<Container>)>;
 
             GroupBy(Container&& container, KeyFunc key_func)
                 : container(std::forward<Container>(container)),

From e31a0db04317d4328fabd796f00c632e9a768648 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 8 Feb 2015 20:47:45 -0500
Subject: [PATCH 0937/1866] uses c++14 type aliases

---
 iterbase.hpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/iterbase.hpp b/iterbase.hpp
index 52f5d807..95f369ef 100644
--- a/iterbase.hpp
+++ b/iterbase.hpp
@@ -30,7 +30,7 @@ namespace iter {
 
     template <typename Container>
     using iterator_traits_deref =
-        typename std::remove_reference<iterator_deref<Container>>::type;
+        std::remove_reference_t<iterator_deref<Container>>;
 
     // iterator_type<C> is the type of C's iterator
     template <typename Container>
@@ -48,11 +48,11 @@ namespace iter {
 
     template <typename T>
     struct is_random_access_iter<T,
-        typename std::enable_if<
+        std::enable_if_t<
              std::is_same<
                  typename std::iterator_traits<T>::iterator_category,
-              std::random_access_iterator_tag>::value,
-          void>::type> : std::true_type { };
+              std::random_access_iterator_tag>::value
+          >> : std::true_type { };
 
     template <typename T>
     using has_random_access_iter = is_random_access_iter<iterator_type<T>>;

From 3d3a0ec9767059ed8854d79f854cfe66b5032517 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 8 Feb 2015 20:49:55 -0500
Subject: [PATCH 0938/1866] uses c++14 type aliases

---
 powerset.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/powerset.hpp b/powerset.hpp
index 964b0651..eb58f909 100644
--- a/powerset.hpp
+++ b/powerset.hpp
@@ -29,7 +29,7 @@ namespace iter {
                       std::input_iterator_tag, CombinatorType>
             {
                 private:
-                    typename std::remove_reference<Container>::type *container_p;
+                    std::remove_reference_t<Container> *container_p;
                     std::size_t set_size;
                     std::unique_ptr<CombinatorType> comb;
                     iterator_type<CombinatorType> comb_iter;

From 2651b6603849b7d64e5ddbe930cc82f4fccdd617 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 8 Feb 2015 20:53:23 -0500
Subject: [PATCH 0939/1866] shortens tag dispatch

---
 range.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/range.hpp b/range.hpp
index f0e7048c..9ce252b8 100644
--- a/range.hpp
+++ b/range.hpp
@@ -121,7 +121,7 @@ namespace iter {
                     // So, if an iterator is not equal to that, it is valid
                     bool operator!=(const Iterator& other) const { 
                         return not_equal_to(
-                                other, typename std::is_unsigned<T>::type());
+                                other, std::is_unsigned<T>{});
                     }
 
                     bool operator==(const Iterator& other) const {

From ead0e699bc642348372395485ae29f835b004094 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 8 Feb 2015 20:54:21 -0500
Subject: [PATCH 0940/1866] uses c++14 type aliases

---
 repeat.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/repeat.hpp b/repeat.hpp
index 03ecadce..7a9c6adc 100644
--- a/repeat.hpp
+++ b/repeat.hpp
@@ -24,7 +24,7 @@ namespace iter {
         friend Repeater repeat<T>(T&&);
         friend Repeater repeat<T>(T&&, int);
         private:
-            using TPlain = typename std::remove_reference<T>::type;
+            using TPlain = std::remove_reference_t<T>;
             T elem;
             int count;
 

From 816e70054fbcd3ae8692eed087ffa46d4b9755dc Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Sun, 8 Feb 2015 21:22:03 -0500
Subject: [PATCH 0941/1866] uses auto funcs and init capture

---
 unique_everseen.hpp | 47 ++++++++++++++-------------------------------
 1 file changed, 14 insertions(+), 33 deletions(-)

diff --git a/unique_everseen.hpp b/unique_everseen.hpp
index ec95eb34..6a095fe6 100644
--- a/unique_everseen.hpp
+++ b/unique_everseen.hpp
@@ -10,45 +10,26 @@
 #include <unordered_set>
 #include <iterator>
 
-namespace iter 
-{
-    //the container type must be usable in an unordered_map to achieve constant
-    //performance checking if it has ever been seen
+namespace iter {
     template <typename Container>
-    auto unique_everseen(Container&& container) 
-        -> Filter<std::function<bool(iterator_deref<Container>)>,Container>
-    {
-        using elem_t = iterator_deref<Container>;
-        std::unordered_set<typename std::decay<elem_t>::type> elem_seen;
-
-        std::function<bool(elem_t)> func =
-        //has to be captured by value because it goes out of scope when the 
-        //function returns
-            [elem_seen](elem_t e) mutable
-            {
-                if (elem_seen.find(e) == std::end(elem_seen)){
-                    elem_seen.insert(e);
-                    return true;
-                } else {
-                    return false;
-                }
+    auto unique_everseen(Container&& container) {
+        using elem_type = iterator_deref<Container>;
+        auto func =
+            [
+                elem_seen = std::unordered_set<std::decay_t<elem_type>>()
+            ] (const elem_type& e) mutable {
+                return elem_seen.insert(e).second;
             };
         return filter(func, std::forward<Container>(container));
     }
 
     template <typename T>
-    auto unique_everseen(std::initializer_list<T> il) 
-        -> Filter<std::function<bool(T)>, std::initializer_list<T>>
-    {
-        std::unordered_set<T> elem_seen;
-        std::function<bool(T)> func = [elem_seen](const T& e) mutable
-            {
-                if (elem_seen.find(e) == std::end(elem_seen)){
-                    elem_seen.insert(e);
-                    return true;
-                } else {
-                    return false;
-                }
+    auto unique_everseen(std::initializer_list<T> il) {
+        auto func =
+            [
+                elem_seen = std::unordered_set<T>()
+            ] (const T& e) mutable {
+                return elem_seen.insert(e).second;
             };
         return filter(func, il);
     }

From eba0d63f1522ce107608cdfaf861919f7dfb6edb Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 9 Feb 2015 15:28:19 -0500
Subject: [PATCH 0942/1866] return type deduction

---
 accumulate.hpp | 10 ++--------
 1 file changed, 2 insertions(+), 8 deletions(-)

diff --git a/accumulate.hpp b/accumulate.hpp
index c57d177c..6186d869 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -123,11 +123,7 @@ namespace iter {
     }
 
     template <typename Container>
-    auto accumulate(Container&& container) -> 
-        decltype(accumulate(std::forward<Container>(container),
-                    std::plus<std::remove_reference_t<
-                        iterator_deref<Container>>>{}))
-    {
+    auto accumulate(Container&& container) {
         return accumulate(std::forward<Container>(container),
                     std::plus<std::remove_reference_t<
                         iterator_deref<Container>>>{});
@@ -142,9 +138,7 @@ namespace iter {
     }
 
     template <typename T>
-    auto accumulate(std::initializer_list<T> il) ->
-        decltype(accumulate(std::move(il), std::plus<T>{}))
-    {
+    auto accumulate(std::initializer_list<T> il) {
         return accumulate(std::move(il), std::plus<T>{});
     }
 

From f5c4cf055b7540f30c500bf140b7f290315d9b85 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 9 Feb 2015 15:29:49 -0500
Subject: [PATCH 0943/1866] uses return type deduction

---
 count.hpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/count.hpp b/count.hpp
index e0bc7cd0..4ef0a3be 100644
--- a/count.hpp
+++ b/count.hpp
@@ -9,13 +9,13 @@ namespace iter {
 
     using DefaultRangeType = long;
 
-    auto count() -> decltype(range(DefaultRangeType(0), DefaultRangeType(0))) {
+    auto count() {
         return range(DefaultRangeType(0),
                 std::numeric_limits<DefaultRangeType>::max());
     }
 
     template <typename T>
-    auto count(T start, T step) -> decltype(range(start, start, start)) {
+    auto count(T start, T step) {
         // if step is < 0, set the stop to numeric min, otherwise numeric max
         T stop = step < T(0) ? std::numeric_limits<T>::min() :
                             std::numeric_limits<T>::max();
@@ -23,7 +23,7 @@ namespace iter {
     }
 
     template <typename T>
-    auto count(T start) -> decltype(range(start, start)) {
+    auto count(T start) {
         return count(start, T(1));
     }
 }

From 16a88e32c99d2ccfb3a2b7a7f2ba5d631bcfa163 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 9 Feb 2015 15:31:52 -0500
Subject: [PATCH 0944/1866] uses return type deduction

---
 filter.hpp | 10 ++--------
 1 file changed, 2 insertions(+), 8 deletions(-)

diff --git a/filter.hpp b/filter.hpp
index fdefe612..b66da5fe 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -143,20 +143,14 @@ namespace iter {
 
 
     template <typename Container>
-    auto filter(Container&& container) ->
-            decltype(filter(
-                        detail::BoolTester<Container>(),
-                        std::forward<Container>(container))) {
+    auto filter(Container&& container) {
         return filter(
                 detail::BoolTester<Container>(),
                 std::forward<Container>(container));
     }
 
     template <typename T>
-    auto filter(std::initializer_list<T> il) ->
-            decltype(filter(
-                        detail::BoolTester<std::initializer_list<T>>(),
-                        std::move(il))) {
+    auto filter(std::initializer_list<T> il) {
            return filter(
                    detail::BoolTester<std::initializer_list<T>>(),
                    std::move(il));

From f3e0f261b5f1d7a56813371e8e07ca9ddd426c78 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 9 Feb 2015 15:35:16 -0500
Subject: [PATCH 0945/1866] uses return type deduction

---
 filterfalse.hpp | 26 +++++++-------------------
 1 file changed, 7 insertions(+), 19 deletions(-)

diff --git a/filterfalse.hpp b/filterfalse.hpp
index 3bad5fa0..f7530ab9 100644
--- a/filterfalse.hpp
+++ b/filterfalse.hpp
@@ -53,11 +53,7 @@ namespace iter {
     // the bool result of the function.  The PredicateFlipper is then passed
     // to the normal filter() function
     template <typename FilterFunc, typename Container>
-    auto filterfalse(FilterFunc filter_func, Container&& container) ->
-            decltype(filter(
-                        detail::PredicateFlipper<FilterFunc, Container>(
-                            filter_func),
-                        std::forward<Container>(container))) {
+    auto filterfalse(FilterFunc filter_func, Container&& container) {
         return filter(
                 detail::PredicateFlipper<FilterFunc, Container>(filter_func),
                 std::forward<Container>(container));
@@ -66,10 +62,7 @@ namespace iter {
     // Single argument version, uses a BoolFlipper to reverse the truthiness
     // of an object
     template <typename Container>
-    auto filterfalse(Container&& container) ->
-            decltype(filter(
-                        detail::BoolFlipper<Container>(),
-                        std::forward<Container>(container))) {
+    auto filterfalse(Container&& container) {
         return filter(
                 detail::BoolFlipper<Container>(),
                 std::forward<Container>(container));
@@ -79,23 +72,18 @@ namespace iter {
 
     //specializations for initializer_lists
     template <typename FilterFunc, typename T>
-    auto filterfalse(FilterFunc filter_func, std::initializer_list<T> container) ->
-            decltype(filter(
-                        detail::PredicateFlipper<FilterFunc, std::initializer_list<T>>(
-                            filter_func),
-                        std::move(container))) {
+    auto filterfalse(FilterFunc filter_func,
+            std::initializer_list<T> container) {
         return filter(
-                detail::PredicateFlipper<FilterFunc, std::initializer_list<T>>(filter_func),
+                detail::PredicateFlipper<FilterFunc, std::initializer_list<T>>(
+                    filter_func),
                 std::move(container));
     }
 
     // Single argument version, uses a BoolFlipper to reverse the truthiness
     // of an object
     template <typename T>
-    auto filterfalse(std::initializer_list<T> container) ->
-            decltype(filter(
-                        detail::BoolFlipper<std::initializer_list<T>>(),
-                        std::move(container))) {
+    auto filterfalse(std::initializer_list<T> container) {
         return filter(
                 detail::BoolFlipper<std::initializer_list<T>>(),
                 std::move(container));

From 944d74cc45069157044fc61ffc0b9e14d8181de3 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 9 Feb 2015 15:36:51 -0500
Subject: [PATCH 0946/1866] uses return type deduction

---
 groupby.hpp | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/groupby.hpp b/groupby.hpp
index dcda1fda..f4a59e64 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -258,9 +258,7 @@ namespace iter {
 
 
     template <typename Container>
-    auto groupby(Container&& container) ->
-            decltype(groupby(std::forward<Container>(container),
-                        ItemReturner<Container>())) {
+    auto groupby(Container&& container) {
         return groupby(std::forward<Container>(container),
                 ItemReturner<Container>());
     }
@@ -274,9 +272,7 @@ namespace iter {
 
 
     template <typename T>
-    auto groupby(std::initializer_list<T> il) ->
-            decltype(groupby(std::move(il),
-                        ItemReturner<std::initializer_list<T>>())) {
+    auto groupby(std::initializer_list<T> il) {
         return groupby(
                 std::move(il),
                 ItemReturner<std::initializer_list<T>>());

From 9b120bb1b4d8010ec4dbf4ea5baa9e35ad1d487f Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 9 Feb 2015 15:39:29 -0500
Subject: [PATCH 0947/1866] uses return type deduction

---
 sorted.hpp | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/sorted.hpp b/sorted.hpp
index 5dbbdc9b..7caa2731 100644
--- a/sorted.hpp
+++ b/sorted.hpp
@@ -66,13 +66,10 @@ namespace iter {
     }
 
     template <typename Container>
-    auto sorted(Container&& container) ->
-             decltype(sorted(std::forward<Container>(container),
-                         std::less<iterator_deref<Container>>()))
-     {
-         return sorted(std::forward<Container>(container),
-                 std::less<iterator_deref<Container>>());
-     }
+    auto sorted(Container&& container) {
+        return sorted(std::forward<Container>(container),
+                std::less<iterator_deref<Container>>());
+    }
 
 }
 

From 2e119bec14cee30d9bdfde1c78298e4db1046554 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 9 Feb 2015 16:08:08 -0500
Subject: [PATCH 0948/1866] uses return type deduction

---
 iteratoriterator.hpp | 16 +++++++---------
 1 file changed, 7 insertions(+), 9 deletions(-)

diff --git a/iteratoriterator.hpp b/iteratoriterator.hpp
index 5bd807bc..10faa0ee 100644
--- a/iteratoriterator.hpp
+++ b/iteratoriterator.hpp
@@ -67,11 +67,11 @@ namespace iter {
                 return ret;
             }
 
-            auto operator*() -> decltype(**sub_iter) {
+            decltype(auto) operator*() {
                 return **this->sub_iter;
             }
 
-            auto operator->() -> decltype(*sub_iter) {
+            decltype(auto) operator->() {
                 return *this->sub_iter;
             }
 
@@ -112,7 +112,7 @@ namespace iter {
                 return this->sub_iter - rhs.sub_iter;
             }
 
-            auto operator[](Diff idx) -> decltype(*sub_iter[idx]) {
+            decltype(auto) operator[](Diff idx) {
                 return *sub_iter[idx];
             }
 
@@ -156,24 +156,22 @@ namespace iter {
                 : container(sz, val)
             { }
 
-            auto at(size_type pos) -> decltype(*container.at(pos)) {
+            decltype(auto) at(size_type pos) {
                 return *container.at(pos);
             }
 
-            auto at(size_type pos) const -> decltype(*container.at(pos)) {
+            decltype(auto) at(size_type pos) const {
                 return *container.at(pos);
             }
 
-            auto operator[](size_type pos) 
+            decltype(auto) operator[](size_type pos) 
                 noexcept(noexcept(*container[pos]))
-                -> decltype(*container[pos])
             {
                 return *container[pos];
             }
 
-            auto operator[](size_type pos) const
+            decltype(auto) operator[](size_type pos) const
                 noexcept(noexcept(*container[pos]))
-                -> decltype(*container[pos])
             {
                 return *container[pos];
             }

From bbcb5cd06134163d2d57588e7b90c2344a36fbd3 Mon Sep 17 00:00:00 2001
From: Ryan Haining <rhainin1@binghamton.edu>
Date: Mon, 9 Feb 2015 16:30:35 -0500
Subject: [PATCH 0949/1866] tests that starmap moves and binds correctly

---
 catchtest/test_starmap.cpp | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/catchtest/test_starmap.cpp b/catchtest/test_starmap.cpp
index fc59fd18..ce8d40c6 100644
--- a/catchtest/test_starmap.cpp
+++ b/catchtest/test_starmap.cpp
@@ -87,3 +87,11 @@ TEST_CASE("starmap: tuple of pairs", "[starmap]") {
 
     REQUIRE( v == vc );
 }
+
+TEST_CASE("starmap: moves rvalues, binds to lvalues", "[starmap]") {
+    itertest::BasicIterable<std::tuple<int>> bi{};
+    starmap(Callable{}, bi);
+    REQUIRE_FALSE( bi.was_moved_from() );
+    starmap(Callable{}, std::move(bi));
+    REQUIRE( bi.was_moved_from() );
+}

From eed7e888ffd646af253c3a7dbe0ea8291ebcb102 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Wed, 11 Feb 2015 17:02:11 -0500
Subject: [PATCH 0950/1866] removes const on iterator member

---
 product.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/product.hpp b/product.hpp
index 92e0c5b8..d95d8060 100644
--- a/product.hpp
+++ b/product.hpp
@@ -50,7 +50,7 @@ namespace iter {
                     const iterator_type<Container> begin;
 
                     RestIter rest_iter;
-                    const RestIter rest_end;
+                    RestIter rest_end;
                 public:
                     constexpr static const bool is_base_iter = false;
                     Iterator(iterator_type<Container> it,

From e4fabf39fefb6b0dda5cdc5c2d5ce5af80587c42 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 12 Feb 2015 19:03:02 -0500
Subject: [PATCH 0951/1866] uses implicit tuple<> construction

---
 product.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/product.hpp b/product.hpp
index d95d8060..aaf0f42d 100644
--- a/product.hpp
+++ b/product.hpp
@@ -145,7 +145,7 @@ namespace iter {
                     }
 
                     std::tuple<> operator*() const {
-                        return std::tuple<>{};
+                        return {};
                     }
             };
 

From 62a05115bb53a5aec2b62d380f082041a6c57164 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 17 Feb 2015 11:06:54 -0500
Subject: [PATCH 0952/1866] adds helper to hold intermittent results of deref

For things like filter that may need to dereference multiple times.
Doing so violates the input_iterator guarantees.
---
 iterbase.hpp | 83 +++++++++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 79 insertions(+), 4 deletions(-)

diff --git a/iterbase.hpp b/iterbase.hpp
index 0f0fe1bc..aacd2246 100644
--- a/iterbase.hpp
+++ b/iterbase.hpp
@@ -11,8 +11,9 @@
 #include <utility>
 #include <iterator>
 #include <functional>
-#include <cstddef>
+#include <memory>
 #include <type_traits>
+#include <cstddef>
 
 namespace iter {
 
@@ -24,7 +25,7 @@ namespace iter {
     // iterator_deref<C> is the type obtained by dereferencing an iterator
     // to an object of type C
     template <typename Container>
-    using iterator_deref = 
+    using iterator_deref =
         decltype(*std::declval<iterator_type<Container>&>());
 
     template <typename Container>
@@ -39,7 +40,7 @@ namespace iter {
     // iterator_deref<C> is the type obtained by dereferencing an iterator
     // to an object of type C
     template <typename Container>
-    using reverse_iterator_deref = 
+    using reverse_iterator_deref =
         decltype(*std::declval<reverse_iterator_type<Container>&>());
 
     template <typename, typename =void>
@@ -118,9 +119,83 @@ namespace iter {
     struct are_same : std::true_type { };
 
     template <typename T, typename U, typename... Ts>
-    struct are_same<T, U, Ts...> 
+    struct are_same<T, U, Ts...>
         : std::integral_constant<bool,
             std::is_same<T, U>::value && are_same<T, Ts...>::value> { };
+
+    template <typename T, typename =void>
+    class DerefHolder {
+        private:
+            static_assert(!std::is_lvalue_reference<T>::value,
+                    "Non-lvalue-ref specialization used for lvalue ref type");
+            // it could still be an rvalue reference
+            using TPlain = typename std::remove_reference<T>::type;
+
+            std::unique_ptr<TPlain> item_p;
+
+        public:
+            explicit DerefHolder()
+                : item_p{nullptr}
+            { }
+
+            DerefHolder(const DerefHolder& other)
+                : item_p{new TPlain(*other.item_p)}
+            { }
+
+            DerefHolder& operator=(const DerefHolder& other) {
+                this->item_p.reset(new TPlain(*other.item_p));
+                return *this;
+            }
+
+            DerefHolder(DerefHolder&&) = default;
+            DerefHolder& operator=(DerefHolder&&) = default;
+            ~DerefHolder() = default;
+
+            TPlain& get() {
+                return *item_p;
+            }
+
+            T pull() {
+                return std::move(*item_p);
+                // NOTE should I reset the unique_ptr to nullptr here
+                // since its held item is now invalid anyway?
+            }
+
+            void reset(T&& item) {
+                item_p.reset(new TPlain(std::move(item)));
+            }
+    };
+
+
+    // Specialization for when T is an lvalue ref.  Keep this in mind
+    // wherever a T appears.
+    template <typename T>
+    class DerefHolder<T,
+        typename std::enable_if<std::is_lvalue_reference<T>::value>::type>
+    {
+        private:
+            static_assert(std::is_lvalue_reference<T>::value,
+                    "lvalue specialization handling non-lvalue-ref type");
+            typename std::remove_reference<T>::type *item_p;
+        public:
+            explicit DerefHolder()
+                : item_p{nullptr}
+            { }
+
+            T get() {
+                return *this->item_p;
+            }
+
+            T pull() {
+                return this->get();
+            }
+
+            void reset(T item) {
+                this->item_p = &item;
+            }
+    };
+
+
 }
 
 #endif

From 6feffa46aa0026d55736a3187e6fdbde01b7a930 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 17 Feb 2015 11:08:27 -0500
Subject: [PATCH 0953/1866] tests imap(filter(imap()))

Currently a problem with modifying function
---
 catchtest/test_mixed.cpp | 82 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 82 insertions(+)
 create mode 100644 catchtest/test_mixed.cpp

diff --git a/catchtest/test_mixed.cpp b/catchtest/test_mixed.cpp
new file mode 100644
index 00000000..d3618348
--- /dev/null
+++ b/catchtest/test_mixed.cpp
@@ -0,0 +1,82 @@
+// mixing different itertools, there is nothing called iter::mixed()
+
+
+#include "imap.hpp"
+#include "filter.hpp"
+
+#include "catch.hpp"
+
+#include <iostream>
+#include <vector>
+
+using iter::filter;
+using iter::imap;
+
+class MyUnMovable {
+    int val;
+public:
+    constexpr MyUnMovable(int val)
+        : val{val}
+    { }
+
+    MyUnMovable(const MyUnMovable&) = delete;
+    MyUnMovable& operator=(const MyUnMovable&) = delete;
+
+    MyUnMovable(MyUnMovable&& other)
+        : val{other.val}
+    { }
+
+    constexpr int get_val() const {
+        return val;
+    }
+    void set_val(int val) {
+        this->val = val;        
+    }
+
+    bool operator==(const MyUnMovable& other) const {
+        return this->val == other.val;
+    }
+
+    bool operator!=(const MyUnMovable& other) const {
+        return !(*this == other);
+    }
+};
+
+TEST_CASE("imap and filter where imap Functor modifies its sequence",
+    "[imap][filter]") {
+
+    // source data
+    std::array<MyUnMovable, 3> arr = {{{41}, {42}, {43}}};
+
+    // some transformations
+    auto inc_ten = [](MyUnMovable& el) -> MyUnMovable& {
+        int va = el.get_val();
+        el.set_val(va + 10);
+        return el;
+    };
+    auto dec_ten = [](MyUnMovable& el) -> MyUnMovable& {
+        int va = el.get_val();
+        el.set_val(va - 10);
+        return el;
+    };
+
+    auto transformed1 = imap(inc_ten, arr);
+    auto filtered = filter([](const MyUnMovable& el) {
+        return 52 != el.get_val();
+    }, transformed1);
+    auto transformed2 = imap(dec_ten, filtered);
+
+    std::vector<int> v;
+    for (auto&& el : transformed2) {
+        // I would use imap again instead of the loop if this wasn't an imap
+        // test
+        v.push_back(el.get_val());
+    }
+
+    std::vector<int> vc = {41, 43};
+
+    REQUIRE( v == vc);
+
+    constexpr std::array<MyUnMovable, 3> arrc = {{{41}, {52}, {43}}};
+    REQUIRE( arr == arrc );
+}

From 66ff1840d29d9d26ba8d7d0ed8d4e728e7495e75 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 17 Feb 2015 11:13:37 -0500
Subject: [PATCH 0954/1866] Uses DerefHolder to avoid double-deref

previous deref'd in operator++ (skip_failures) and in operator*
---
 filter.hpp | 19 +++++++++++++++----
 1 file changed, 15 insertions(+), 4 deletions(-)

diff --git a/filter.hpp b/filter.hpp
index fdefe612..54947c5d 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -49,14 +49,22 @@ namespace iter {
                 protected:
                     iterator_type<Container> sub_iter;
                     iterator_type<Container> sub_end;
+                    DerefHolder<iterator_deref<Container>> item;
                     FilterFunc filter_func;
 
+                    void inc_sub_iter() {
+                            ++this->sub_iter;
+                            if (this->sub_iter != this->sub_end) {
+                                this->item.reset(*this->sub_iter);
+                            }
+                    }
+
                     // increment until the iterator points to is true on the 
                     // predicate.  Called by constructor and operator++
                     void skip_failures() { 
                         while (this->sub_iter != this->sub_end
-                                && !this->filter_func(*this->sub_iter)) {
-                            ++this->sub_iter;
+                                && !this->filter_func(this->item.get())) {
+                            this->inc_sub_iter();
                         }
                     }
 
@@ -68,15 +76,18 @@ namespace iter {
                         sub_end{end},
                         filter_func(filter_func)
                     { 
+                        if (this->sub_iter != this->sub_end) {
+                            this->item.reset(*this->sub_iter);
+                        }
                         this->skip_failures();
                     } 
 
                     iterator_deref<Container> operator*() {
-                        return *this->sub_iter;
+                        return this->item.pull();
                     }
 
                     Iterator& operator++() { 
-                        ++this->sub_iter;
+                        this->inc_sub_iter();
                         this->skip_failures();
                         return *this;
                     }

From fe608c7b2a86c1bd78befaabdb69ad4ccce13180 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 17 Feb 2015 11:14:55 -0500
Subject: [PATCH 0955/1866] builds mixed test

---
 catchtest/SConstruct | 1 +
 1 file changed, 1 insertion(+)

diff --git a/catchtest/SConstruct b/catchtest/SConstruct
index 0a8c1e35..80dc8d25 100644
--- a/catchtest/SConstruct
+++ b/catchtest/SConstruct
@@ -45,6 +45,7 @@ progs = Split(
     zip_longest
 
     iteratoriterator
+    mixed
     '''
 )
 

From c5ae80c487c362e6d3f0891fe4ae1b606c68b39d Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 17 Feb 2015 11:18:46 -0500
Subject: [PATCH 0956/1866] moves rather than copies iterators

---
 imap.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/imap.hpp b/imap.hpp
index 9df55a1a..daa8cdb5 100644
--- a/imap.hpp
+++ b/imap.hpp
@@ -98,9 +98,9 @@ namespace iter {
                     ZippedIterType zipiter;
 
                 public:
-                    Iterator(MapFunc map_func, ZippedIterType zipiter) :
+                    Iterator(MapFunc map_func, ZippedIterType&& in_zipiter) :
                         map_func(map_func),
-                        zipiter(zipiter)
+                        zipiter(std::move(in_zipiter))
                     { } 
 
                     IMapIterDeref operator*() {

From 4bc52a9dfe1a5c70962268ef126096b02a8588cc Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 17 Feb 2015 11:19:03 -0500
Subject: [PATCH 0957/1866] moves rather than copies iterators

---
 zip.hpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/zip.hpp b/zip.hpp
index 64b3f087..285146a8 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -48,9 +48,9 @@ namespace iter {
                     RestIter rest_iter;
                 public:
                     constexpr static const bool is_base_iter = false;
-                    Iterator(iterator_type<Container> it, const RestIter& rest)
-                        : iter{it},
-                        rest_iter{rest}
+                    Iterator(iterator_type<Container>&& it, RestIter&& rest)
+                        : iter{std::move(it)},
+                        rest_iter{std::move(rest)}
                     { }
 
                     Iterator& operator++() {

From 4e6a8433ee675f36a557395869b87323ce97a7f1 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 17 Feb 2015 11:33:23 -0500
Subject: [PATCH 0958/1866] moves iterators rather than copies

---
 accumulate.hpp | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/accumulate.hpp b/accumulate.hpp
index 8df2e409..06f22168 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -35,7 +35,7 @@ namespace iter {
             template <typename T, typename AF>
             friend Accumulator<std::initializer_list<T>, AF> accumulate(
                     std::initializer_list<T>, AF);
-            
+
             // AccumVal must be default constructible
             using AccumVal =
                 typename std::remove_reference<
@@ -61,11 +61,11 @@ namespace iter {
                     AccumulateFunc accumulate_func;
                     AccumVal acc_val;
                 public:
-                    Iterator (iterator_type<Container> iter,
-                            iterator_type<Container> end,
+                    Iterator (iterator_type<Container>&& iter,
+                            iterator_type<Container>&& end,
                             AccumulateFunc accumulate_func)
-                        : sub_iter{iter},
-                        sub_end{end},
+                        : sub_iter{std::move(iter)},
+                        sub_end{std::move(end)},
                         accumulate_func(accumulate_func),
                         // only get first value if not an end iterator
                         acc_val(!(iter != end) ? AccumVal{} : *iter)

From ea211ad418e8f81f2be0cadd12b0262e2ceac835 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 17 Feb 2015 11:35:54 -0500
Subject: [PATCH 0959/1866] moves iterators rather than copies

---
 chain.hpp | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/chain.hpp b/chain.hpp
index 5130dc56..a05a39da 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -50,12 +50,12 @@ namespace iter {
                     bool at_end;
 
                 public:
-                    Iterator(const iterator_type<Container>& s_begin,
-                            const iterator_type<Container>& s_end,
-                            RestIter rest_iter)
-                        : sub_iter{s_begin},
-                        sub_end{s_end},
-                        rest_iter{rest_iter},
+                    Iterator(iterator_type<Container>&& s_begin,
+                            iterator_type<Container>&& s_end,
+                            RestIter&& rest_iter)
+                        : sub_iter{std::move(s_begin)},
+                        sub_end{std::move(s_end)},
+                        rest_iter{std::move(rest_iter)},
                         at_end{!(sub_iter != sub_end)}
                     { }
                     
@@ -211,10 +211,10 @@ namespace iter {
                    }
 
                 public:
-                   Iterator(iterator_type<Container> top_iter,
-                           iterator_type<Container> top_end)
-                       : top_level_iter{top_iter},
-                       top_level_end{top_end},
+                   Iterator(iterator_type<Container>&& top_iter,
+                           iterator_type<Container>&& top_end)
+                       : top_level_iter{std::move(top_iter)},
+                       top_level_end{std::move(top_end)},
                        sub_iter_p{!(top_iter != top_end) ?  // iter == end ?
                            nullptr : new SubIter{std::begin(*top_iter)}},
                        sub_end_p{!(top_iter != top_end) ?  // iter == end ?

From 4f052c3f58f479955cf17b610a36c2c7f5db36b1 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 17 Feb 2015 11:38:06 -0500
Subject: [PATCH 0960/1866] moves iterators rather than copies

---
 compress.hpp | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/compress.hpp b/compress.hpp
index 4dfab7a8..29318fe3 100644
--- a/compress.hpp
+++ b/compress.hpp
@@ -89,14 +89,14 @@ namespace iter {
                     }
 
                 public:
-                    Iterator(iterator_type<Container> cont_iter,
-                            iterator_type<Container> cont_end,
-                            selector_iter_type sel_iter,
-                            selector_iter_type sel_end)
-                        : sub_iter{cont_iter},
-                        sub_end{cont_end},
-                        selector_iter{sel_iter},
-                        selector_end{sel_end}
+                    Iterator(iterator_type<Container>&& cont_iter,
+                            iterator_type<Container>&& cont_end,
+                            selector_iter_type&& sel_iter,
+                            selector_iter_type&& sel_end)
+                        : sub_iter{std::move(cont_iter)},
+                        sub_end{std::move(cont_end)},
+                        selector_iter{std::move(sel_iter)},
+                        selector_end{std::move(sel_end)}
                     { 
                         this->skip_failures();
                     } 

From 86a3d94f23567b16dbabde7a36a0c53059d2d348 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 17 Feb 2015 11:39:25 -0500
Subject: [PATCH 0961/1866] moves end, copies begin

---
 cycle.hpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/cycle.hpp b/cycle.hpp
index 484fc922..d63403ba 100644
--- a/cycle.hpp
+++ b/cycle.hpp
@@ -43,11 +43,11 @@ namespace iter {
                     iterator_type<Container> begin;
                     iterator_type<Container> end;
                 public:
-                    Iterator (iterator_type<Container> iter,
-                            iterator_type<Container> end)
+                    Iterator (const iterator_type<Container>& iter,
+                            iterator_type<Container>&& end)
                         : sub_iter{iter},
                         begin{iter},
-                        end{end}
+                        end{std::move(end)}
                     { } 
 
                     iterator_deref<Container> operator*() {

From bf33f346314b14d2ddcc1f85badbb8476e512c83 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 17 Feb 2015 11:40:42 -0500
Subject: [PATCH 0962/1866] moves iterators rather than copies

---
 dropwhile.hpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/dropwhile.hpp b/dropwhile.hpp
index 169aa305..55c10fc6 100644
--- a/dropwhile.hpp
+++ b/dropwhile.hpp
@@ -56,11 +56,11 @@ namespace iter {
                     }
 
                 public:
-                    Iterator (iterator_type<Container> iter,
-                            iterator_type<Container> end,
+                    Iterator(iterator_type<Container>&& iter,
+                            iterator_type<Container>&& end,
                             FilterFunc filter_func)
-                        : sub_iter{iter},
-                        sub_end{end},
+                        : sub_iter{std::move(iter)},
+                        sub_end{std::move(end)},
                         filter_func(filter_func)
                     { 
                         this->skip_passes();

From b2e4e224b236142ffc1e271bb8f4ce1edf469424 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 17 Feb 2015 11:41:12 -0500
Subject: [PATCH 0963/1866] moves iterators rather than copies

---
 enumerate.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index cba785f5..c9b7ee76 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -71,8 +71,8 @@ namespace iter {
                     iterator_type<Container> sub_iter;
                     std::size_t index;
                 public:
-                    Iterator(const iterator_type<Container>& si)
-                        : sub_iter{si},
+                    Iterator(iterator_type<Container>&& si)
+                        : sub_iter{std::move(si)},
                         index{0}
                     { } 
 

From 13874b6e4bb5fe6e11da4c8ac137f09ed361d4bd Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 17 Feb 2015 11:42:39 -0500
Subject: [PATCH 0964/1866] moves iterators rather than copies

---
 groupby.hpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/groupby.hpp b/groupby.hpp
index 42768202..a78cc69a 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -66,11 +66,11 @@ namespace iter {
                     KeyFunc key_func;
 
                 public:
-                    Iterator (iterator_type<Container> si,
-                              iterator_type<Container> end,
+                    Iterator(iterator_type<Container>&& si,
+                              iterator_type<Container>&& end,
                               KeyFunc key_func)
-                        : sub_iter{si},
-                        sub_end{end},
+                        : sub_iter{std::move(si)},
+                        sub_end{std::move(end)},
                         key_func(key_func)
                     { }
 

From 9c5ed817ebf0f31fa88a5e3d380d90d9387f3e3d Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 17 Feb 2015 11:43:25 -0500
Subject: [PATCH 0965/1866] eliminates extra copies

---
 grouper.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/grouper.hpp b/grouper.hpp
index 3cb69fe1..c96a9f80 100644
--- a/grouper.hpp
+++ b/grouper.hpp
@@ -67,8 +67,8 @@ namespace iter {
                     }
 
                 public: 
-                    Iterator(iterator_type<Container> in_iter,
-                            iterator_type<Container> in_end,
+                    Iterator(iterator_type<Container>&& in_iter,
+                            iterator_type<Container>&& in_end,
                             std::size_t s)
                         : sub_iter{std::move(in_iter)},
                         sub_end{std::move(in_end)},

From 707f0aab6ce01a9969b03881fd0e5d26dac33ef6 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 17 Feb 2015 11:44:52 -0500
Subject: [PATCH 0966/1866] eliminates extra copies

---
 permutations.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/permutations.hpp b/permutations.hpp
index c16a8f4e..547b6aef 100644
--- a/permutations.hpp
+++ b/permutations.hpp
@@ -40,8 +40,8 @@ namespace iter {
                     int steps{};
 
                 public:
-                    Iterator(iterator_type<Container> sub_iter,
-                            iterator_type<Container> sub_end)
+                    Iterator(iterator_type<Container>&& sub_iter,
+                            iterator_type<Container>&& sub_end)
                         : steps{ sub_iter != sub_end ? 0 : COMPLETE }
                     {
                         // done like this instead of using vector ctor with

From 9e8aeaaeea1753539d3fcabfef7bcf21ccc41385 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 17 Feb 2015 11:46:33 -0500
Subject: [PATCH 0967/1866] removes extra moves

---
 product.hpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/product.hpp b/product.hpp
index aaf0f42d..2866406f 100644
--- a/product.hpp
+++ b/product.hpp
@@ -53,9 +53,9 @@ namespace iter {
                     RestIter rest_end;
                 public:
                     constexpr static const bool is_base_iter = false;
-                    Iterator(iterator_type<Container> it,
-                            const RestIter& rest,
-                            const RestIter& in_rest_end)
+                    Iterator(const iterator_type<Container>& it,
+                            RestIter&& rest,
+                            RestIter&& in_rest_end)
                         : iter{it},
                         begin{it},
                         rest_iter{rest},

From a3e11c95d44d1fb5314d8e9d442104079858e937 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 17 Feb 2015 11:48:06 -0500
Subject: [PATCH 0968/1866] moves iterators rather than copies

---
 reversed.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/reversed.hpp b/reversed.hpp
index 9d580ec5..b9427f72 100644
--- a/reversed.hpp
+++ b/reversed.hpp
@@ -32,8 +32,8 @@ namespace iter {
                 private:
                     reverse_iterator_type<Container> sub_iter;
                 public:
-                    Iterator (reverse_iterator_type<Container> iter)
-                        : sub_iter{iter}
+                    Iterator (reverse_iterator_type<Container>&& iter)
+                        : sub_iter{std::move(iter)}
                     { } 
 
                     reverse_iterator_deref<Container> operator*() {

From bca97a5fee82fea7407df4ed335c2d440ca1cdb2 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 17 Feb 2015 11:49:13 -0500
Subject: [PATCH 0969/1866] moves iterators rather than copies

---
 slice.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/slice.hpp b/slice.hpp
index d04f863b..f31e164b 100644
--- a/slice.hpp
+++ b/slice.hpp
@@ -54,8 +54,8 @@ namespace iter {
                     DifferenceType step;
 
                 public:
-                    Iterator (iterator_type<Container> si,
-                            iterator_type<Container> se,
+                    Iterator (iterator_type<Container>&& si,
+                            iterator_type<Container>&& se,
                             DifferenceType start,
                             DifferenceType stop,
                             DifferenceType step)

From b088968d91e1588df9bf0251b18b11fc3e8e2d4d Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 17 Feb 2015 11:51:32 -0500
Subject: [PATCH 0970/1866] eliminates extra iterator copies

---
 sliding_window.hpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/sliding_window.hpp b/sliding_window.hpp
index 94cc66e7..7780f183 100644
--- a/sliding_window.hpp
+++ b/sliding_window.hpp
@@ -48,13 +48,14 @@ namespace iter {
                     DerefVec window;
 
                 public:
-                    Iterator(const iterator_type<Container>& in_iter,
+                    Iterator(iterator_type<Container>&& in_iter,
                             const iterator_type<Container>& in_end,
                              std::size_t window_sz)
-                        : sub_iter(in_iter)
+                        : sub_iter(std::move(in_iter))
                     {
                         std::size_t i{0};
-                        while (i < window_sz && this->sub_iter != in_end) {
+                        while (i < window_sz
+                                && this->sub_iter != in_end) {
                             this->window.get().push_back(this->sub_iter);
                             ++i;
                             if (i != window_sz) ++this->sub_iter;

From 41380f3299d406ce4e0d4506d34c5a0ee7c9f9e3 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 17 Feb 2015 11:52:55 -0500
Subject: [PATCH 0971/1866] moves iterators rather than copies

---
 takewhile.hpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/takewhile.hpp b/takewhile.hpp
index 12eb4368..2c851db4 100644
--- a/takewhile.hpp
+++ b/takewhile.hpp
@@ -58,11 +58,11 @@ namespace iter {
                     }
 
                 public:
-                    Iterator(iterator_type<Container> iter,
-                            iterator_type<Container> end,
+                    Iterator(iterator_type<Container>&& iter,
+                            iterator_type<Container>&& end,
                             FilterFunc filter_func)
-                        : sub_iter{iter},
-                        sub_end{end},
+                        : sub_iter{std::move(iter)},
+                        sub_end{std::move(end)},
                         filter_func(filter_func)
                     { 
                         if (this->sub_iter != this->sub_end) {

From 2d1566cdf8ee7803a02c45328d75b696e8c814de Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 17 Feb 2015 11:55:18 -0500
Subject: [PATCH 0972/1866] moves iterators rather than copies

---
 zip_longest.hpp | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/zip_longest.hpp b/zip_longest.hpp
index cc6705b9..044a9191 100644
--- a/zip_longest.hpp
+++ b/zip_longest.hpp
@@ -57,12 +57,12 @@ namespace iter {
 
                 public:
                     Iterator(
-                            iterator_type<Container> it,
-                            iterator_type<Container> in_end,
-                            const RestIter& rest)
-                        : iter{it},
-                        end{in_end},
-                        rest_iter{rest}
+                            iterator_type<Container>&& it,
+                            iterator_type<Container>&& in_end,
+                            RestIter&& rest)
+                        : iter{std::move(it)},
+                        end{std::move(in_end)},
+                        rest_iter{std::move(rest)}
                     { }
 
                     Iterator& operator++() {

From 2552d4bdc4ae3e6fffe787be5620dfb93a355025 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 17 Feb 2015 18:10:01 -0500
Subject: [PATCH 0973/1866] adds double-deref test for dropwhile

---
 catchtest/test_mixed.cpp | 45 +++++++++++++++++++++++++++++-----------
 1 file changed, 33 insertions(+), 12 deletions(-)

diff --git a/catchtest/test_mixed.cpp b/catchtest/test_mixed.cpp
index d3618348..f78b7fe9 100644
--- a/catchtest/test_mixed.cpp
+++ b/catchtest/test_mixed.cpp
@@ -1,17 +1,13 @@
 // mixing different itertools, there is nothing called iter::mixed()
 
 
-#include "imap.hpp"
-#include "filter.hpp"
+#include "itertools.hpp"
 
 #include "catch.hpp"
 
 #include <iostream>
 #include <vector>
 
-using iter::filter;
-using iter::imap;
-
 class MyUnMovable {
     int val;
 public:
@@ -42,13 +38,7 @@ class MyUnMovable {
     }
 };
 
-TEST_CASE("imap and filter where imap Functor modifies its sequence",
-    "[imap][filter]") {
-
-    // source data
-    std::array<MyUnMovable, 3> arr = {{{41}, {42}, {43}}};
-
-    // some transformations
+namespace {
     auto inc_ten = [](MyUnMovable& el) -> MyUnMovable& {
         int va = el.get_val();
         el.set_val(va + 10);
@@ -59,6 +49,14 @@ TEST_CASE("imap and filter where imap Functor modifies its sequence",
         el.set_val(va - 10);
         return el;
     };
+}
+
+TEST_CASE("filtering doesn't dereference multiple times", "[imap][filter]") {
+    using iter::filter;
+    using iter::imap;
+
+    // source data
+    std::array<MyUnMovable, 3> arr = {{{41}, {42}, {43}}};
 
     auto transformed1 = imap(inc_ten, arr);
     auto filtered = filter([](const MyUnMovable& el) {
@@ -80,3 +78,26 @@ TEST_CASE("imap and filter where imap Functor modifies its sequence",
     constexpr std::array<MyUnMovable, 3> arrc = {{{41}, {52}, {43}}};
     REQUIRE( arr == arrc );
 }
+
+TEST_CASE("dropwhile doesn't dereference multiple times", "[imap][dropwhile]"){
+    using iter::imap;
+    using iter::dropwhile;
+    // source data
+    std::array<MyUnMovable, 3> arr = {{{41}, {42}, {43}}};
+
+    auto transformed1 = imap(inc_ten, arr);
+    auto filtered = dropwhile([](const MyUnMovable& el) {
+        return 52 != el.get_val();
+    }, transformed1);
+    auto transformed2 = imap(dec_ten, filtered);
+
+    std::vector<int> v;
+    for (auto&& el : transformed2) {
+        v.push_back(el.get_val());
+    }
+
+    std::vector<int> vc = {42, 43};
+
+    constexpr std::array<MyUnMovable, 3> arrc = {{{51}, {42}, {43}}};
+    REQUIRE( arr == arrc );
+}

From 019d30e2f6fb85220d693464024c865cc65a1388 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 17 Feb 2015 18:10:36 -0500
Subject: [PATCH 0974/1866] removes include of wrap_iter

---
 itertools.hpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/itertools.hpp b/itertools.hpp
index 55039902..8e84eed3 100644
--- a/itertools.hpp
+++ b/itertools.hpp
@@ -27,7 +27,6 @@
 #include "takewhile.hpp"
 #include "unique_everseen.hpp"
 #include "unique_justseen.hpp"
-#include "wrap_iter.hpp"
 #include "zip.hpp"
 #include "zip_longest.hpp"
 

From e39e1f5c3529a503a6194ffb8cca8b0da6a3f80a Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 17 Feb 2015 19:33:06 -0500
Subject: [PATCH 0975/1866] tests dropwhile for multiple dereferencing

---
 catchtest/test_mixed.cpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/catchtest/test_mixed.cpp b/catchtest/test_mixed.cpp
index f78b7fe9..f98fc0c2 100644
--- a/catchtest/test_mixed.cpp
+++ b/catchtest/test_mixed.cpp
@@ -98,6 +98,8 @@ TEST_CASE("dropwhile doesn't dereference multiple times", "[imap][dropwhile]"){
 
     std::vector<int> vc = {42, 43};
 
-    constexpr std::array<MyUnMovable, 3> arrc = {{{51}, {42}, {43}}};
-    REQUIRE( arr == arrc );
+    std::vector<int> vsc = {51, 42, 43};
+    auto get_vals = imap([](const MyUnMovable& mv){return mv.get_val();}, arr);
+    std::vector<int> vs(std::begin(get_vals), std::end(get_vals));
+    REQUIRE( vs == vsc );
 }

From a7d4e6dac09a776e056e158535e1d03f62b6b569 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 17 Feb 2015 19:33:27 -0500
Subject: [PATCH 0976/1866] removes multiple dereference from dropwhile

---
 dropwhile.hpp | 19 +++++++++++++++----
 1 file changed, 15 insertions(+), 4 deletions(-)

diff --git a/dropwhile.hpp b/dropwhile.hpp
index 55c10fc6..3e905170 100644
--- a/dropwhile.hpp
+++ b/dropwhile.hpp
@@ -45,13 +45,21 @@ namespace iter {
                 private:
                     iterator_type<Container> sub_iter;
                     iterator_type<Container> sub_end;
+                    DerefHolder<iterator_deref<Container>> item;
                     FilterFunc filter_func;
 
+                    void inc_sub_iter() {
+                            ++this->sub_iter;
+                            if (this->sub_iter != this->sub_end) {
+                                this->item.reset(*this->sub_iter);
+                            }
+                    }
+
                     // skip all values for which the predicate is true
                     void skip_passes() { 
                         while (this->sub_iter != this->sub_end
-                                && this->filter_func(*this->sub_iter)) {
-                            ++this->sub_iter;
+                                && this->filter_func(this->item.get())) {
+                            this->inc_sub_iter();
                         }
                     }
 
@@ -63,15 +71,18 @@ namespace iter {
                         sub_end{std::move(end)},
                         filter_func(filter_func)
                     { 
+                        if (this->sub_iter != this->sub_end) {
+                            this->item.reset(*this->sub_iter);
+                        }
                         this->skip_passes();
                     } 
 
                     iterator_deref<Container> operator*() {
-                        return *this->sub_iter;
+                        return this->item.pull();
                     }
 
                     Iterator& operator++() { 
-                        ++this->sub_iter;
+                        this->inc_sub_iter();
                         return *this;
                     }
 

From c8fa12aa7ebf4cac40988c6d2baa3f4a3a1aa6b6 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 17 Feb 2015 19:53:41 -0500
Subject: [PATCH 0977/1866] tests filter iterator assignment

---
 catchtest/test_filter.cpp | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/catchtest/test_filter.cpp b/catchtest/test_filter.cpp
index eb21b2c2..985e38e2 100644
--- a/catchtest/test_filter.cpp
+++ b/catchtest/test_filter.cpp
@@ -53,6 +53,14 @@ TEST_CASE("filter: handles different functor types", "[filter]") {
     }
 }
 
+TEST_CASE("filter: iterator with lambda can be assigned", "[filter]") {
+    Vec ns{};
+    auto ltf = [](int i) {return i < 5;};
+    auto f = filter(ltf, ns);
+    auto it = std::begin(f);
+    it = std::begin(f);
+}
+
 TEST_CASE("filter: using identity", "[filter]") {
     Vec ns{0, 1, 2, 0, 3, 0, 0, 0, 4, 5, 0};
     auto f = filter(ns);

From 32495f9b2a7ead95707c146c8d252b117659ae25 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 17 Feb 2015 19:54:07 -0500
Subject: [PATCH 0978/1866] uses pointer to FuncType for iterator operator=

Without this, Filter::Iterator::operator= fails with lambdas since
lambdas can't be assigned (apparently).
---
 filter.hpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/filter.hpp b/filter.hpp
index 54947c5d..b9136874 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -50,7 +50,7 @@ namespace iter {
                     iterator_type<Container> sub_iter;
                     iterator_type<Container> sub_end;
                     DerefHolder<iterator_deref<Container>> item;
-                    FilterFunc filter_func;
+                    FilterFunc *filter_func;
 
                     void inc_sub_iter() {
                             ++this->sub_iter;
@@ -63,7 +63,7 @@ namespace iter {
                     // predicate.  Called by constructor and operator++
                     void skip_failures() { 
                         while (this->sub_iter != this->sub_end
-                                && !this->filter_func(this->item.get())) {
+                                && !(*this->filter_func)(this->item.get())) {
                             this->inc_sub_iter();
                         }
                     }
@@ -71,10 +71,10 @@ namespace iter {
                 public:
                     Iterator (iterator_type<Container> iter,
                             iterator_type<Container> end,
-                            FilterFunc filter_func)
+                            FilterFunc& filter_func)
                         : sub_iter{iter},
                         sub_end{end},
-                        filter_func(filter_func)
+                        filter_func(&filter_func)
                     { 
                         if (this->sub_iter != this->sub_end) {
                             this->item.reset(*this->sub_iter);

From 3f137ced732328c7a6d832bc1fb2e14bc7566846 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 17 Feb 2015 19:56:03 -0500
Subject: [PATCH 0979/1866] FilterFunc * for dropwhile iterator

---
 dropwhile.hpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/dropwhile.hpp b/dropwhile.hpp
index 3e905170..a89e5a81 100644
--- a/dropwhile.hpp
+++ b/dropwhile.hpp
@@ -46,7 +46,7 @@ namespace iter {
                     iterator_type<Container> sub_iter;
                     iterator_type<Container> sub_end;
                     DerefHolder<iterator_deref<Container>> item;
-                    FilterFunc filter_func;
+                    FilterFunc *filter_func;
 
                     void inc_sub_iter() {
                             ++this->sub_iter;
@@ -58,7 +58,7 @@ namespace iter {
                     // skip all values for which the predicate is true
                     void skip_passes() { 
                         while (this->sub_iter != this->sub_end
-                                && this->filter_func(this->item.get())) {
+                                && (*this->filter_func)(this->item.get())) {
                             this->inc_sub_iter();
                         }
                     }
@@ -66,10 +66,10 @@ namespace iter {
                 public:
                     Iterator(iterator_type<Container>&& iter,
                             iterator_type<Container>&& end,
-                            FilterFunc filter_func)
+                            FilterFunc& filter_func)
                         : sub_iter{std::move(iter)},
                         sub_end{std::move(end)},
-                        filter_func(filter_func)
+                        filter_func(&filter_func)
                     { 
                         if (this->sub_iter != this->sub_end) {
                             this->item.reset(*this->sub_iter);

From 90275c1cc8e9011b07094756e06191c9cd51760c Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 17 Feb 2015 19:56:48 -0500
Subject: [PATCH 0980/1866] takewhile uses derefholder

---
 takewhile.hpp | 18 +++++++++++++-----
 1 file changed, 13 insertions(+), 5 deletions(-)

diff --git a/takewhile.hpp b/takewhile.hpp
index 2c851db4..bbf0a21d 100644
--- a/takewhile.hpp
+++ b/takewhile.hpp
@@ -48,11 +48,19 @@ namespace iter {
                 private:
                     iterator_type<Container> sub_iter;
                     iterator_type<Container> sub_end;
+                    DerefHolder<iterator_deref<Container>> item;
                     FilterFunc filter_func;
 
+                    void inc_sub_iter() {
+                        ++this->sub_iter;
+                        if (this->sub_iter != this->sub_end) {
+                            this->item.reset(*this->sub_iter);
+                        }
+                    }
+
                     void check_current() {
                         if (this->sub_iter != this->sub_end
-                                && !this->filter_func(*this->sub_iter)) {
+                                && !this->filter_func(this->item.get())) {
                             this->sub_iter = this->sub_end;
                         }
                     }
@@ -66,17 +74,17 @@ namespace iter {
                         filter_func(filter_func)
                     { 
                         if (this->sub_iter != this->sub_end) {
-                            // only do the check if not already at the end
-                            this->check_current();
+                            this->item.reset(*this->sub_iter);
                         }
+                        this->check_current();
                     } 
 
                     iterator_deref<Container> operator*() {
-                        return *this->sub_iter;
+                        return this->item.pull();
                     }
 
                     Iterator& operator++() { 
-                        ++this->sub_iter;
+                        this->inc_sub_iter();
                         this->check_current();
                         return *this;
                     }

From 4c689e6948d5d3d5461ce7aa7b232ecc48bedfd5 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 17 Feb 2015 19:58:25 -0500
Subject: [PATCH 0981/1866] imap iterator uses MapFunc *

---
 imap.hpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/imap.hpp b/imap.hpp
index daa8cdb5..79a8deae 100644
--- a/imap.hpp
+++ b/imap.hpp
@@ -94,18 +94,18 @@ namespace iter {
                     typename std::remove_reference<IMapIterDeref>::type >
             {
                 private:
-                    MapFunc map_func;
+                    MapFunc *map_func;
                     ZippedIterType zipiter;
 
                 public:
-                    Iterator(MapFunc map_func, ZippedIterType&& in_zipiter) :
-                        map_func(map_func),
+                    Iterator(MapFunc& map_func, ZippedIterType&& in_zipiter) :
+                        map_func(&map_func),
                         zipiter(std::move(in_zipiter))
                     { } 
 
                     IMapIterDeref operator*() {
                         return detail::call_with_tuple(
-                                this->map_func, *(this->zipiter));
+                                *this->map_func, *(this->zipiter));
                     }
 
                     Iterator& operator++() { 

From fb3518123500d67248399241c32a8e92e5c5c020 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 17 Feb 2015 19:58:49 -0500
Subject: [PATCH 0982/1866] takewhile iterator uses FiterFunc*

---
 takewhile.hpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/takewhile.hpp b/takewhile.hpp
index bbf0a21d..bd518c32 100644
--- a/takewhile.hpp
+++ b/takewhile.hpp
@@ -49,7 +49,7 @@ namespace iter {
                     iterator_type<Container> sub_iter;
                     iterator_type<Container> sub_end;
                     DerefHolder<iterator_deref<Container>> item;
-                    FilterFunc filter_func;
+                    FilterFunc *filter_func;
 
                     void inc_sub_iter() {
                         ++this->sub_iter;
@@ -60,7 +60,7 @@ namespace iter {
 
                     void check_current() {
                         if (this->sub_iter != this->sub_end
-                                && !this->filter_func(this->item.get())) {
+                                && !(*this->filter_func)(this->item.get())) {
                             this->sub_iter = this->sub_end;
                         }
                     }
@@ -68,10 +68,10 @@ namespace iter {
                 public:
                     Iterator(iterator_type<Container>&& iter,
                             iterator_type<Container>&& end,
-                            FilterFunc filter_func)
+                            FilterFunc& filter_func)
                         : sub_iter{std::move(iter)},
                         sub_end{std::move(end)},
-                        filter_func(filter_func)
+                        filter_func(&filter_func)
                     { 
                         if (this->sub_iter != this->sub_end) {
                             this->item.reset(*this->sub_iter);

From 70c2e380db3330f1847d7c52dfb6d327db717b2b Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 17 Feb 2015 19:59:11 -0500
Subject: [PATCH 0983/1866] tests takewhile for double-deref

---
 catchtest/test_mixed.cpp | 27 ++++++++++++++++++++++++++-
 1 file changed, 26 insertions(+), 1 deletion(-)

diff --git a/catchtest/test_mixed.cpp b/catchtest/test_mixed.cpp
index f98fc0c2..f0ed106e 100644
--- a/catchtest/test_mixed.cpp
+++ b/catchtest/test_mixed.cpp
@@ -82,7 +82,7 @@ TEST_CASE("filtering doesn't dereference multiple times", "[imap][filter]") {
 TEST_CASE("dropwhile doesn't dereference multiple times", "[imap][dropwhile]"){
     using iter::imap;
     using iter::dropwhile;
-    // source data
+
     std::array<MyUnMovable, 3> arr = {{{41}, {42}, {43}}};
 
     auto transformed1 = imap(inc_ten, arr);
@@ -103,3 +103,28 @@ TEST_CASE("dropwhile doesn't dereference multiple times", "[imap][dropwhile]"){
     std::vector<int> vs(std::begin(get_vals), std::end(get_vals));
     REQUIRE( vs == vsc );
 }
+
+TEST_CASE("takewhile doesn't dereference multiple times", "[imap][takewhile]"){
+    using iter::imap;
+    using iter::takewhile;
+
+    std::array<MyUnMovable, 3> arr = {{{41}, {42}, {43}}};
+
+    auto transformed1 = imap(inc_ten, arr);
+    auto filtered = takewhile([](const MyUnMovable& el) {
+        return 53 != el.get_val();
+    }, transformed1);
+    auto transformed2 = imap(dec_ten, filtered);
+
+    std::vector<int> v;
+    for (auto&& el : transformed2) {
+        v.push_back(el.get_val());
+    }
+
+    std::vector<int> vc = {41, 42};
+
+    std::vector<int> vsc = {41, 42, 53};
+    auto get_vals = imap([](const MyUnMovable& mv){return mv.get_val();}, arr);
+    std::vector<int> vs(std::begin(get_vals), std::end(get_vals));
+    REQUIRE( vs == vsc );
+}

From 72a2ed8bd5fe2a6a194f290948d04cee57f63e08 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 17 Feb 2015 19:59:26 -0500
Subject: [PATCH 0984/1866] simplifies DerefHolder

---
 iterbase.hpp | 11 ++---------
 1 file changed, 2 insertions(+), 9 deletions(-)

diff --git a/iterbase.hpp b/iterbase.hpp
index aacd2246..3b111040 100644
--- a/iterbase.hpp
+++ b/iterbase.hpp
@@ -134,10 +134,6 @@ namespace iter {
             std::unique_ptr<TPlain> item_p;
 
         public:
-            explicit DerefHolder()
-                : item_p{nullptr}
-            { }
-
             DerefHolder(const DerefHolder& other)
                 : item_p{new TPlain(*other.item_p)}
             { }
@@ -176,12 +172,9 @@ namespace iter {
         private:
             static_assert(std::is_lvalue_reference<T>::value,
                     "lvalue specialization handling non-lvalue-ref type");
-            typename std::remove_reference<T>::type *item_p;
-        public:
-            explicit DerefHolder()
-                : item_p{nullptr}
-            { }
 
+            typename std::remove_reference<T>::type *item_p =nullptr;
+        public:
             T get() {
                 return *this->item_p;
             }

From 14c5246a13e6a4fdcec561d08e3aca1ba9430de6 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 17 Feb 2015 20:02:42 -0500
Subject: [PATCH 0985/1866] uses default argument to eliminate count overload

---
 count.hpp | 11 ++---------
 1 file changed, 2 insertions(+), 9 deletions(-)

diff --git a/count.hpp b/count.hpp
index e0bc7cd0..c4e62087 100644
--- a/count.hpp
+++ b/count.hpp
@@ -7,13 +7,6 @@
 
 namespace iter {
 
-    using DefaultRangeType = long;
-
-    auto count() -> decltype(range(DefaultRangeType(0), DefaultRangeType(0))) {
-        return range(DefaultRangeType(0),
-                std::numeric_limits<DefaultRangeType>::max());
-    }
-
     template <typename T>
     auto count(T start, T step) -> decltype(range(start, start, start)) {
         // if step is < 0, set the stop to numeric min, otherwise numeric max
@@ -22,8 +15,8 @@ namespace iter {
         return range(start, stop, step);
     }
 
-    template <typename T>
-    auto count(T start) -> decltype(range(start, start)) {
+    template <typename T =long>
+    auto count(T start =T(0)) -> decltype(range(start, start)) {
         return count(start, T(1));
     }
 }

From cfd592f1993ecde77b3f5966963fc3b2260da31d Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 17 Feb 2015 23:59:29 -0500
Subject: [PATCH 0986/1866] checks for null when copying DerefHolder

---
 iterbase.hpp | 25 ++++++++++++++++++++++---
 1 file changed, 22 insertions(+), 3 deletions(-)

diff --git a/iterbase.hpp b/iterbase.hpp
index 3b111040..58d6ee96 100644
--- a/iterbase.hpp
+++ b/iterbase.hpp
@@ -123,6 +123,16 @@ namespace iter {
         : std::integral_constant<bool,
             std::is_same<T, U>::value && are_same<T, Ts...>::value> { };
 
+    // DerefHolder holds the value gotten from an iterator dereference
+    // if the iterate dereferences to an lvalue references, a pointer to the
+    //     element is stored
+    // if it does not, a value is stored instead
+    // get() returns a reference to the held item in either case
+    // pull() should be used when the item is being "pulled out" of the
+    //     DerefHolder.  after pull() is called, neither it nor get() can be
+    //     safely called after
+    // reset() replaces the currently held item and may be called after pull()
+
     template <typename T, typename =void>
     class DerefHolder {
         private:
@@ -135,11 +145,12 @@ namespace iter {
 
         public:
             DerefHolder(const DerefHolder& other)
-                : item_p{new TPlain(*other.item_p)}
+                : item_p{other.item_p ? new TPlain(*other.item_p) : nullptr}
             { }
 
             DerefHolder& operator=(const DerefHolder& other) {
-                this->item_p.reset(new TPlain(*other.item_p));
+                this->item_p.reset(other.item_p
+                        ? new TPlain(*other.item_p) : nullptr);
                 return *this;
             }
 
@@ -152,14 +163,18 @@ namespace iter {
             }
 
             T pull() {
-                return std::move(*item_p);
                 // NOTE should I reset the unique_ptr to nullptr here
                 // since its held item is now invalid anyway?
+                return std::move(*item_p);
             }
 
             void reset(T&& item) {
                 item_p.reset(new TPlain(std::move(item)));
             }
+
+            explicit operator bool() const {
+                return this->item_p;
+            }
     };
 
 
@@ -186,6 +201,10 @@ namespace iter {
             void reset(T item) {
                 this->item_p = &item;
             }
+
+            explicit operator bool() const {
+                return this->item_p != nullptr;
+            }
     };
 
 

From 8161f3902519486b5c116bb96e31cca8f56279e4 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Wed, 18 Feb 2015 00:23:11 -0500
Subject: [PATCH 0987/1866] uses Func* in starmap iterator

---
 starmap.hpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/starmap.hpp b/starmap.hpp
index 3f8a64e2..15119dc2 100644
--- a/starmap.hpp
+++ b/starmap.hpp
@@ -33,11 +33,11 @@ namespace iter {
                 : public std::iterator<std::input_iterator_tag, StarIterDeref>
             {
                 private:
-                    Func func;
+                    Func *func;
                     iterator_type<Container> sub_iter;
                 public:
                     Iterator(Func& f, iterator_type<Container> iter)
-                        : func(f),
+                        : func(&f),
                         sub_iter(iter)
                     { }
 
@@ -61,7 +61,7 @@ namespace iter {
                     }
 
                     decltype(auto) operator*() {
-                        return call_with_tuple(this->func, *this->sub_iter);
+                        return call_with_tuple(*this->func, *this->sub_iter);
                     }
             };
 

From ec1d73153b09ccd342f9eb5a9bced3d91548f7e0 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Wed, 18 Feb 2015 00:24:14 -0500
Subject: [PATCH 0988/1866] eliminates extra copy of iterator

---
 starmap.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/starmap.hpp b/starmap.hpp
index 15119dc2..3e1ec9fc 100644
--- a/starmap.hpp
+++ b/starmap.hpp
@@ -36,9 +36,9 @@ namespace iter {
                     Func *func;
                     iterator_type<Container> sub_iter;
                 public:
-                    Iterator(Func& f, iterator_type<Container> iter)
+                    Iterator(Func& f, iterator_type<Container>&& iter)
                         : func(&f),
-                        sub_iter(iter)
+                        sub_iter(std::move(iter))
                     { }
 
                     bool operator!=(const Iterator& other) const {

From 7c096f05f4a918eeadbb16d44f99f0a8b64a9599 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Wed, 18 Feb 2015 00:37:52 -0500
Subject: [PATCH 0989/1866] corrects ++ and == in starmap iterators

prefix ++ was returning Iterator instead of Iterator&
---
 starmap.hpp | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/starmap.hpp b/starmap.hpp
index 3e1ec9fc..138dba75 100644
--- a/starmap.hpp
+++ b/starmap.hpp
@@ -49,7 +49,7 @@ namespace iter {
                         return !(*this != other);
                     }
 
-                    Iterator operator++() {
+                    Iterator& operator++() {
                         ++this->sub_iter;
                         return *this;
                     }
@@ -131,14 +131,24 @@ namespace iter {
                         return callers[this->index](this->func, this->tup);
                     }
 
-                    Iterator operator++() {
+                    Iterator& operator++() {
                         ++this->index;
                         return *this;
                     }
 
+                    Iterator operator++(int) {
+                        auto ret = *this;
+                        ++*this;
+                        return ret;
+                    }
+
                     bool operator!=(const Iterator& other) const {
                         return this->index != other.index;
                     }
+
+                    bool operator==(const Iterator& other) const {
+                        return !(*this != other);
+                    }
             };
 
             Iterator begin() {

From 2d6a5aa2991d83bd8bcc56a2a0a35219f75d3aa2 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Wed, 18 Feb 2015 00:40:28 -0500
Subject: [PATCH 0990/1866] explicitly defaults default ctors for DerefHolder

---
 iterbase.hpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/iterbase.hpp b/iterbase.hpp
index 6ab8958a..48c987fd 100644
--- a/iterbase.hpp
+++ b/iterbase.hpp
@@ -198,6 +198,7 @@ namespace iter {
             std::unique_ptr<TPlain> item_p;
 
         public:
+            DerefHolder() = default;
             DerefHolder(const DerefHolder& other)
                 : item_p{other.item_p ? new TPlain(*other.item_p) : nullptr}
             { }
@@ -244,6 +245,7 @@ namespace iter {
 
             typename std::remove_reference<T>::type *item_p =nullptr;
         public:
+            DerefHolder() = default;
             T get() {
                 return *this->item_p;
             }

From 2640ca1b544c3560f94c7e3669bbc5dd81a1fb5e Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Wed, 18 Feb 2015 00:44:37 -0500
Subject: [PATCH 0991/1866] explicitly default default ctor for DerefHolder

---
 iterbase.hpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/iterbase.hpp b/iterbase.hpp
index 58d6ee96..1f962d84 100644
--- a/iterbase.hpp
+++ b/iterbase.hpp
@@ -144,6 +144,8 @@ namespace iter {
             std::unique_ptr<TPlain> item_p;
 
         public:
+            DerefHolder() = default;
+
             DerefHolder(const DerefHolder& other)
                 : item_p{other.item_p ? new TPlain(*other.item_p) : nullptr}
             { }
@@ -190,6 +192,8 @@ namespace iter {
 
             typename std::remove_reference<T>::type *item_p =nullptr;
         public:
+            DerefHolder() = default;
+
             T get() {
                 return *this->item_p;
             }

From 5a11a2c5c5310cf2a75d9bc4ea70dbe6e57c9de4 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Wed, 18 Feb 2015 11:01:22 -0500
Subject: [PATCH 0992/1866] forwards the tuple elements to the called function

---
 iterbase.hpp | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/iterbase.hpp b/iterbase.hpp
index 48c987fd..7a354802 100644
--- a/iterbase.hpp
+++ b/iterbase.hpp
@@ -162,7 +162,10 @@ namespace iter {
         template <typename Func, typename TupleType, std::size_t... Is>
         decltype(auto) call_with_tuple_impl(Func&& mf, TupleType&& tup,
                 std::index_sequence<Is...>) {
-            return mf(std::get<Is>(tup)...);
+            return mf(std::forward<
+                        std::tuple_element_t<
+                            Is, std::remove_reference_t<TupleType>>
+                        >(std::get<Is>(tup))...);
         }
     }
 

From eb990a7c88ed2015dab12b4164ced8c2b4c1a8a4 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Wed, 18 Feb 2015 11:10:58 -0500
Subject: [PATCH 0993/1866] forwards elements in call_with_tuple

---
 imap.hpp | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/imap.hpp b/imap.hpp
index 79a8deae..168cfd99 100644
--- a/imap.hpp
+++ b/imap.hpp
@@ -5,6 +5,7 @@
 
 #include <utility>
 #include <type_traits>
+#include <tuple>
 
 namespace iter {
 
@@ -17,14 +18,21 @@ namespace iter {
             -> decltype(Expander<Index-1, Functor, Tup>::call(
                     std::forward<Functor>(f),
                     std::forward<Tup>(tup),
-                    std::get<Index-1>(tup),
+                    std::forward<
+                        typename std::tuple_element<Index-1,
+                            typename std::remove_reference<Tup>::type>::type>(
+                        std::get<Index-1>(tup)),
                     std::forward<Ts>(args)...))
         {
             // recurse
             return Expander<Index-1, Functor, Tup>::call(
                     std::forward<Functor>(f),
                     std::forward<Tup>(tup),
-                    std::get<Index-1>(tup), // pull out one element
+                    // pull out one element
+                    std::forward<
+                        typename std::tuple_element<Index-1,
+                            typename std::remove_reference<Tup>::type>::type>(
+                        std::get<Index-1>(tup)),
                     std::forward<Ts>(args)...); // everything already expanded
         }
     };

From 3d971c9b5434fdc5ed1cf02f0e97adfbd69185f6 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 21 Feb 2015 15:49:00 -0500
Subject: [PATCH 0994/1866] adds a helper to throw on double deref

auto it = std::begin(ii);
*it; // fine
++it;
*it; // fine
*it; // no ++, throws
---
 catchtest/helpers.hpp | 77 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 77 insertions(+)

diff --git a/catchtest/helpers.hpp b/catchtest/helpers.hpp
index d3dacfa6..7c0c1eaa 100644
--- a/catchtest/helpers.hpp
+++ b/catchtest/helpers.hpp
@@ -2,6 +2,8 @@
 #define TEST_HELPER_H_
 
 #include <stdexcept>
+#include <type_traits>
+#include <utility>
 
 namespace itertest {
 
@@ -25,6 +27,57 @@ class SolidInt {
         SolidInt(SolidInt&&) = delete;
 };
 
+namespace {
+    struct DoubleDereferenceError : std::exception {
+        const char *what() const noexcept override {
+            return "Iterator dereferenced twice without increment";
+        }
+    };
+
+    // this class's iterator will throw if it's dereference twice without
+    // an increment in between
+    class InputIterable {
+        public:
+            class Iterator {
+                private:
+                    int i;
+                    bool was_incremented = true;
+
+                public:
+                    Iterator(int n)
+                        : i{n}
+                    { }
+
+                    Iterator& operator++() {
+                        ++this->i;
+                        this->was_incremented = true;
+                        return *this;
+                    }
+
+                    int operator*() {
+                        if (!this->was_incremented) {
+                            throw DoubleDereferenceError{};
+                        }
+                        this->was_incremented = false;
+                        return this->i;
+                    }
+
+                    bool operator!=(const Iterator& other) const {
+                        return this->i != other.i;
+                    }
+            };
+
+            Iterator begin() {
+                return {0};
+            }
+
+            Iterator end() {
+                return {3};
+            }
+    };
+}
+
+
 
 // BasicIterable provides a minimal forward iterator
 // operator++(), operator!=(const BasicIterable&), operator*()
@@ -117,6 +170,30 @@ class BasicIterable {
         }
 };
 
+
+// gcc CWG 1558
+template <typename...>
+struct void_t_help {
+    using type = void;
+};
+template <typename... Ts>
+
+using void_t = typename void_t_help<Ts...>::type;
+
+template <typename, typename =void>
+struct IsIterator : std::false_type { };
+
+template <typename T>
+struct IsIterator <T, void_t<
+        decltype(T(std::declval<const T&>())), // copyctor
+        decltype(std::declval<T&>() = std::declval<const T&>()), // copy =
+        decltype(*std::declval<T&>()), // operator*
+        decltype(++std::declval<T&>()), // prefix ++
+        decltype(std::declval<T&>()++), // postfix ++
+        decltype(std::declval<const T&>() != std::declval<const T&>()), //  !=
+        decltype(std::declval<const T&>() == std::declval<const T&>()) //  ==
+    >> : std::true_type { };
+
 }
 
 #endif

From 6a62b40f7f1035901f3b822e6de76355c4dcfc46 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 21 Feb 2015 15:50:06 -0500
Subject: [PATCH 0995/1866] tests that groupby doesn't double-dereference

---
 catchtest/test_groupby.cpp | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/catchtest/test_groupby.cpp b/catchtest/test_groupby.cpp
index 6b67f16d..f94c2f98 100644
--- a/catchtest/test_groupby.cpp
+++ b/catchtest/test_groupby.cpp
@@ -152,3 +152,12 @@ TEST_CASE("groupby: inner iterator (group) not used", "[groupby]") {
     std::vector<int> kc = {2, 3, 5};
     REQUIRE( keys == kc );
 }
+
+TEST_CASE("groupby: doesn't double dereference", "[groupby]") {
+    itertest::InputIterable seq;
+    for (auto&& kg : groupby(seq)) {
+        for (auto&& e : kg.second) {
+            (void)e;
+        }
+    }
+}

From 059d9eab1904f386dab561ecab1912c9d076912c Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 21 Feb 2015 15:55:37 -0500
Subject: [PATCH 0996/1866] stretches out inputiterable length

---
 catchtest/helpers.hpp |  2 +-
 groupby.hpp           | 39 ++++++++++++++++++++++++---------------
 2 files changed, 25 insertions(+), 16 deletions(-)

diff --git a/catchtest/helpers.hpp b/catchtest/helpers.hpp
index 7c0c1eaa..29203304 100644
--- a/catchtest/helpers.hpp
+++ b/catchtest/helpers.hpp
@@ -72,7 +72,7 @@ namespace {
             }
 
             Iterator end() {
-                return {3};
+                return {5};
             }
     };
 }
diff --git a/groupby.hpp b/groupby.hpp
index a78cc69a..0e754c15 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -61,23 +61,28 @@ namespace iter {
             {
                 private:
                     iterator_type<Container> sub_iter;
-                    iterator_type<Container> sub_iter_peek;
                     iterator_type<Container> sub_end;
-                    KeyFunc key_func;
+                    DerefHolder<iterator_deref<Container>> item;
+                    KeyFunc *key_func;
 
                 public:
                     Iterator(iterator_type<Container>&& si,
                               iterator_type<Container>&& end,
-                              KeyFunc key_func)
+                              KeyFunc& key_func)
                         : sub_iter{std::move(si)},
                         sub_end{std::move(end)},
-                        key_func(key_func)
-                    { }
+                        key_func(&key_func)
+                    {
+                        if (this->sub_iter != this->sub_end) {
+                            this->item.reset(*this->sub_iter);
+                        }
+                    }
 
                     KeyGroupPair operator*() {
+                        // FIXME double deref
                         return {
-                            this->key_func(*this->sub_iter),
-                            Group{*this, this->key_func(*this->sub_iter)}
+                            (*this->key_func)(this->item.get()),
+                            Group{*this, (*this->key_func)(this->item.get())}
                         };
                     }
 
@@ -102,6 +107,9 @@ namespace iter {
                     void increment_iterator() {
                         if (this->sub_iter != this->sub_end) {
                             ++this->sub_iter;
+                            if (this->sub_iter != this->sub_end) {
+                                this->item.reset(*this->sub_iter);
+                            }
                         }
                     }
 
@@ -109,12 +117,13 @@ namespace iter {
                         return !(this->sub_iter != this->sub_end);
                     }
 
-                    iterator_deref<Container> current() {
-                        return *this->sub_iter;
+                    iterator_deref<Container> pull() {
+                        return this->item.pull();
                     }
 
+                    // FIXME double deref. Two deref holders?
                     key_func_ret next_key() {
-                        return this->key_func(*this->sub_iter);
+                        return (*this->key_func)(this->item.get());
                     }
             };
 
@@ -170,18 +179,18 @@ namespace iter {
                                 iterator_traits_deref<Container>>
                     {
                         private:
-                            key_func_ret key;
+                            typename std::remove_reference<key_func_ret>::type  *key;
                             Group *group_p;
 
                             bool not_at_end() {
                                 return !this->group_p->owner.exhausted()&&
-                                    this->group_p->owner.next_key() == this->key;
+                                    this->group_p->owner.next_key() == *this->key;
                             }
 
                         public:
                             GroupIterator(Group *in_group_p,
-                                          key_func_ret key)
-                                : key{key},
+                                          key_func_ret& key)
+                                : key{&key},
                                 group_p{in_group_p}
                             { }
 
@@ -209,7 +218,7 @@ namespace iter {
                             }
 
                             iterator_deref<Container> operator*() {
-                                return this->group_p->owner.current();
+                                return this->group_p->owner.pull();
                             }
                     };
 

From 7f4f0e1bdd0c8946e2c4457fd2729a3bbb10af96 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 21 Feb 2015 15:55:58 -0500
Subject: [PATCH 0997/1866] makes groups of more that one element

---
 catchtest/test_groupby.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/catchtest/test_groupby.cpp b/catchtest/test_groupby.cpp
index f94c2f98..943f99dc 100644
--- a/catchtest/test_groupby.cpp
+++ b/catchtest/test_groupby.cpp
@@ -155,7 +155,7 @@ TEST_CASE("groupby: inner iterator (group) not used", "[groupby]") {
 
 TEST_CASE("groupby: doesn't double dereference", "[groupby]") {
     itertest::InputIterable seq;
-    for (auto&& kg : groupby(seq)) {
+    for (auto&& kg : groupby(seq, [](int i){return i < 3;})) {
         for (auto&& e : kg.second) {
             (void)e;
         }

From 3ed735ffb04a719f0efd75ed56bf1c4854b20290 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 21 Feb 2015 17:17:09 -0500
Subject: [PATCH 0998/1866] makes product iter assignable

by removing a const data member
---
 product.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/product.hpp b/product.hpp
index 2866406f..44210a51 100644
--- a/product.hpp
+++ b/product.hpp
@@ -47,7 +47,7 @@ namespace iter {
                         typename Productor<RestContainers...>::Iterator;
 
                     iterator_type<Container> iter;
-                    const iterator_type<Container> begin;
+                    iterator_type<Container> begin;
 
                     RestIter rest_iter;
                     RestIter rest_end;

From c319227ec542468cd746d14ee986e113f6cad62b Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 21 Feb 2015 20:11:24 -0500
Subject: [PATCH 0999/1866] tests IsIterator tests

---
 catchtest/test_helpers.cpp | 85 +++++++++++++++++++++++++++++++++-----
 1 file changed, 75 insertions(+), 10 deletions(-)

diff --git a/catchtest/test_helpers.cpp b/catchtest/test_helpers.cpp
index f3c59813..22d0a858 100644
--- a/catchtest/test_helpers.cpp
+++ b/catchtest/test_helpers.cpp
@@ -1,17 +1,82 @@
-#include "helpers.hpp"
 #include <utility>
 
 #include "catch.hpp"
+#include "helpers.hpp"
 
 using itertest::SolidInt;
+using itertest::IsIterator;
+
+namespace {
+
+class ValidIter {
+    private:
+        int i;
+    public:
+        ValidIter& operator++(); // prefix
+        ValidIter operator++(int); // postfix
+        bool operator==(const ValidIter&) const;
+        bool operator!=(const ValidIter&) const;
+        int operator*();
+};
+
+}
+
+TEST_CASE("IsIterator fails when missing prefix ++", "[helpers]") {
+    struct InvalidIter : ValidIter {
+        InvalidIter& operator++() = delete;
+    };
+
+    REQUIRE( !IsIterator<InvalidIter>::value );
+}
+
+TEST_CASE("IsIterator fails when missing postfix ++", "[helpers]") {
+    struct InvalidIter : ValidIter {
+        InvalidIter operator++(int) = delete;
+    };
+
+    REQUIRE( !IsIterator<InvalidIter>::value );
+}
+
+TEST_CASE("IsIterator fails when missing ==", "[helpers]") {
+    struct InvalidIter : ValidIter {
+        bool operator==(const InvalidIter&) const = delete;
+    };
+
+    REQUIRE( !IsIterator<InvalidIter>::value );
+}
+
+TEST_CASE("IsIterator fails when missing !=", "[helpers]") {
+    struct InvalidIter : ValidIter {
+        bool operator!=(const InvalidIter&) const = delete;
+    };
+
+    REQUIRE( !IsIterator<InvalidIter>::value );
+}
+
+TEST_CASE("IsIterator fails when missing *", "[helpers]") {
+    struct InvalidIter : ValidIter {
+        int operator*() = delete;
+    };
+
+    REQUIRE( !IsIterator<InvalidIter>::value );
+}
+
+TEST_CASE("IsIterator fails when missing copy-ctor", "[helpers]") {
+    struct InvalidIter : ValidIter {
+        InvalidIter(const InvalidIter&) = delete;
+    };
+
+    REQUIRE( !IsIterator<InvalidIter>::value );
+}
+
+TEST_CASE("IsIterator fails when missing copy assignment", "[helpers]") {
+    struct InvalidIter : ValidIter {
+        InvalidIter& operator=(const InvalidIter&) = delete;
+    };
+
+    REQUIRE( !IsIterator<InvalidIter>::value );
+}
 
-TEST_CASE("SolidInt can be moved only once", "[helpers]") {
-    SolidInt i{3};
-    SECTION("Doesn't throw on first move") {
-        REQUIRE_NOTHROW( SolidInt{std::move(i)} );
-    }
-    SECTION("Throws on second move") {
-        SolidInt i2{std::move(i)};
-        REQUIRE_THROWS( SolidInt i3{std::move(i2)} );
-    }
+TEST_CASE("IsIterator passes a valid iterator", "[helpers]") {
+    REQUIRE( IsIterator<ValidIter>::value );
 }

From 7bb5eeac946deb3bcf1dec8e5741583dba241af9 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 21 Feb 2015 20:11:40 -0500
Subject: [PATCH 1000/1866] builds heplers tests

---
 catchtest/SConstruct | 1 +
 1 file changed, 1 insertion(+)

diff --git a/catchtest/SConstruct b/catchtest/SConstruct
index 80dc8d25..4bbf3f42 100644
--- a/catchtest/SConstruct
+++ b/catchtest/SConstruct
@@ -46,6 +46,7 @@ progs = Split(
 
     iteratoriterator
     mixed
+    helpers
     '''
 )
 

From 1e51cbbbb1fc175dabae8a148cc78f3f7dbbab06 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 21 Feb 2015 21:06:17 -0500
Subject: [PATCH 1001/1866] makes powerset iter == more correct

compares the combinations sub iterators as well as the set_size
---
 powerset.hpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/powerset.hpp b/powerset.hpp
index 964b0651..dee9bdf2 100644
--- a/powerset.hpp
+++ b/powerset.hpp
@@ -71,7 +71,8 @@ namespace iter {
                     }
 
                     bool operator==(const Iterator& other) const {
-                        return this->set_size == other.set_size;
+                        return this->set_size == other.set_size
+                            && this->comb_iter == other.comb_iter;
                     }
             };
 

From bb7d5162850a15f3ce2ec2811907cef75988b89b Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 21 Feb 2015 21:25:51 -0500
Subject: [PATCH 1002/1866] tests powerset iterator copy ctor

---
 catchtest/test_powerset.cpp | 56 +++++++++++++++++++++++++++----------
 1 file changed, 41 insertions(+), 15 deletions(-)

diff --git a/catchtest/test_powerset.cpp b/catchtest/test_powerset.cpp
index 1b4faeb7..0bf2de99 100644
--- a/catchtest/test_powerset.cpp
+++ b/catchtest/test_powerset.cpp
@@ -32,26 +32,52 @@ TEST_CASE("powerset: empty sequence gives only empty set", "[powerset]") {
 }
 
 TEST_CASE("powerset: iterators can be compared", "[powerset]") {
-    const std::vector<int> ns = {1, 2};
+    std::vector<int> ns = {1, 2};
+    auto p = powerset(ns);
+    {
+        auto it = std::begin(p);
+        REQUIRE( it == std::begin(p) );
+        REQUIRE_FALSE( it != std::begin(p) );
+        REQUIRE( it != std::end(p) );
+        REQUIRE_FALSE( it == std::end(p) );
+        ++it;
+        REQUIRE_FALSE( it == std::begin(p) );
+        REQUIRE( it != std::begin(p) );
+        REQUIRE_FALSE( it == std::end(p) );
+        REQUIRE( it != std::end(p) );
+        ++it;
+        ++it;
+        ++it;
+        REQUIRE( it == std::end(p) );
+    }
+
+    ns.push_back(3);
+    {
+        auto it = std::begin(p);
+        auto it2 = std::begin(p);
+        std::advance(it, 4);
+        std::advance(it2, 4);
+        REQUIRE( it == it2 );
+        ++it2;
+        REQUIRE( it != it2 );
+    }
+
+}
+
+TEST_CASE("powerset: iterator copy ctor is correct", "[powerset]") {
+    // { {}, {1}, {2}, {1, 2} }
+    std::vector<int> ns = {1, 2};
     auto p = powerset(ns);
     auto it = std::begin(p);
-    REQUIRE( it == std::begin(p) );
-    REQUIRE_FALSE( it != std::begin(p) );
-    REQUIRE( it != std::end(p) );
-    REQUIRE_FALSE( it == std::end(p) );
-    ++it;
-    REQUIRE_FALSE( it == std::begin(p) );
-    REQUIRE( it != std::begin(p) );
-    REQUIRE_FALSE( it == std::end(p) );
-    REQUIRE( it != std::end(p) );
-    ++it;
-    ++it;
-    ++it;
-    REQUIRE( it == std::end(p) );
-    REQUIRE_FALSE( it != std::end(p) );
+    auto it2(it);
+    REQUIRE( it == it2 );
+    ++it2;
+    REQUIRE( it != it2 );
+    REQUIRE( std::begin(*it) == std::end(*it) );
 }
 
 
+
 TEST_CASE("powerset: binds to lvalues, moves rvalues", "[powerset]") {
     itertest::BasicIterable<int> bi{1, 2};
     SECTION("binds to lvalues") {

From eca1005614cdf87939674e72845cd2f769b61e6a Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 21 Feb 2015 21:26:17 -0500
Subject: [PATCH 1003/1866] makes powerset iterator copyable

Iterator now holds a shared_ptr, iterators made as copies of it will
shared a combinator.  Each can get a new combinator without affecting
the old one.
---
 powerset.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/powerset.hpp b/powerset.hpp
index dee9bdf2..5635cc4e 100644
--- a/powerset.hpp
+++ b/powerset.hpp
@@ -31,7 +31,7 @@ namespace iter {
                 private:
                     typename std::remove_reference<Container>::type *container_p;
                     std::size_t set_size;
-                    std::unique_ptr<CombinatorType> comb;
+                    std::shared_ptr<CombinatorType> comb;
                     iterator_type<CombinatorType> comb_iter;
                     iterator_type<CombinatorType> comb_end;
 

From f7a82869253fbaf4324a0e83457d604cfbfb4aec Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 23 Feb 2015 08:53:03 -0500
Subject: [PATCH 1004/1866] tests accumulate iterator requirements

---
 catchtest/test_accumulate.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/catchtest/test_accumulate.cpp b/catchtest/test_accumulate.cpp
index 7912d8d5..f8f2d3d7 100644
--- a/catchtest/test_accumulate.cpp
+++ b/catchtest/test_accumulate.cpp
@@ -63,3 +63,9 @@ TEST_CASE("accumulate: postfix ++", "[accumulate]") {
     REQUIRE( *it == 5 );
 }
 
+
+TEST_CASE("accumulate: iterator meets requirements", "[accumulate]") {
+    Vec ns{};
+    auto a = accumulate(ns);
+    REQUIRE( itertest::IsIterator<decltype(std::begin(a))>::value );
+}

From 5e2deb8fc87d03101c16c3d4a34648f09b31b50b Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 23 Feb 2015 08:53:30 -0500
Subject: [PATCH 1005/1866] tests chain iterator requirements

---
 catchtest/test_chain.cpp | 16 +++++++++++++++-
 1 file changed, 15 insertions(+), 1 deletion(-)

diff --git a/catchtest/test_chain.cpp b/catchtest/test_chain.cpp
index 23aa98f4..c2a00fb0 100644
--- a/catchtest/test_chain.cpp
+++ b/catchtest/test_chain.cpp
@@ -143,6 +143,12 @@ TEST_CASE("chain: postfix ++", "[chain]") {
     REQUIRE( *it == 'b');
 }
 
+TEST_CASE("chain: iterator meets requirements", "[chain]") {
+    Vec ns{};
+    auto c = chain(ns, ns);
+    REQUIRE( itertest::IsIterator<decltype(std::begin(c))>::value );
+}
+
 
 TEST_CASE("chain.from_iterable: basic test", "[chain.from_iterable]") {
     std::vector<std::string> sv{"abc", "xyz"};
@@ -194,8 +200,16 @@ TEST_CASE("chain.from_iterable: moves rvalues and binds ref to lvalues",
     }
 }
 
-TEST_CASE("chain.from_iterable: empty", "[empty]") {
+TEST_CASE("chain.from_iterable: empty", "[chain.from_iterable]") {
     const std::vector<std::string> v{};
     auto ch = chain.from_iterable(v);
     REQUIRE( std::begin(ch) == std::end(ch) );
 }
+
+
+TEST_CASE("chain.from_iterable: iterator meets requirements",
+        "[chain.from_iterable]") {
+    const std::vector<std::string> v{};
+    auto c = chain(v);
+    REQUIRE( itertest::IsIterator<decltype(std::begin(c))>::value );
+}

From 879ac8ac092cc91b5e9ab52729371a6fd8cb9355 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 23 Feb 2015 08:53:43 -0500
Subject: [PATCH 1006/1866] tests combinations iterator requirements

---
 catchtest/test_combinations.cpp | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/catchtest/test_combinations.cpp b/catchtest/test_combinations.cpp
index e5c015df..dfdb0d0b 100644
--- a/catchtest/test_combinations.cpp
+++ b/catchtest/test_combinations.cpp
@@ -68,3 +68,11 @@ TEST_CASE("combinations: doesn't move or copy elements of iterable",
         (void)i;
     }
 }
+
+TEST_CASE("combinations: iterator meets requirements", "[combinations]") {
+    std::string s{"abc"};
+    auto c = combinations(s, 1);
+    REQUIRE( itertest::IsIterator<decltype(std::begin(c))>::value );
+    auto&& row = *std::begin(c);
+    REQUIRE( itertest::IsIterator<decltype(std::begin(row))>::value );
+}

From b4b95184270831d399b30b2c6f200d9923315fd0 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 23 Feb 2015 08:54:07 -0500
Subject: [PATCH 1007/1866] tests comb_w_repl iterator requirements

---
 catchtest/test_combinations_with_replacement.cpp | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/catchtest/test_combinations_with_replacement.cpp b/catchtest/test_combinations_with_replacement.cpp
index bfa688f1..c58aec6d 100644
--- a/catchtest/test_combinations_with_replacement.cpp
+++ b/catchtest/test_combinations_with_replacement.cpp
@@ -76,3 +76,12 @@ TEST_CASE("combinations_with_replacement: "
         (void)i;
     }
 }
+
+TEST_CASE("combinations_with_replacement: iterator meets requirements",
+        "[combinations_with_replacement]") {
+    std::string s{"abc"};
+    auto c = combinations_with_replacement(s, 1);
+    REQUIRE( itertest::IsIterator<decltype(std::begin(c))>::value );
+    auto&& row = *std::begin(c);
+    REQUIRE( itertest::IsIterator<decltype(std::begin(row))>::value );
+}

From 0ff84eb82bb6151d39f137ce6a99d1850c1766ab Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 23 Feb 2015 08:58:43 -0500
Subject: [PATCH 1008/1866] tests compress iterator requirements

---
 catchtest/test_compress.cpp | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/catchtest/test_compress.cpp b/catchtest/test_compress.cpp
index 137f69c9..29a7c068 100644
--- a/catchtest/test_compress.cpp
+++ b/catchtest/test_compress.cpp
@@ -120,3 +120,10 @@ TEST_CASE("compress: nothing on empty data", "[compress]") {
     auto c = compress(ivec, bvec);
     REQUIRE( std::begin(c) == std::end(c) );
 }
+
+TEST_CASE("compress: iterator meets requirements", "[compress]") {
+    std::string s{};
+    std::vector<bool> bv;
+    auto c = compress(s, bv);
+    REQUIRE( itertest::IsIterator<decltype(std::begin(c))>::value );
+}

From 67e157e4a6cbaaf38fa86546aefe4cef6f9e94c3 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 23 Feb 2015 09:01:16 -0500
Subject: [PATCH 1009/1866] tests count iterator requirements

---
 catchtest/test_count.cpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/catchtest/test_count.cpp b/catchtest/test_count.cpp
index 05134724..12b1347b 100644
--- a/catchtest/test_count.cpp
+++ b/catchtest/test_count.cpp
@@ -52,3 +52,8 @@ TEST_CASE("count: with step > 1", "[count]") {
     const std::vector<int> vc{10, 12, 14, 16};
     REQUIRE( v == vc );
 }
+
+TEST_CASE("count: iterator meets requirements", "[count]") {
+    auto c = count();
+    REQUIRE( itertest::IsIterator<decltype(std::begin(c))>::value );
+}

From d27194d63b221f62152997d2f3e81f52b033d151 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 23 Feb 2015 09:01:31 -0500
Subject: [PATCH 1010/1866] tests cycle iterator requirements

---
 catchtest/test_cycle.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/catchtest/test_cycle.cpp b/catchtest/test_cycle.cpp
index 7f3d4203..572e73d6 100644
--- a/catchtest/test_cycle.cpp
+++ b/catchtest/test_cycle.cpp
@@ -50,3 +50,9 @@ TEST_CASE("cycle: doesn't move or copy elements of iterable",
     auto c = cycle(arr);
     *std::begin(c);
 }
+
+TEST_CASE("cycle: iterator meets requirements", "[cycle]") {
+    std::string s{};
+    auto c = cycle(s);
+    REQUIRE( itertest::IsIterator<decltype(std::begin(c))>::value );
+}

From 9bd15bea3ccde36c3442adbc7333b2fbdcec738b Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 23 Feb 2015 09:01:45 -0500
Subject: [PATCH 1011/1866] tests dropwhile iterator requirements

---
 catchtest/test_dropwhile.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/catchtest/test_dropwhile.cpp b/catchtest/test_dropwhile.cpp
index 07b6b907..7a4d7dee 100644
--- a/catchtest/test_dropwhile.cpp
+++ b/catchtest/test_dropwhile.cpp
@@ -83,3 +83,9 @@ TEST_CASE("dropwhile: doesn't move or copy elements of iterable",
         (void)i;
     }
 }
+
+TEST_CASE("dropwhile: iterator meets requirements", "[dropwhile]") {
+    std::string s{};
+    auto c = dropwhile([]{return true;}, s);
+    REQUIRE( itertest::IsIterator<decltype(std::begin(c))>::value );
+}

From aaa41f6794b9cb9526ad3c4ca2c08040afc3afc5 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 23 Feb 2015 09:05:13 -0500
Subject: [PATCH 1012/1866] tests enumerate iterator requirements

---
 catchtest/test_enumerate.cpp | 7 +++++++
 catchtest/test_filter.cpp    | 6 ++++++
 2 files changed, 13 insertions(+)

diff --git a/catchtest/test_enumerate.cpp b/catchtest/test_enumerate.cpp
index 6fb747b8..1a899bc2 100644
--- a/catchtest/test_enumerate.cpp
+++ b/catchtest/test_enumerate.cpp
@@ -114,3 +114,10 @@ TEST_CASE("Doesn't move or copy elements of iterable", "[enumerate]") {
         (void)i;
     }
 }
+
+
+TEST_CASE("enumerate: iterator meets requirements", "[enumerate]") {
+    std::string s{};
+    auto c = enumerate(s);
+    REQUIRE( itertest::IsIterator<decltype(std::begin(c))>::value );
+}
diff --git a/catchtest/test_filter.cpp b/catchtest/test_filter.cpp
index 985e38e2..28d597d3 100644
--- a/catchtest/test_filter.cpp
+++ b/catchtest/test_filter.cpp
@@ -109,3 +109,9 @@ TEST_CASE("filter: doesn't move or copy elements of iterable", "[filter]") {
         (void)i;
     }
 }
+
+TEST_CASE("filter: iterator meets requirements", "[filter]") {
+    std::string s{};
+    auto c = filter([]{return true;}, s);
+    REQUIRE( itertest::IsIterator<decltype(std::begin(c))>::value );
+}

From 99742e329801cfb2a284541930b7e4adf501a613 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 23 Feb 2015 09:05:54 -0500
Subject: [PATCH 1013/1866] tests filterfalse iterator requirements

---
 catchtest/test_filterfalse.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/catchtest/test_filterfalse.cpp b/catchtest/test_filterfalse.cpp
index ca6ec915..cb09d897 100644
--- a/catchtest/test_filterfalse.cpp
+++ b/catchtest/test_filterfalse.cpp
@@ -92,3 +92,9 @@ TEST_CASE("filterfalse: all elements pass predicate", "[filterfalse]") {
 
     REQUIRE( std::begin(f) == std::end(f) );
 }
+
+TEST_CASE("filterfalse: iterator meets requirements", "[filterfalse]") {
+    std::string s{};
+    auto c = filterfalse([]{return true;}, s);
+    REQUIRE( itertest::IsIterator<decltype(std::begin(c))>::value );
+}

From 57e001460b9cccc2c5cf6d6e96be8da8ea6da671 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 23 Feb 2015 09:06:09 -0500
Subject: [PATCH 1014/1866] tests groupby iterator requirements

---
 catchtest/test_groupby.cpp | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/catchtest/test_groupby.cpp b/catchtest/test_groupby.cpp
index 943f99dc..06139d7b 100644
--- a/catchtest/test_groupby.cpp
+++ b/catchtest/test_groupby.cpp
@@ -161,3 +161,14 @@ TEST_CASE("groupby: doesn't double dereference", "[groupby]") {
         }
     }
 }
+
+TEST_CASE("groupby: iterator and groupiterator are correct", "[groupby]") {
+    std::string s{"abc"};
+    auto c = groupby(s);
+    auto it = std::begin(c);
+    REQUIRE( itertest::IsIterator<decltype(it)>::value );
+    auto&& gp = (*it).second;
+    auto it2 = std::begin(gp);
+    REQUIRE( itertest::IsIterator<decltype(it2)>::value );
+
+}

From 3125d55722ea3649b8fc56986758961dcccac04d Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 23 Feb 2015 09:07:28 -0500
Subject: [PATCH 1015/1866] tests grouper iterator requirements

---
 catchtest/test_grouper.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/catchtest/test_grouper.cpp b/catchtest/test_grouper.cpp
index 27032464..bc09bc30 100644
--- a/catchtest/test_grouper.cpp
+++ b/catchtest/test_grouper.cpp
@@ -58,3 +58,9 @@ TEST_CASE("grouper: empty iterable gives empty grouper", "[grouper]") {
     auto g = grouper(ns, 1);
     REQUIRE( std::begin(g) == std::end(g) );
 }
+
+TEST_CASE("grouper: iterator meets requirements", "[grouper]") {
+    std::string s{};
+    auto c = grouper(s, 1);
+    REQUIRE( itertest::IsIterator<decltype(std::begin(c))>::value );
+}

From fa1600f121194be2491eb3f570a061f6a86e2276 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 23 Feb 2015 09:07:42 -0500
Subject: [PATCH 1016/1866] tests imap iterator requirements

---
 catchtest/test_imap.cpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/catchtest/test_imap.cpp b/catchtest/test_imap.cpp
index ba9ae171..71a70440 100644
--- a/catchtest/test_imap.cpp
+++ b/catchtest/test_imap.cpp
@@ -121,3 +121,8 @@ TEST_CASE("imap: postfix ++", "[imap]") {
     REQUIRE( it == std::end(im) );
 }
 
+TEST_CASE("imap: iterator meets requirements", "[imap]") {
+    std::string s{};
+    auto c = imap([](char){return 1;}, s);
+    REQUIRE( itertest::IsIterator<decltype(std::begin(c))>::value );
+}

From 6ba0981269993246fce35a29c932739eaf46532e Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 23 Feb 2015 09:07:54 -0500
Subject: [PATCH 1017/1866] tests permutations iterator requirements

---
 catchtest/test_permutations.cpp | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/catchtest/test_permutations.cpp b/catchtest/test_permutations.cpp
index 23eec08f..2e012131 100644
--- a/catchtest/test_permutations.cpp
+++ b/catchtest/test_permutations.cpp
@@ -80,3 +80,11 @@ TEST_CASE("permutations doesn't move or copy elements of iterable",
         (void)st;
     }
 }
+
+TEST_CASE("permutations: iterator meets requirements", "[permutations]") {
+    std::string s{"abc"};
+    auto c = permutations(s);
+    REQUIRE( itertest::IsIterator<decltype(std::begin(c))>::value );
+    auto&& row = *std::begin(c);
+    REQUIRE( itertest::IsIterator<decltype(std::begin(row))>::value );
+}

From c81c36e999da6a1aecab59ee9ab23fe05780c2b6 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 23 Feb 2015 09:08:09 -0500
Subject: [PATCH 1018/1866] tests powrset iterator requirements

---
 catchtest/test_powerset.cpp | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/catchtest/test_powerset.cpp b/catchtest/test_powerset.cpp
index 0bf2de99..7da82744 100644
--- a/catchtest/test_powerset.cpp
+++ b/catchtest/test_powerset.cpp
@@ -98,3 +98,11 @@ TEST_CASE("powerset: doesn't move or copy elements of iterable", "[powerset]"){
         }
     }
 }
+
+TEST_CASE("powerset: iterator meets requirements", "[powerset]") {
+    std::string s{"abc"};
+    auto c = powerset(s);
+    REQUIRE( itertest::IsIterator<decltype(std::begin(c))>::value );
+    auto&& row = *std::begin(c);
+    REQUIRE( itertest::IsIterator<decltype(std::begin(row))>::value );
+}

From 09844b2ea988d7723d8f85e64d2b19ceaad9d746 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 23 Feb 2015 09:08:20 -0500
Subject: [PATCH 1019/1866] tests product iterator requirements

---
 catchtest/test_product.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/catchtest/test_product.cpp b/catchtest/test_product.cpp
index 3e160d0f..fb6ea0cc 100644
--- a/catchtest/test_product.cpp
+++ b/catchtest/test_product.cpp
@@ -113,3 +113,9 @@ TEST_CASE("product: doesn't move or copy elements of iterable", "[product]") {
         (void)std::get<0>(t);
     }
 }
+
+TEST_CASE("product: iterator meets requirements", "[product]") {
+    std::string s{"abc"};
+    auto c = product(s, s);
+    REQUIRE( itertest::IsIterator<decltype(std::begin(c))>::value );
+}

From f9925494812752b13825a5b8262f9cd8124c27c6 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 23 Feb 2015 09:08:37 -0500
Subject: [PATCH 1020/1866] tests range iterator requirements

---
 catchtest/test_range.cpp | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/catchtest/test_range.cpp b/catchtest/test_range.cpp
index fbf50298..d5dc6d29 100644
--- a/catchtest/test_range.cpp
+++ b/catchtest/test_range.cpp
@@ -4,6 +4,7 @@
 #include <iterator>
 #include <algorithm>
 
+#include "helpers.hpp"
 #include "catch.hpp"
 
 using Vec = const std::vector<int>;
@@ -189,4 +190,8 @@ TEST_CASE("range: using doubles detects empty ranges", "[range]") {
     auto r2 = range(0.0, 1.0, -1.0);
     REQUIRE(std::begin(r2) == std::end(r2));
 }
-    
+
+TEST_CASE("range: iterator meets requirements", "[range]") {
+    auto r = range(5);
+    REQUIRE( itertest::IsIterator<decltype(std::begin(r))>::value );
+}

From cf18b40e5a054c8f14b03ba6b0e9769b11131ec3 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 23 Feb 2015 09:14:44 -0500
Subject: [PATCH 1021/1866] tests repeat iterator requirements

---
 catchtest/test_repeat.cpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/catchtest/test_repeat.cpp b/catchtest/test_repeat.cpp
index 0f159d29..59d0256d 100644
--- a/catchtest/test_repeat.cpp
+++ b/catchtest/test_repeat.cpp
@@ -49,3 +49,7 @@ TEST_CASE("repeat: doesn't duplicate item", "[repeat]") {
     (void)*it;
 }
 
+TEST_CASE("repeat: iterator meets requirements", "[repeat]") {
+    auto r = repeat(1);
+    REQUIRE( itertest::IsIterator<decltype(std::begin(r))>::value );
+}

From 63bd48a58a7cd223be08a94484cf0aee00ff85b9 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 23 Feb 2015 09:15:02 -0500
Subject: [PATCH 1022/1866] tests slice iterator requirements

---
 catchtest/test_slice.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/catchtest/test_slice.cpp b/catchtest/test_slice.cpp
index 3d95380e..ea6f5e13 100644
--- a/catchtest/test_slice.cpp
+++ b/catchtest/test_slice.cpp
@@ -101,3 +101,9 @@ TEST_CASE("slice: with iterable doesn't move or copy elems", "[slice]") {
         (void)i;
     }
 }
+
+TEST_CASE("slice: iterator meets requirements", "[slice]") {
+    std::string s{"abcdef"};
+    auto c = slice(s, 1, 3);
+    REQUIRE( itertest::IsIterator<decltype(std::begin(c))>::value );
+}

From 37bcc243abd2fd710d60dcd202beca0692b8ba61 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 23 Feb 2015 09:15:21 -0500
Subject: [PATCH 1023/1866] tests sliding window iterator requirements

---
 catchtest/test_sliding_window.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/catchtest/test_sliding_window.cpp b/catchtest/test_sliding_window.cpp
index 3bcd0878..d413b431 100644
--- a/catchtest/test_sliding_window.cpp
+++ b/catchtest/test_sliding_window.cpp
@@ -99,3 +99,9 @@ TEST_CASE("sliding window: doesn't copy elements", "[sliding_window]") {
         (void)*std::begin(i);
     }
 }
+
+TEST_CASE("sliding_window: iterator meets requirements", "[sliding_window]") {
+    std::string s{"abcdef"};
+    auto c = sliding_window(s, 2);
+    REQUIRE( itertest::IsIterator<decltype(std::begin(c))>::value );
+}

From be3278750048d9bce4220cf2f9ff71533636c34e Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 23 Feb 2015 09:15:52 -0500
Subject: [PATCH 1024/1866] tests takewhile iterator requirements

---
 catchtest/test_takewhile.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/catchtest/test_takewhile.cpp b/catchtest/test_takewhile.cpp
index aae3f481..1d28b4d2 100644
--- a/catchtest/test_takewhile.cpp
+++ b/catchtest/test_takewhile.cpp
@@ -95,3 +95,9 @@ TEST_CASE("takewhile: with iterable doesn't move or copy elements",
         (void)i;
     }
 }
+
+TEST_CASE("takewhile: iterator meets requirements", "[takewhile]") {
+    std::string s{};
+    auto c = takewhile([]{return true;}, s);
+    REQUIRE( itertest::IsIterator<decltype(std::begin(c))>::value );
+}

From 366a9581b247a9ef20897c88c8de07d3090e640b Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 23 Feb 2015 09:16:09 -0500
Subject: [PATCH 1025/1866] tests unique_everseen iterator requirements

---
 catchtest/test_unique_everseen.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/catchtest/test_unique_everseen.cpp b/catchtest/test_unique_everseen.cpp
index 31e712a2..4cd94cd2 100644
--- a/catchtest/test_unique_everseen.cpp
+++ b/catchtest/test_unique_everseen.cpp
@@ -38,3 +38,9 @@ TEST_CASE("unique everseen: moves rvalues, binds to lvalues",
     unique_everseen(std::move(bi));
     REQUIRE( bi.was_moved_from() );
 }
+
+TEST_CASE("unique_everseen: iterator meets requirements", "[unique_everseen]") {
+    std::string s{};
+    auto c = unique_everseen(s);
+    REQUIRE( itertest::IsIterator<decltype(std::begin(c))>::value );
+}

From 308b048d221f9ba8f152751799dcfe6570b2549f Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 23 Feb 2015 09:16:20 -0500
Subject: [PATCH 1026/1866] tests unique_justseen iterator requirements

---
 catchtest/test_unique_justseen.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/catchtest/test_unique_justseen.cpp b/catchtest/test_unique_justseen.cpp
index fcb9067b..4285f364 100644
--- a/catchtest/test_unique_justseen.cpp
+++ b/catchtest/test_unique_justseen.cpp
@@ -44,3 +44,9 @@ TEST_CASE("unique justseen: moves and binds correctly", "[unique_justseen]") {
     unique_justseen(std::move(bi));
     REQUIRE( bi.was_moved_from() );
 }
+
+TEST_CASE("unique_justseen: iterator meets requirements", "[unique_justseen]") {
+    std::string s{};
+    auto c = unique_justseen(s);
+    REQUIRE( itertest::IsIterator<decltype(std::begin(c))>::value );
+}

From 67f1b89f0c2e14842902b299da50fa052863d9b7 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 23 Feb 2015 09:16:34 -0500
Subject: [PATCH 1027/1866] tests zip iterator requirements

---
 catchtest/test_zip.cpp | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/catchtest/test_zip.cpp b/catchtest/test_zip.cpp
index 106c9444..f099c8eb 100644
--- a/catchtest/test_zip.cpp
+++ b/catchtest/test_zip.cpp
@@ -99,3 +99,11 @@ TEST_CASE("zip: postfix ++", "[zip]") {
     it++;
     REQUIRE( it == std::end(z) );
 }
+
+TEST_CASE("zip: iterator meets requirements", "[zip]") {
+    std::string s{};
+    auto c = zip(s);
+    REQUIRE( itertest::IsIterator<decltype(std::begin(c))>::value );
+    auto c2 = zip(s, s);
+    REQUIRE( itertest::IsIterator<decltype(std::begin(c2))>::value );
+}

From e5383ac9adad59c6dd08f48cdf9d0e4e70ce5ff5 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 23 Feb 2015 09:16:44 -0500
Subject: [PATCH 1028/1866] tests zip_longest iterator requirements

---
 catchtest/test_zip_longest.cpp | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/catchtest/test_zip_longest.cpp b/catchtest/test_zip_longest.cpp
index 1e12a68a..6fe8cf5a 100644
--- a/catchtest/test_zip_longest.cpp
+++ b/catchtest/test_zip_longest.cpp
@@ -141,3 +141,11 @@ TEST_CASE("zip_longest: doesn't move or copy elements", "[zip_longest]") {
         (void)std::get<0>(t);
     }
 }
+
+TEST_CASE("zip_longest: iterator meets requirements", "[zip_longest]") {
+    std::string s{};
+    auto c = zip_longest(s);
+    REQUIRE( itertest::IsIterator<decltype(std::begin(c))>::value );
+    auto c2 = zip_longest(s, s);
+    REQUIRE( itertest::IsIterator<decltype(std::begin(c2))>::value );
+}

From a755f8b906372b9557d369481802635120ea5fe4 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 23 Feb 2015 10:35:16 -0500
Subject: [PATCH 1029/1866] tests normal starmap iterator requirements

---
 catchtest/test_starmap.cpp | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/catchtest/test_starmap.cpp b/catchtest/test_starmap.cpp
index ce8d40c6..b26de6c5 100644
--- a/catchtest/test_starmap.cpp
+++ b/catchtest/test_starmap.cpp
@@ -95,3 +95,10 @@ TEST_CASE("starmap: moves rvalues, binds to lvalues", "[starmap]") {
     starmap(Callable{}, std::move(bi));
     REQUIRE( bi.was_moved_from() );
 }
+
+TEST_CASE("starmap: iterator meets requirements", "[starmap]") {
+    std::string s{};
+    const std::vector<std::pair<double, int>> v1;
+    auto sm = starmap([](long a, int b) { return a * b; }, v1);
+    REQUIRE( itertest::IsIterator<decltype(std::begin(sm))>::value );
+}

From 57ef52338ca340ace4b778ebf45347e3a865b4cc Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 23 Feb 2015 10:41:54 -0500
Subject: [PATCH 1030/1866] tests TupleStarMapper's iterator requirements

---
 catchtest/test_starmap.cpp | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/catchtest/test_starmap.cpp b/catchtest/test_starmap.cpp
index b26de6c5..994f96b7 100644
--- a/catchtest/test_starmap.cpp
+++ b/catchtest/test_starmap.cpp
@@ -102,3 +102,10 @@ TEST_CASE("starmap: iterator meets requirements", "[starmap]") {
     auto sm = starmap([](long a, int b) { return a * b; }, v1);
     REQUIRE( itertest::IsIterator<decltype(std::begin(sm))>::value );
 }
+
+TEST_CASE("starmap:  tuple of tuples iterator meets requirements",
+        "[starmap]") {
+    auto tup = std::make_tuple(std::make_tuple(10, 19, 60),std::make_tuple(7));
+    auto sm = starmap(Callable{}, tup);
+    REQUIRE( itertest::IsIterator<decltype(std::begin(sm))>::value );
+}

From 8f284acb26acbe0b4747b9ceffea80b9b93e1933 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 23 Feb 2015 11:20:24 -0500
Subject: [PATCH 1031/1866] replaces references with pointers in starmap iter

to make the iterator assignable
---
 starmap.hpp | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/starmap.hpp b/starmap.hpp
index 138dba75..978fab23 100644
--- a/starmap.hpp
+++ b/starmap.hpp
@@ -116,19 +116,19 @@ namespace iter {
                 : public std::iterator<std::input_iterator_tag, TraitsValue> 
             {
                 private:
-                    Func& func;
-                    TupType& tup;
+                    Func *func;
+                    std::remove_reference_t<TupType> *tup;
                     std::size_t index;
 
                 public:
                     Iterator(Func& f, TupType& t, std::size_t i)
-                        : func{f},
-                        tup{t},
+                        : func{&f},
+                        tup{&t},
                         index{i}
                     { }
 
                     decltype(auto) operator*() {
-                        return callers[this->index](this->func, this->tup);
+                        return callers[this->index](*this->func, *this->tup);
                     }
 
                     Iterator& operator++() {

From 46c5c68c9cd670d2ded40ffa495bd7e7009c6601 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 23 Feb 2015 11:24:20 -0500
Subject: [PATCH 1032/1866] uses c++14 aliases

---
 groupby.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/groupby.hpp b/groupby.hpp
index a50730bc..b81e1eeb 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -179,7 +179,7 @@ namespace iter {
                                 iterator_traits_deref<Container>>
                     {
                         private:
-                            typename std::remove_reference<key_func_ret>::type  *key;
+                            std::remove_reference_t<key_func_ret> *key;
                             Group *group_p;
 
                             bool not_at_end() {

From 203e881080143f35b0fae9ebf3289066ad3a81ee Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 23 Feb 2015 11:24:36 -0500
Subject: [PATCH 1033/1866] uses c++14 aliases

---
 iterbase.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/iterbase.hpp b/iterbase.hpp
index 42efd0b7..ce97260d 100644
--- a/iterbase.hpp
+++ b/iterbase.hpp
@@ -196,7 +196,7 @@ namespace iter {
             static_assert(!std::is_lvalue_reference<T>::value,
                     "Non-lvalue-ref specialization used for lvalue ref type");
             // it could still be an rvalue reference
-            using TPlain = typename std::remove_reference<T>::type;
+            using TPlain = std::remove_reference_t<T>;
 
             std::unique_ptr<TPlain> item_p;
 
@@ -247,7 +247,7 @@ namespace iter {
             static_assert(std::is_lvalue_reference<T>::value,
                     "lvalue specialization handling non-lvalue-ref type");
 
-            typename std::remove_reference<T>::type *item_p =nullptr;
+            std::remove_reference_t<T> *item_p =nullptr;
         public:
             DerefHolder() = default;
 

From 84d478c73bb445fe7f9dc289c377cbcafcab2f49 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 23 Feb 2015 11:28:20 -0500
Subject: [PATCH 1034/1866] uses universal refs in readme examples

---
 README.md | 64 +++++++++++++++++++++++++++----------------------------
 1 file changed, 32 insertions(+), 32 deletions(-)

diff --git a/README.md b/README.md
index 7d44c246..dcaaf0e2 100644
--- a/README.md
+++ b/README.md
@@ -88,7 +88,7 @@ appears as:
 
 ```c++
 vector<int> vec{2, 4, 6, 8};
-for (auto e : enumerate(vec)) { 
+for (auto&& e : enumerate(vec)) { 
     cout << e.index
          << ": "
          << e.element
@@ -104,7 +104,7 @@ Called as `filter(predicate, iterable)`.  The predicate can be any callable.
 Prints values greater than 4:  `5 6 7 8`
 ```c++
 vector<int> vec{1, 5, 4, 0, 6, 7, 3, 0, 2, 8, 3, 2, 1};
-for (auto i : filter([] (int i) { return i > 4; }, vec)) {
+for (auto&& i : filter([] (int i) { return i > 4; }, vec)) {
     cout << i <<'\n';
 }
 
@@ -114,7 +114,7 @@ If no predicate is passed, the elements themselves are tested for truth
 
 Prints only non-zero values.
 ```c++
-for(auto i : filter(vec)) {
+for(auto&& i : filter(vec)) {
     cout << i << '\n';
 }
 ```
@@ -126,7 +126,7 @@ Similar to filter, but only prints values that are false under the predicate.
 Prints values not greater than 4: `1 4 3 2 3 2 1 `
 ```c++
 vector<int> vec{1, 5, 4, 0, 6, 7, 3, 0, 2, 8, 3, 2, 1};
-for (auto i : filterfalse([] (int i) { return i > 4; }, vec)) {
+for (auto&& i : filterfalse([] (int i) { return i > 4; }, vec)) {
     cout << i <<'\n';
 }
 
@@ -136,7 +136,7 @@ If no predicate is passed, the elements themselves are tested for truth.
 
 Prints only zero values.
 ```c++
-for(auto i : filterfalse(vec)) {
+for(auto&& i : filterfalse(vec)) {
     cout << i << '\n';
 }
 ```
@@ -149,7 +149,7 @@ otherwise it will not be very efficient
 Example Usage:
 ```c++
 std::vector<int> v {1,2,3,4,3,2,1,5,6,7,7,8,9,8,9,6};                      
-for (auto i : unique_everseen(v)) {                                        
+for (auto&& i : unique_everseen(v)) {                                        
     std::cout << i << " ";                                                 
 }std::cout << std::endl; 
 ```
@@ -163,7 +163,7 @@ case it will be better and more efficient to use.
 Example Usage:
 ```c++
 std::vector<int> v {1,1,1,2,2,4,4,5,6,7,8,8,8,8,9,9};                          
-for (auto i : unique_justseen(v)) {                                            
+for (auto&& i : unique_justseen(v)) {                                            
     std::cout << i << " ";                                                     
 }std::cout << std::endl; 
 ```
@@ -176,7 +176,7 @@ the predicate is encountered.
 Prints `1 2 3 4`.  (5 is false under the predicate)
 ```c++
 vector<int> ivec{1, 2, 3, 4, 5, 6, 7, 6, 5, 4, 3, 2, 1};
-for (auto i : takewhile([] (int i) {return i < 5;}, ivec)) {
+for (auto&& i : takewhile([] (int i) {return i < 5;}, ivec)) {
     cout << i << '\n';
 }
 ```
@@ -189,7 +189,7 @@ the predicate.
 Prints `5 6 7 1 2`
 ```c++
 vector<int> ivec{1, 2, 3, 4, 5, 6, 7, 1, 2};
-for (auto i : dropwhile([] (int i) {return i < 5;}, ivec)) {
+for (auto&& i : dropwhile([] (int i) {return i < 5;}, ivec)) {
     cout << i << '\n';
 }
 ```
@@ -203,7 +203,7 @@ Repeatedly produce all values of an iterable.  The loop will be infinite, so a
 Prints `1 2 3` repeatedly until `some_condition` is true
 ```c++
 vector<int> vec{1, 2, 3};
-for (auto i : cycle(vec)) {
+for (auto&& i : cycle(vec)) {
     cout << i << '\n';
     if (some_condition) {
         break;
@@ -222,7 +222,7 @@ vector<string> vec = {
     "abcde", "efghi"
 };
 
-for (auto gb : groupby(vec, [] (const string &s) {return s.length(); })) {
+for (auto&& gb : groupby(vec, [] (const string &s) {return s.length(); })) {
     cout << "key: " << gb.first << '\n';
     cout << "content: ";
     for (auto s : gb.second) {
@@ -242,7 +242,7 @@ Differs from `std::accumulate` (which in my humble opinion should be named
 can see all of the intermediate results.  By default, it keeps a running sum.
 Prints: `1 3 6 10 15`
 ```c++
-for (auto i : accumulate(range(1, 6))) {
+for (auto&& i : accumulate(range(1, 6))) {
     cout << i << '\n';
 }
 ```
@@ -252,7 +252,7 @@ than adding them.
 Prints: `1 2 6 24 120`
 
 ```c++
-for (auto i : accumulate(range(1, 6), std::multiplies<int>{})) {
+for (auto&& i : accumulate(range(1, 6), std::multiplies<int>{})) {
     cout << i << '\n';
 }
 ```
@@ -275,7 +275,7 @@ vector<float> f{1.2,1.4,12.3,4.5,9.9};
 vector<string> s{"i","like","apples","alot","dude"};             
 array<double,5> d{{1.2,1.2,1.2,1.2,1.2}};                             
 
-for (auto e : zip(i,f,s,d)) {                                        
+for (auto&& e : zip(i,f,s,d)) {                                        
     cout << std::get<0>(e) << ' '                                
          << std::get<1>(e) << ' '                                      
          << std::get<2>(e) << ' '                                      
@@ -302,7 +302,7 @@ sequence.
 Prints the squares of the numbers in vec: `1 4 9 16 25`
 ```c++
 vector<int> vec{1, 2, 3, 4, 5};
-for (auto i : imap([] (int x) {return x * x;}, vec)) {
+for (auto&& i : imap([] (int x) {return x * x;}, vec)) {
     cout << i << '\n';
 }
 ```
@@ -312,7 +312,7 @@ each vector together, printing `11 23 35 47 59 71`
 ```c++
 vector<int> vec1{1, 3, 5, 7, 9, 11};
 vector<int> vec2{10, 20, 30, 40, 50, 60};
-for (auto i : imap([] (int x, int y) { return x + y; }, vec1, vec2)) {
+for (auto&& i : imap([] (int x, int y) { return x + y; }, vec1, vec2)) {
     cout << i << '\n';
 }
 ```
@@ -332,7 +332,7 @@ Prints `2 6`
 ```c++
 vector<int> ivec{1, 2, 3, 4, 5, 6};
 vector<bool> bvec{false, true, false, false, false, true};
-for (auto i : compress(ivec, bvec) {
+for (auto&& i : compress(ivec, bvec) {
     cout << i << '\n';
 }
 ```
@@ -348,7 +348,7 @@ vector<int> empty{};
 vector<int> vec1{1,2,3,4,5,6};                                       
 array<int,4> arr1{{7,8,9,10}};                                       
 
-for (auto i : chain(empty,vec1,arr1)) {                             
+for (auto&& i : chain(empty,vec1,arr1)) {                             
     cout << i << '\n';                                          
 }
 ```
@@ -367,7 +367,7 @@ vector<vector<int>> matrix = {
     {6, 8, 9, 10, 11, 12}
 };
 
-for (auto i : chain.from_iterable(matrix)) {
+for (auto&& i : chain.from_iterable(matrix)) {
     cout << i << '\n';
 }
 ```
@@ -378,7 +378,7 @@ reversed
 Iterates over elements of a sequence in reverse order.
 
 ```c++
-for (auto i : reversed(a)) {                                          
+for (auto&& i : reversed(a)) {                                          
     cout << i << '\n';                                           
 }
 ```
@@ -392,7 +392,7 @@ the range returned is [start,stop) where you only take every step element
 This outputs `0 3 6 9 12`
 ```c++
 vector<int> a{0,1,2,3,4,5,6,7,8,9,10,11,12,13};
-for (auto i : slice(a,0,15,3)) {
+for (auto&& i : slice(a,0,15,3)) {
     cout << i << '\n';
 }
 ```
@@ -418,8 +418,8 @@ take a section of size 4, output is:
 Example Usage:
 ```c++
 std::vector<int> v = {1,2,3,4,5,6,7,8,9};                                      
-for (auto sec : sliding_window(v,4)) {                                         
-    for (auto i : sec) {                                                       
+for (auto&& sec : sliding_window(v,4)) {                                         
+    for (auto&& i : sec) {                                                       
         std::cout << i << " ";                                                 
         i.get() = 90; 
         //has to be accessed with get if you want to store references
@@ -438,11 +438,11 @@ section sliding by only 1 it goes the length of the full section.
 Example usage:
 ```c++
 std::vector<int> v {1,2,3,4,5,6,7,8,9};                                        
-for (auto sec : grouper(v,4)) 
+for (auto&& sec : grouper(v,4)) 
 //each section will have 4 elements
 //except the last one may be cut short
 {
-    for (auto i : sec) {                                                       
+    for (auto&& i : sec) {                                                       
         std::cout << i << " ";                                                 
         i.get() *= 2;                                                          
     }                                                                          
@@ -461,7 +461,7 @@ std::vector<int> v1{1,2,3};
 std::vector<int> v2{7,8};                                                      
 std::vector<std::string> v3{"the","cat"};                                      
 std::vector<std::string> v4{"hi","what","up","dude"}; 
-for (auto t : product(v1,v2,v3,v4)) {                                          
+for (auto&& t : product(v1,v2,v3,v4)) {                                          
     std::cout << std::get<0>(t) << ", "                                        
         << std::get<1>(t) << ", "                                              
         << std::get<2>(t) << ", "                                              
@@ -478,9 +478,9 @@ combinations_with_replacement
 Example usage:
 ```c++
 std::vector<int> v = {1,2,3,4,5};                                              
-for (auto i : combinations(v,3)) {                                             
+for (auto&& i : combinations(v,3)) {                                             
     //std::cout << i << std::endl;                                             
-    for (auto j : i ) std::cout << j << " ";                                   
+    for (auto&& j : i ) std::cout << j << " ";                                   
     std::cout<<std::endl;                                                      
 }
 ```
@@ -494,8 +494,8 @@ Generates all the permutations of a range using `std::next_permutation`
 Example usage:
 ```c++
 std::vector<int> v = {1,2,3,4,5};                                              
-for (auto vec : permutations(v)) {                                             
-    for (auto i : vec) {                                                       
+for (auto&& vec : permutations(v)) {                                             
+    for (auto&& i : vec) {                                                       
         std::cout << i << " ";                                                 
     }                                                                       
     std::cout << std::endl;                                                 
@@ -510,8 +510,8 @@ Generates every possible subset of a set, never run it since it runs in �(2^n
 Example usage:
 ```c++
 std::vector<int> vec {1,2,3,4,5,6,7,8,9};                                      
-for (auto v : powerset(vec)) {                                                 
-    for (auto i : v) std::cout << i << " ";                                    
+for (auto&& v : powerset(vec)) {                                                 
+    for (auto&& i : v) std::cout << i << " ";                                    
     std::cout << std::endl;                                                    
 }
 ```

From 09c8c7f964f2b624c07b091dcc7dd7050ed462d7 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 23 Feb 2015 11:29:28 -0500
Subject: [PATCH 1035/1866] adds missing && in groupby example

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index dcaaf0e2..7d6b8668 100644
--- a/README.md
+++ b/README.md
@@ -225,7 +225,7 @@ vector<string> vec = {
 for (auto&& gb : groupby(vec, [] (const string &s) {return s.length(); })) {
     cout << "key: " << gb.first << '\n';
     cout << "content: ";
-    for (auto s : gb.second) {
+    for (auto&& s : gb.second) {
         cout << s << "  ";
     }
     cout << '\n';

From 429101fe7a39964cf7dc7e691be620229829facf Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 2 Apr 2015 17:06:14 -0400
Subject: [PATCH 1036/1866] eliminates shadowing in accumulate

---
 accumulate.hpp | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/accumulate.hpp b/accumulate.hpp
index 06f22168..e0dbb137 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -46,9 +46,10 @@ namespace iter {
                     std::is_default_constructible<AccumVal>::value,
                     "Cannot accumulate a non-default constructible type");
 
-            Accumulator(Container&& container, AccumulateFunc accumulate_func)
-                : container(std::forward<Container>(container)),
-                accumulate_func(accumulate_func)
+            Accumulator(Container&& in_container,
+                    AccumulateFunc in_accumulate_func)
+                : container(std::forward<Container>(in_container)),
+                accumulate_func(in_accumulate_func)
             { }
         public:
 
@@ -63,10 +64,10 @@ namespace iter {
                 public:
                     Iterator (iterator_type<Container>&& iter,
                             iterator_type<Container>&& end,
-                            AccumulateFunc accumulate_func)
+                            AccumulateFunc in_accumulate_func)
                         : sub_iter{std::move(iter)},
                         sub_end{std::move(end)},
-                        accumulate_func(accumulate_func),
+                        accumulate_func(in_accumulate_func),
                         // only get first value if not an end iterator
                         acc_val(!(iter != end) ? AccumVal{} : *iter)
                     { } 

From 367734f41af14b2c31f7fd320aa6a42132bd7bc0 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 2 Apr 2015 17:10:07 -0400
Subject: [PATCH 1037/1866] eliminates shadow warnings from chain

---
 chain.hpp | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/chain.hpp b/chain.hpp
index a05a39da..65e15a36 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -30,8 +30,8 @@ namespace iter {
         private:
             Container container;
             Chained<RestContainers...> rest_chained;
-            Chained(Container&& container, RestContainers&&... rest)
-                : container(std::forward<Container>(container)),
+            Chained(Container&& in_container, RestContainers&&... rest)
+                : container(std::forward<Container>(in_container)),
                 rest_chained{std::forward<RestContainers>(rest)...}
             { }
 
@@ -52,10 +52,10 @@ namespace iter {
                 public:
                     Iterator(iterator_type<Container>&& s_begin,
                             iterator_type<Container>&& s_end,
-                            RestIter&& rest_iter)
+                            RestIter&& in_rest_iter)
                         : sub_iter{std::move(s_begin)},
                         sub_end{std::move(s_end)},
-                        rest_iter{std::move(rest_iter)},
+                        rest_iter{std::move(in_rest_iter)},
                         at_end{!(sub_iter != sub_end)}
                     { }
                     
@@ -112,8 +112,8 @@ namespace iter {
 
         private:
             Container container;
-            Chained(Container&& container)
-                : container(std::forward<Container>(container))
+            Chained(Container&& in_container)
+                : container(std::forward<Container>(in_container))
             { }
 
         public:
@@ -173,8 +173,8 @@ namespace iter {
         private:
             Container container;
             friend class ChainMaker;
-            ChainedFromIterable(Container&& container)
-                : container(std::forward<Container>(container))
+            ChainedFromIterable(Container&& in_container)
+                : container(std::forward<Container>(in_container))
             { }
 
         public:

From 67a87efddc346aca8c47926faf785c992892df63 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 2 Apr 2015 17:11:12 -0400
Subject: [PATCH 1038/1866] eliminates shadow warnings from zip

---
 zip.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/zip.hpp b/zip.hpp
index 285146a8..ca3ed78b 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -31,8 +31,8 @@ namespace iter {
         private:
             Container container;
             Zipped<RestContainers...> rest_zipped;
-            Zipped(Container&& container, RestContainers&&... rest)
-                : container(std::forward<Container>(container)),
+            Zipped(Container&& in_container, RestContainers&&... rest)
+                : container(std::forward<Container>(in_container)),
                 rest_zipped{std::forward<RestContainers>(rest)...}
             { }
 

From 7d8667497a45a4cbc359873b2953fdeb2adf3e21 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 2 Apr 2015 17:12:56 -0400
Subject: [PATCH 1039/1866] eliminates shadow warnings from comb_w_repl

---
 combinations_with_replacement.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/combinations_with_replacement.hpp b/combinations_with_replacement.hpp
index bfb8a9b1..900e563e 100644
--- a/combinations_with_replacement.hpp
+++ b/combinations_with_replacement.hpp
@@ -37,8 +37,8 @@ namespace iter {
             combinations_with_replacement(
                     std::initializer_list<T>, std::size_t);
 
-           CombinatorWithReplacement(Container&& container, std::size_t n)
-               : container(std::forward<Container>(container)),
+           CombinatorWithReplacement(Container&& in_container, std::size_t n)
+               : container(std::forward<Container>(in_container)),
                length{n}
            { }
 

From c895551c4b39bacfa1bc2186535a2d04376b7fd7 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 2 Apr 2015 17:14:53 -0400
Subject: [PATCH 1040/1866] eliminates shadow warnings from compress

---
 compress.hpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/compress.hpp b/compress.hpp
index 29318fe3..404f3047 100644
--- a/compress.hpp
+++ b/compress.hpp
@@ -57,9 +57,9 @@ namespace iter {
             using selector_iter_type = decltype(std::begin(selectors));
             
             // Value constructor for use only in the compress function
-            Compressed(Container&& container, Selector&& selectors)
-                : container(std::forward<Container>(container)),
-                selectors(std::forward<Selector>(selectors))
+            Compressed(Container&& in_container, Selector&& in_selectors)
+                : container(std::forward<Container>(in_container)),
+                selectors(std::forward<Selector>(in_selectors))
             { }
 
         public:

From 237c5cd6b6addee344db3293d198f68454b0bc82 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 2 Apr 2015 17:16:21 -0400
Subject: [PATCH 1041/1866] eliminates shadow warnings from cycle

---
 cycle.hpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/cycle.hpp b/cycle.hpp
index d63403ba..5745340b 100644
--- a/cycle.hpp
+++ b/cycle.hpp
@@ -28,8 +28,8 @@ namespace iter {
 
             Container container;
             
-            Cycle(Container&& container)
-                : container(std::forward<Container>(container))
+            Cycle(Container&& in_container)
+                : container(std::forward<Container>(in_container))
             { }
 
         public:
@@ -44,10 +44,10 @@ namespace iter {
                     iterator_type<Container> end;
                 public:
                     Iterator (const iterator_type<Container>& iter,
-                            iterator_type<Container>&& end)
+                            iterator_type<Container>&& in_end)
                         : sub_iter{iter},
                         begin{iter},
-                        end{std::move(end)}
+                        end{std::move(in_end)}
                     { } 
 
                     iterator_deref<Container> operator*() {

From 2558be9cb15c9d60004c766af2f67b9890431b7f Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 2 Apr 2015 17:17:22 -0400
Subject: [PATCH 1042/1866] replaces <> with "" for include of iterbase

---
 dropwhile.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dropwhile.hpp b/dropwhile.hpp
index a89e5a81..bb156ed4 100644
--- a/dropwhile.hpp
+++ b/dropwhile.hpp
@@ -1,7 +1,7 @@
 #ifndef ITER_DROPWHILE_H_
 #define ITER_DROPWHILE_H_
 
-#include <iterbase.hpp>
+#include "iterbase.hpp"
 
 #include <utility>
 #include <iterator>

From 4a3e7e3ee9d50d99f3c77d7397ceec36c4d4e849 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 2 Apr 2015 17:18:20 -0400
Subject: [PATCH 1043/1866] eliminates shadow warnings from dropwhile

---
 dropwhile.hpp | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/dropwhile.hpp b/dropwhile.hpp
index bb156ed4..d5c9947f 100644
--- a/dropwhile.hpp
+++ b/dropwhile.hpp
@@ -32,9 +32,9 @@ namespace iter {
             friend DropWhile<FF, std::initializer_list<T>> dropwhile(
                     FF, std::initializer_list<T>);
             
-            DropWhile(FilterFunc filter_func, Container&& container)
-                : container(std::forward<Container>(container)),
-                filter_func(filter_func)
+            DropWhile(FilterFunc in_filter_func, Container&& in_container)
+                : container(std::forward<Container>(in_container)),
+                filter_func(in_filter_func)
             { }
 
         public:
@@ -66,10 +66,10 @@ namespace iter {
                 public:
                     Iterator(iterator_type<Container>&& iter,
                             iterator_type<Container>&& end,
-                            FilterFunc& filter_func)
+                            FilterFunc& in_filter_func)
                         : sub_iter{std::move(iter)},
                         sub_end{std::move(end)},
-                        filter_func(&filter_func)
+                        filter_func(&in_filter_func)
                     { 
                         if (this->sub_iter != this->sub_end) {
                             this->item.reset(*this->sub_iter);

From 5c0eb12263be9bdf47c38e51084541150487b525 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 2 Apr 2015 17:19:34 -0400
Subject: [PATCH 1044/1866] eliminates shadow warnings from enumerate

---
 enumerate.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index c9b7ee76..2775232a 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -47,8 +47,8 @@ namespace iter {
             using BasePair = std::pair<std::size_t, iterator_deref<Container>>;
 
             // Value constructor for use only in the enumerate function
-            Enumerable(Container&& container)
-                : container(std::forward<Container>(container))
+            Enumerable(Container&& in_container)
+                : container(std::forward<Container>(in_container))
             { }
             
         public:

From 5ae6b83b33a9f2a8e4429e61e81fc17aa7cf6d9f Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 2 Apr 2015 17:20:58 -0400
Subject: [PATCH 1045/1866] eliminates shadow warnings from filter

---
 filter.hpp | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/filter.hpp b/filter.hpp
index b9136874..60a1be0d 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -35,9 +35,9 @@ namespace iter {
                     FF, std::initializer_list<T>);
             
             // Value constructor for use only in the filter function
-            Filter(FilterFunc filter_func, Container&& container)
-                : container(std::forward<Container>(container)),
-                filter_func(filter_func)
+            Filter(FilterFunc in_filter_func, Container&& in_container)
+                : container(std::forward<Container>(in_container)),
+                filter_func(in_filter_func)
             { }
 
         public:
@@ -71,10 +71,10 @@ namespace iter {
                 public:
                     Iterator (iterator_type<Container> iter,
                             iterator_type<Container> end,
-                            FilterFunc& filter_func)
+                            FilterFunc& in_filter_func)
                         : sub_iter{iter},
                         sub_end{end},
-                        filter_func(&filter_func)
+                        filter_func(&in_filter_func)
                     { 
                         if (this->sub_iter != this->sub_end) {
                             this->item.reset(*this->sub_iter);

From 116e944b7d66cb009692e59f3abe665c3239fefd Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 2 Apr 2015 17:22:23 -0400
Subject: [PATCH 1046/1866] eliminates shadow warnings from filterfalse

---
 filterfalse.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/filterfalse.hpp b/filterfalse.hpp
index 3bad5fa0..247fa84b 100644
--- a/filterfalse.hpp
+++ b/filterfalse.hpp
@@ -18,8 +18,8 @@ namespace iter {
                 FilterFunc filter_func;
 
             public:
-                PredicateFlipper(FilterFunc filter_func) :
-                    filter_func(filter_func)
+                PredicateFlipper(FilterFunc in_filter_func) :
+                    filter_func(in_filter_func)
                 { }
 
                 PredicateFlipper() = delete;

From f6d5a069215bd87dfce01de115f38a1634f23e0b Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 2 Apr 2015 17:23:58 -0400
Subject: [PATCH 1047/1866] eliminates shadow warnings from groupby

---
 groupby.hpp | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/groupby.hpp b/groupby.hpp
index 0e754c15..488c93f3 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -35,9 +35,9 @@ namespace iter {
             using key_func_ret = typename
                 std::result_of<KeyFunc(iterator_deref<Container>)>::type;
 
-            GroupBy(Container&& container, KeyFunc key_func)
-                : container(std::forward<Container>(container)),
-                key_func(key_func)
+            GroupBy(Container&& in_container, KeyFunc in_key_func)
+                : container(std::forward<Container>(in_container)),
+                key_func(in_key_func)
             { }
 
         public:
@@ -68,10 +68,10 @@ namespace iter {
                 public:
                     Iterator(iterator_type<Container>&& si,
                               iterator_type<Container>&& end,
-                              KeyFunc& key_func)
+                              KeyFunc& in_key_func)
                         : sub_iter{std::move(si)},
                         sub_end{std::move(end)},
-                        key_func(&key_func)
+                        key_func(&in_key_func)
                     {
                         if (this->sub_iter != this->sub_end) {
                             this->item.reset(*this->sub_iter);
@@ -146,9 +146,9 @@ namespace iter {
                     // when called.
                     bool completed = false;
 
-                    Group(Iterator& owner, key_func_ret key) :
-                        owner(owner),
-                        key(key)
+                    Group(Iterator& in_owner, key_func_ret in_key) :
+                        owner(in_owner),
+                        key(in_key)
                     { }
 
                 public:
@@ -189,8 +189,8 @@ namespace iter {
 
                         public:
                             GroupIterator(Group *in_group_p,
-                                          key_func_ret& key)
-                                : key{&key},
+                                          key_func_ret& in_key)
+                                : key{&in_key},
                                 group_p{in_group_p}
                             { }
 

From c5594de9db795024aefbf4c949cf714ef210d1ea Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 2 Apr 2015 17:27:49 -0400
Subject: [PATCH 1048/1866] eliminates shadow warnings from imap

---
 imap.hpp | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/imap.hpp b/imap.hpp
index 168cfd99..f4cf1279 100644
--- a/imap.hpp
+++ b/imap.hpp
@@ -91,9 +91,9 @@ namespace iter {
                         map_func, *std::begin(zipped)));
             
             // Value constructor for use only in the imap function
-            IMap(MapFunc map_func, Containers&& ... containers) :
-                map_func(map_func),
-                zipped(zip(std::forward<Containers>(containers)...))
+            IMap(MapFunc in_map_func, Containers&&... in_containers) :
+                map_func(in_map_func),
+                zipped(zip(std::forward<Containers>(in_containers)...))
             { }
 
         public:
@@ -106,8 +106,8 @@ namespace iter {
                     ZippedIterType zipiter;
 
                 public:
-                    Iterator(MapFunc& map_func, ZippedIterType&& in_zipiter) :
-                        map_func(&map_func),
+                    Iterator(MapFunc& in_map_func, ZippedIterType&& in_zipiter) :
+                        map_func(&in_map_func),
                         zipiter(std::move(in_zipiter))
                     { } 
 

From 3992376ca5ae1bbffa6272b4c3bc6a306430059a Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 2 Apr 2015 17:29:37 -0400
Subject: [PATCH 1049/1866] eliminates shadow warnings from product

---
 product.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/product.hpp b/product.hpp
index 44210a51..72ef1b36 100644
--- a/product.hpp
+++ b/product.hpp
@@ -33,8 +33,8 @@ namespace iter {
         private:
             Container container;
             Productor<RestContainers...> rest_products;
-            Productor(Container&& container, RestContainers&&... rest)
-                : container(std::forward<Container>(container)),
+            Productor(Container&& in_container, RestContainers&&... rest)
+                : container(std::forward<Container>(in_container)),
                 rest_products{std::forward<RestContainers>(rest)...}
             { }
 

From 9d2f2b1ff0e750b3ad664b91fe6281d9e770788d Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 2 Apr 2015 17:33:25 -0400
Subject: [PATCH 1050/1866] eliminates shadow warnings from range

---
 range.hpp | 36 ++++++++++++++++++------------------
 1 file changed, 18 insertions(+), 18 deletions(-)

diff --git a/range.hpp b/range.hpp
index f0e7048c..7a0017d3 100644
--- a/range.hpp
+++ b/range.hpp
@@ -49,16 +49,16 @@ namespace iter {
             const T stop;
             const T step;
 
-            Range(T stop)
+            Range(T in_stop)
                 : start{0},
-                stop{stop},
+                stop{in_stop},
                 step{1}
             { }
 
-            Range(T start, T stop, T step =1)
-                : start{start},
-                stop{stop},
-                step{step}
+            Range(T in_start, T in_stop, T in_step =1)
+                : start{in_start},
+                stop{in_stop},
+                step{in_step}
             { }
 
         public:
@@ -82,9 +82,9 @@ namespace iter {
                             && !(this->step < 0 && this->value <= other.value);
                     }
                 public:
-                    Iterator(T val, T step)
+                    Iterator(T val, T in_step)
                         : value{val},
-                        step{step}
+                        step{in_step}
                     { }
 
                     T operator*() const {
@@ -152,16 +152,16 @@ namespace iter {
             const T stop;
             const T step;
 
-            Range(T stop)
+            Range(T in_stop)
                 : start{0},
-                stop{stop},
+                stop{in_stop},
                 step{1}
             { }
 
-            Range(T start, T stop, T step =1)
-                : start{start},
-                stop{stop},
-                step{step}
+            Range(T in_start, T in_stop, T in_step =1)
+                : start{in_start},
+                stop{in_stop},
+                step{in_step}
             { }
         public:
             class Iterator
@@ -174,10 +174,10 @@ namespace iter {
                     unsigned long steps_taken =0;
 
                 public:
-                    Iterator(T start, T step)
-                        : start{start},
-                        value{start},
-                        step{step}
+                    Iterator(T in_start, T in_step)
+                        : start{in_start},
+                        value{in_start},
+                        step{in_step}
                     { }
 
                     bool operator!=(const Iterator& other) const {

From ab5155450b43d2330bcbfb915621f1cc8af91dfe Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 2 Apr 2015 17:37:41 -0400
Subject: [PATCH 1051/1866] eliminates shadow warnings in reversed

---
 reversed.hpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/reversed.hpp b/reversed.hpp
index b9427f72..0e03b6c1 100644
--- a/reversed.hpp
+++ b/reversed.hpp
@@ -20,8 +20,8 @@ namespace iter {
             Container container;
             friend Reverser reversed<Container>(Container&&);
             
-            Reverser(Container&& container)
-                : container(std::forward<Container>(container))
+            Reverser(Container&& in_container)
+                : container(std::forward<Container>(in_container))
             { }
 
         public:
@@ -88,8 +88,8 @@ namespace iter {
             friend Reverser reversed<T, N>(T (&)[N]);
             
             // Value constructor for use only in the reversed function
-            Reverser(T *array)
-                : array{array}
+            Reverser(T *in_array)
+                : array{in_array}
             { }
 
         public:

From 63d86a41fb9a5ae0c3ffcb5500b11e05b78db695 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 2 Apr 2015 17:38:59 -0400
Subject: [PATCH 1052/1866] eliminates shadow warnings in slice

---
 slice.hpp | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/slice.hpp b/slice.hpp
index f31e164b..2dfac39d 100644
--- a/slice.hpp
+++ b/slice.hpp
@@ -33,12 +33,12 @@ namespace iter {
             //template <typename T>
             //friend Slice<std::initializer_list<T>> slice(std::initializer_list<T>);
         public:
-            Slice(Container&& in_container, DifferenceType start,
-                  DifferenceType stop, DifferenceType step)
+            Slice(Container&& in_container, DifferenceType in_start,
+                  DifferenceType in_stop, DifferenceType in_step)
                 : container(std::forward<Container>(in_container)),
-                start{start < stop && step > 0 ? start : stop},
-                stop{stop},
-                step{step}
+                start{in_start < in_stop && in_step > 0 ? in_start : in_stop},
+                stop{in_stop},
+                step{in_step}
             { }
 
 
@@ -56,14 +56,14 @@ namespace iter {
                 public:
                     Iterator (iterator_type<Container>&& si,
                             iterator_type<Container>&& se,
-                            DifferenceType start,
-                            DifferenceType stop,
-                            DifferenceType step)
+                            DifferenceType in_start,
+                            DifferenceType in_stop,
+                            DifferenceType in_step)
                         : sub_iter{std::move(si)},
                         sub_end{std::move(se)},
-                        current{start},
-                        stop{stop},
-                        step{step}
+                        current{in_start},
+                        stop{in_stop},
+                        step{in_step}
                     { }
 
                     iterator_deref<Container> operator*() {

From f7480e183f6afa2350898ad1153db284c9c80d1e Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 2 Apr 2015 17:39:49 -0400
Subject: [PATCH 1053/1866] eliminates shadow warnings from sliding_window

---
 sliding_window.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/sliding_window.hpp b/sliding_window.hpp
index 7780f183..8d3526e0 100644
--- a/sliding_window.hpp
+++ b/sliding_window.hpp
@@ -31,8 +31,8 @@ namespace iter {
             friend SlidingWindow<std::initializer_list<T>> sliding_window(
                     std::initializer_list<T>, std::size_t);
 
-            SlidingWindow(Container&& container, std::size_t win_sz)
-                : container(std::forward<Container>(container)),
+            SlidingWindow(Container&& in_container, std::size_t win_sz)
+                : container(std::forward<Container>(in_container)),
                 window_size{win_sz}
             { }
 

From a803bc30308d55b649e64b281969097f6b8290f8 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 2 Apr 2015 17:41:23 -0400
Subject: [PATCH 1054/1866] eliminates shadow warnings in takewhile

---
 takewhile.hpp | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/takewhile.hpp b/takewhile.hpp
index bd518c32..2c27c715 100644
--- a/takewhile.hpp
+++ b/takewhile.hpp
@@ -33,9 +33,9 @@ namespace iter {
             friend TakeWhile<FF, std::initializer_list<T>> takewhile(
                     FF, std::initializer_list<T>);
 
-            TakeWhile(FilterFunc filter_func, Container&& container)
-                : container(std::forward<Container>(container)),
-                filter_func(filter_func)
+            TakeWhile(FilterFunc in_filter_func, Container&& in_container)
+                : container(std::forward<Container>(in_container)),
+                filter_func(in_filter_func)
             { }
 
 
@@ -68,10 +68,10 @@ namespace iter {
                 public:
                     Iterator(iterator_type<Container>&& iter,
                             iterator_type<Container>&& end,
-                            FilterFunc& filter_func)
+                            FilterFunc& in_filter_func)
                         : sub_iter{std::move(iter)},
                         sub_end{std::move(end)},
-                        filter_func(&filter_func)
+                        filter_func(&in_filter_func)
                     { 
                         if (this->sub_iter != this->sub_end) {
                             this->item.reset(*this->sub_iter);

From b4bc10959332f69db9643c2ac615f038d121481e Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 2 Apr 2015 17:43:24 -0400
Subject: [PATCH 1055/1866] eliminates shadow warnings from zip_longest

---
 zip_longest.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/zip_longest.hpp b/zip_longest.hpp
index 044a9191..ecc973c4 100644
--- a/zip_longest.hpp
+++ b/zip_longest.hpp
@@ -38,8 +38,8 @@ namespace iter {
 
             Container container;
             ZippedLongest<RestContainers...> rest_zipped;
-            ZippedLongest(Container&& container, RestContainers&&... rest)
-                : container(std::forward<Container>(container)),
+            ZippedLongest(Container&& in_container, RestContainers&&... rest)
+                : container(std::forward<Container>(in_container)),
                 rest_zipped{std::forward<RestContainers>(rest)...}
             { }
 

From 423b91c775c891f9cfbf8c17d358082d333a35ab Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 2 Apr 2015 18:05:24 -0400
Subject: [PATCH 1056/1866] marks zip_longest constexpr funcs as const

---
 zip_longest.hpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/zip_longest.hpp b/zip_longest.hpp
index ecc973c4..d1cc3e0f 100644
--- a/zip_longest.hpp
+++ b/zip_longest.hpp
@@ -126,7 +126,7 @@ namespace iter {
                         return *this;
                     }
 
-                    constexpr Iterator operator++(int) {
+                    constexpr Iterator operator++(int) const {
                         return *this;
                     }
 
@@ -138,16 +138,16 @@ namespace iter {
                         return true;
                     }
 
-                    constexpr std::tuple<> operator*() {
+                    constexpr std::tuple<> operator*() const {
                         return {};
                     }
             };
 
-            constexpr Iterator begin() {
+            constexpr Iterator begin() const {
                 return {};
             }
 
-            constexpr Iterator end() {
+            constexpr Iterator end() const {
                 return {};
             }
     };

From b4c2e30625f9f37faf8861323e8110fe196cd38f Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 4 Apr 2015 10:11:36 -0700
Subject: [PATCH 1057/1866] adds basic test for sorted

---
 catchtest/test_sorted.cpp | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 catchtest/test_sorted.cpp

diff --git a/catchtest/test_sorted.cpp b/catchtest/test_sorted.cpp
new file mode 100644
index 00000000..761c3493
--- /dev/null
+++ b/catchtest/test_sorted.cpp
@@ -0,0 +1,23 @@
+#include <sorted.hpp>
+
+#include <set>
+#include <unordered_set>
+#include <vector>
+#include <array>
+#include <string>
+#include <utility>
+
+#include "helpers.hpp"
+#include "catch.hpp"
+
+using iter::sorted;
+
+using Vec = const std::vector<int>;
+
+TEST_CASE("sorted: iterates through a vector in sorted order", "[sorted]" ){
+    Vec ns = {4, 0, 5, 1, 6, 7, 9, 3, 2, 8};
+    auto s = sorted(ns);
+    Vec v(std::begin(s), std::end(s));
+    Vec vc = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+    REQUIRE( v == vc );
+}

From 270b20e169393fcfb18b95877de798aebbc710c5 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 4 Apr 2015 10:11:52 -0700
Subject: [PATCH 1058/1866] builds sorted test

---
 catchtest/SConstruct | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/catchtest/SConstruct b/catchtest/SConstruct
index 4bbf3f42..615fb6d5 100644
--- a/catchtest/SConstruct
+++ b/catchtest/SConstruct
@@ -37,7 +37,7 @@ progs = Split(
     reversed
     slice
     sliding_window
-    
+    sorted
     takewhile
     unique_everseen
     unique_justseen

From c6a0374620b879701bbf2bdc9bcb7bb89c2d147e Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 4 Apr 2015 10:12:08 -0700
Subject: [PATCH 1059/1866] tests that elements can be modified through sorted

---
 catchtest/test_sorted.cpp | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/catchtest/test_sorted.cpp b/catchtest/test_sorted.cpp
index 761c3493..f49d62cf 100644
--- a/catchtest/test_sorted.cpp
+++ b/catchtest/test_sorted.cpp
@@ -21,3 +21,12 @@ TEST_CASE("sorted: iterates through a vector in sorted order", "[sorted]" ){
     Vec vc = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
     REQUIRE( v == vc );
 }
+
+TEST_CASE("sorted: can modify elements through sorted", "[sorted]") {
+    std::vector<int> ns(3, 9);
+    for (auto&& n : sorted(ns)) {
+        n = -1;
+    }
+    Vec vc(3, -1);
+    REQUIRE( ns == vc );
+}

From 11006b48d42d0405ae56c00e1b401fbadb026f36 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 4 Apr 2015 10:14:54 -0700
Subject: [PATCH 1060/1866] tests sorted with unordered set

---
 catchtest/test_sorted.cpp | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/catchtest/test_sorted.cpp b/catchtest/test_sorted.cpp
index f49d62cf..4e441cf6 100644
--- a/catchtest/test_sorted.cpp
+++ b/catchtest/test_sorted.cpp
@@ -30,3 +30,12 @@ TEST_CASE("sorted: can modify elements through sorted", "[sorted]") {
     Vec vc(3, -1);
     REQUIRE( ns == vc );
 }
+
+TEST_CASE("sorted: can iterate over unordered container", "[sorted]") {
+    std::unordered_set<int> ns = {1, 3, 2, 0, 4};
+    auto s = sorted(ns);
+
+    Vec v(std::begin(s), std::end(s));
+    Vec vc = {0, 1, 2, 3, 4};
+    REQUIRE( v == vc );
+}

From a5a621e6b92c718dd3d3f7e9cc19c04c70daa06a Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 4 Apr 2015 10:16:39 -0700
Subject: [PATCH 1061/1866] tests sorted is empty when given empty sequence

---
 catchtest/test_sorted.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/catchtest/test_sorted.cpp b/catchtest/test_sorted.cpp
index 4e441cf6..1a459402 100644
--- a/catchtest/test_sorted.cpp
+++ b/catchtest/test_sorted.cpp
@@ -39,3 +39,9 @@ TEST_CASE("sorted: can iterate over unordered container", "[sorted]") {
     Vec vc = {0, 1, 2, 3, 4};
     REQUIRE( v == vc );
 }
+
+TEST_CASE("sorted: empty when iterable is empty", "[sorted]") {
+    Vec ns{};
+    auto s = sorted(ns);
+    REQUIRE( std::begin(s) == std::end(s) );
+}

From 8661b3d533da54b61016c33ed35ff516114757b9 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 4 Apr 2015 10:27:37 -0700
Subject: [PATCH 1062/1866] tests sorted with different functor types

---
 catchtest/test_sorted.cpp | 34 ++++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/catchtest/test_sorted.cpp b/catchtest/test_sorted.cpp
index 1a459402..a1638ecd 100644
--- a/catchtest/test_sorted.cpp
+++ b/catchtest/test_sorted.cpp
@@ -45,3 +45,37 @@ TEST_CASE("sorted: empty when iterable is empty", "[sorted]") {
     auto s = sorted(ns);
     REQUIRE( std::begin(s) == std::end(s) );
 }
+
+namespace {
+    bool int_greater_than(int lhs, int rhs) {
+        return lhs > rhs;
+    }
+
+    struct IntGreaterThan {
+        bool operator() (int lhs, int rhs) const {
+            return lhs > rhs;
+        }
+    };
+}
+
+TEST_CASE("sorted: works with different functor types", "[sorted]") {
+    Vec ns = {4, 1, 3, 2, 0};
+    std::vector<int> v;
+    SECTION("with function pointer") {
+        auto s = sorted(ns, int_greater_than);
+        v.insert(v.begin(), std::begin(s), std::end(s));
+    }
+
+    SECTION("with callable object") {
+        auto s = sorted(ns, IntGreaterThan{});
+        v.insert(v.begin(), std::begin(s), std::end(s));
+    }
+
+    SECTION("with lambda") {
+        auto s = sorted(ns, [](int lhs, int rhs){return lhs > rhs;});
+        v.insert(v.begin(), std::begin(s), std::end(s));
+    }
+
+    Vec vc = {4, 3, 2, 1, 0};
+    REQUIRE( v == vc );
+}

From 1280b949a63c3e57ec8b6c5a9b15be7aa74f58fc Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 4 Apr 2015 11:17:27 -0700
Subject: [PATCH 1063/1866] tests sorted moves and binds correctly

---
 catchtest/test_sorted.cpp | 83 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 83 insertions(+)

diff --git a/catchtest/test_sorted.cpp b/catchtest/test_sorted.cpp
index a1638ecd..854ddb0d 100644
--- a/catchtest/test_sorted.cpp
+++ b/catchtest/test_sorted.cpp
@@ -79,3 +79,86 @@ TEST_CASE("sorted: works with different functor types", "[sorted]") {
     Vec vc = {4, 3, 2, 1, 0};
     REQUIRE( v == vc );
 }
+
+namespace {
+template <typename T>
+class BasicIterableWithConstDeref {
+    private:
+        T *data;
+        std::size_t size;
+        bool was_moved_from_ = false;
+    public:
+        BasicIterableWithConstDeref(std::initializer_list<T> il)
+            : data{new T[il.size()]},
+            size{il.size()}
+        {
+            // would like to use enumerate, can't because it's for unit
+            // testing enumerate
+            std::size_t i = 0;
+            for (auto&& e : il) {
+                data[i] = e;
+                ++i;
+            }
+        }
+
+        BasicIterableWithConstDeref& operator=(BasicIterableWithConstDeref&&) = delete;
+        BasicIterableWithConstDeref& operator=(const BasicIterableWithConstDeref&) = delete;
+        BasicIterableWithConstDeref(const BasicIterableWithConstDeref&) = delete;
+
+        BasicIterableWithConstDeref(BasicIterableWithConstDeref&& other)
+            : data{other.data},
+            size{other.size}
+        {
+            other.data = nullptr;
+            other.was_moved_from_ = true;
+        }
+
+        bool was_moved_from() const {
+            return this->was_moved_from_;
+        }
+
+        ~BasicIterableWithConstDeref() {
+            delete [] this->data;
+        }
+
+        class Iterator {
+            private:
+                T *p;
+            public:
+                Iterator(T *b) : p{b} { }
+                bool operator!=(const Iterator& other) const {
+                    return this->p != other.p;
+                }
+
+                Iterator& operator++() {
+                    ++this->p;
+                    return *this;
+                }
+
+                T& operator*() {
+                    return *this->p;
+                }
+
+                const T& operator*() const {
+                    return *this->p;
+                }
+        };
+
+        Iterator begin() {
+            return {this->data};
+        }
+
+        Iterator end() {
+            return {this->data + this->size};
+        }
+};
+}
+
+TEST_CASE("sorted: moves rvalues and binds to lvalues", "[sorted]") {
+    BasicIterableWithConstDeref<int> bi{1, 2};
+    sorted(bi);
+    REQUIRE_FALSE( bi.was_moved_from() );
+
+    sorted(std::move(bi));
+    REQUIRE( bi.was_moved_from() );
+}

From 0ffb2605b16bfbe8d698a4c0d5b025efa1d187f0 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 4 Apr 2015 11:17:45 -0700
Subject: [PATCH 1064/1866] adds const_iterator_deref

Which deduces the type of an iterator dereferenced in a const context.
---
 iterbase.hpp | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/iterbase.hpp b/iterbase.hpp
index 1f962d84..dc65fcfc 100644
--- a/iterbase.hpp
+++ b/iterbase.hpp
@@ -28,6 +28,14 @@ namespace iter {
     using iterator_deref =
         decltype(*std::declval<iterator_type<Container>&>());
 
+    // const_iteator_deref is the type obtained through dereferencing
+    // a const iterator& (note: not a const_iterator).  ie: the result
+    // of Container::iterator::operator*() const
+    template <typename Container>
+    using const_iterator_deref =
+        decltype(*std::declval<const iterator_type<Container>&>());
+
+
     template <typename Container>
     using iterator_traits_deref =
         typename std::remove_reference<iterator_deref<Container>>::type;

From 136757a72444e5e15757dc9b5f37cfb1691ddce5 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 4 Apr 2015 11:18:16 -0700
Subject: [PATCH 1065/1866] Uses correct std::less in sorted

Needs to be const
---
 sorted.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/sorted.hpp b/sorted.hpp
index 5dbbdc9b..93e4a3c7 100644
--- a/sorted.hpp
+++ b/sorted.hpp
@@ -68,10 +68,10 @@ namespace iter {
     template <typename Container>
     auto sorted(Container&& container) ->
              decltype(sorted(std::forward<Container>(container),
-                         std::less<iterator_deref<Container>>()))
+                         std::less<const_iterator_deref<Container>>()))
      {
          return sorted(std::forward<Container>(container),
-                 std::less<iterator_deref<Container>>());
+                 std::less<const_iterator_deref<Container>>());
      }
 
 }

From 7315351d098c2a0bc880ea51e37cb8916c6b2482 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 4 Apr 2015 11:20:56 -0700
Subject: [PATCH 1066/1866] tests sorted with SolidInt

---
 catchtest/test_sorted.cpp | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/catchtest/test_sorted.cpp b/catchtest/test_sorted.cpp
index 854ddb0d..918dec7d 100644
--- a/catchtest/test_sorted.cpp
+++ b/catchtest/test_sorted.cpp
@@ -162,3 +162,12 @@ TEST_CASE("sorted: moves rvalues and binds to lvalues", "[sorted]") {
     sorted(std::move(bi));
     REQUIRE( bi.was_moved_from() );
 }
+
+TEST_CASE("sorted: doesn't move or copy elements of iterable", "[sorted]") {
+    using itertest::SolidInt;
+    constexpr SolidInt arr[] = {{6}, {7}, {8}};
+    for (auto&& i : sorted(arr, [](const SolidInt& lhs, const SolidInt& rhs){
+                return lhs.getint() < rhs.getint();})) {
+        (void)i;
+    }
+}

From 0477efb3e17a67d13c01d48562f28e79b08ba2c9 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 4 Apr 2015 11:40:50 -0700
Subject: [PATCH 1067/1866] removes Functor from Sorted's type

Since the comparison function is only used in the constructor, there's
no reason to make it be a part of Sorted<T>.  Instead the constructor
can now deduce the type of the compare function.
---
 sorted.hpp | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/sorted.hpp b/sorted.hpp
index 93e4a3c7..c68171e3 100644
--- a/sorted.hpp
+++ b/sorted.hpp
@@ -9,25 +9,26 @@
 #include <vector>
 
 namespace iter {
-    template <typename Container, typename CompareFunc>
+    template <typename Container>
     class Sorted;
 
     template <typename Container, typename CompareFunc>
-    Sorted<Container, CompareFunc> sorted(Container&&, CompareFunc);
+    Sorted<Container> sorted(Container&&, CompareFunc);
 
-    template <typename Container, typename CompareFunc>
+    template <typename Container>
     class Sorted  {
         private:
             using IterIterWrap =
                 IterIterWrapper<std::vector<iterator_type<Container>>>;
             using ItIt = iterator_type<IterIterWrap>;
-            friend Sorted
-                sorted<Container, CompareFunc>(Container&&, CompareFunc);
+
+            template <typename C, typename F>
+            friend Sorted<C> sorted(C&&, F);
 
             Container container;
             IterIterWrap sorted_iters;
 
-
+            template <typename CompareFunc>
             Sorted(Container&& in_container, CompareFunc compare_func)
                 : container(std::forward<Container>(in_container))
             {
@@ -60,7 +61,7 @@ namespace iter {
     };
 
     template <typename Container, typename CompareFunc>
-    Sorted<Container, CompareFunc> sorted(
+    Sorted<Container> sorted(
             Container&& container, CompareFunc compare_func) {
         return {std::forward<Container>(container), compare_func};
     }

From 3bb32e7dfec9679bc9c4a57a01d68e13e4b37d51 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 4 Apr 2015 12:58:40 -0700
Subject: [PATCH 1068/1866] adds sorted() to the docs

---
 README.md | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/README.md b/README.md
index 7d6b8668..8f33b5f9 100644
--- a/README.md
+++ b/README.md
@@ -22,6 +22,7 @@ evaluation wherever possible.
 [groupby](#groupby)<br />
 [accumulate](#accumulate)<br />
 [compress](#compress)<br />
+[sorted](#sorted)<br />
 [chain](#chain)<br />
 [chain.from\_iterable](#chainfrom_iterable)<br />
 [reversed](#reversed)<br />
@@ -337,6 +338,20 @@ for (auto&& i : compress(ivec, bvec) {
 }
 ```
 
+sorted
+------
+Allows iteration over a sequence in sorted order. `sorted()` does
+**not** produce a new sequence, copy elements, or modify the original
+sequence.  It only provides a way to iterate over existing elements.
+The below outputs `0 1 2 3 4`.
+
+```c++
+unordered_set<int> nums{4, 0, 2, 1, 3};
+for (auto&& i : sorted(nums)) {
+    cout << i << '\n';
+}
+```
+
 chain
 -----
 

From a9c72cbdeb24c2cea3ca67712f1f27be7945dffb Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 4 Apr 2015 13:03:57 -0700
Subject: [PATCH 1069/1866] mentions second sorted arg and requirements

---
 README.md | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 8f33b5f9..86a3b666 100644
--- a/README.md
+++ b/README.md
@@ -340,9 +340,15 @@ for (auto&& i : compress(ivec, bvec) {
 
 sorted
 ------
-Allows iteration over a sequence in sorted order. `sorted()` does
+Allows iteration over a sequence in sorted order. `sorted` does
 **not** produce a new sequence, copy elements, or modify the original
 sequence.  It only provides a way to iterate over existing elements.
+`sorted` also takes an optional second 
+[comparator](http://en.cppreference.com/w/cpp/concept/Compare)
+argument.  If not provided, defaults to `std::less`. <br />
+Iterables passed to sorted are required to have an iterator with
+an `operator*() const` member.
+
 The below outputs `0 1 2 3 4`.
 
 ```c++

From 56e33f051d3bf528bfac5cdf2519238dd2cdeb01 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 4 Apr 2015 13:11:21 -0700
Subject: [PATCH 1070/1866] adds repeat to the docs

---
 README.md | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/README.md b/README.md
index 86a3b666..98462cbe 100644
--- a/README.md
+++ b/README.md
@@ -19,6 +19,7 @@ evaluation wherever possible.
 [takewhile](#takewhile)<br />
 [dropwhile](#dropwhile)<br />
 [cycle](#cycle)<br />
+[repeat](#repeat)<br />
 [groupby](#groupby)<br />
 [accumulate](#accumulate)<br />
 [compress](#compress)<br />
@@ -212,6 +213,25 @@ for (auto&& i : cycle(vec)) {
 }
 ```
 
+repeat
+------
+Repeatedly produces a single argument forever, or a given number of times.
+`repeat` will bind a reference when passed an lvalue and move when given
+an rvalue.  It will then yield a reference to the same item until completion.
+
+The below prints `1` five times.
+```c++
+for (auto&& e : repeat(1, 5)) {
+    cout << e << '\n';
+}
+```
+The below prints `2` forever
+```c++
+for (auto&& e : repeat(2)) {
+    cout << e << '\n';
+}
+```
+
 groupby
 -------
 Separate an iterable into groups sharing a common key.  The following example

From ed7ce408caab8a8c0cac6afe57da3fdfdae9dd80 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 4 Apr 2015 13:23:48 -0700
Subject: [PATCH 1071/1866] adds count to docs

---
 README.md | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/README.md b/README.md
index 98462cbe..81eda729 100644
--- a/README.md
+++ b/README.md
@@ -20,6 +20,7 @@ evaluation wherever possible.
 [dropwhile](#dropwhile)<br />
 [cycle](#cycle)<br />
 [repeat](#repeat)<br />
+[count](#count)<br />
 [groupby](#groupby)<br />
 [accumulate](#accumulate)<br />
 [compress](#compress)<br />
@@ -232,6 +233,28 @@ for (auto&& e : repeat(2)) {
 }
 ```
 
+count
+-----
+Effectively a `range` without a stopping point.<br />
+`count()` with no arguments will start counting from 0 with a positive 
+step of 1.<br />
+`count(i)` will start counting from `i` with a positive step of 1.<br />
+`count(i, st)` will start counting from `i` with a step of `st`.
+
+*Technical limitations*: Unlike Python which can use its long integer
+types when needed, count() will eventually exceed the 
+maximum possible value for its type (or minimum with a negative step).
+When using a signed type it is up to the API user to ensure this does
+not happen.  If the limit is exceeded for signed types, the result is
+undefined (as per the C++ standard).
+
+The below will print `0 1 2` ... etc
+```c++
+for (auto&& i : count()) {
+    cout << i << '\n';
+}
+```
+
 groupby
 -------
 Separate an iterable into groups sharing a common key.  The following example

From a5aed68a560213e1237f6778d46e5ec1bcfbd99f Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 4 Apr 2015 13:33:39 -0700
Subject: [PATCH 1072/1866] adds comb_w_repl to the docs

---
 README.md | 30 ++++++++++++++++++++++++------
 1 file changed, 24 insertions(+), 6 deletions(-)

diff --git a/README.md b/README.md
index 81eda729..7fcfaf40 100644
--- a/README.md
+++ b/README.md
@@ -35,6 +35,7 @@ evaluation wherever possible.
 ##### Combinatoric fuctions
 [product](#product)<br />
 [combinations](#combinations)<br />
+[combinations_with_replacement](#combinations_with_replacement)
 [permutations](#permutations)<br />
 [powerset](#powerset)<br />
 
@@ -536,16 +537,33 @@ for (auto&& t : product(v1,v2,v3,v4)) {
 combinations
 -----------
 
-Generates n length unique sequences of the input range, there is also a
-combinations_with_replacement
+Generates n length unique sequences of the input range.
 
 Example usage:
 ```c++
-std::vector<int> v = {1,2,3,4,5};                                              
+vector<int> v = {1,2,3,4,5};                                              
 for (auto&& i : combinations(v,3)) {                                             
-    //std::cout << i << std::endl;                                             
-    for (auto&& j : i ) std::cout << j << " ";                                   
-    std::cout<<std::endl;                                                      
+    //cout << i << std::endl;                                             
+    for (auto&& j : i ) cout << j << " ";                                   
+    cout << '\n';                                                      
+}
+```
+
+combinations_with_replacement
+-----------------------------
+Like combinations, but with replacment of each element.  The
+below is printed by the loop that follows:
+```
+{A, A}
+{A, B}
+{A, C}
+{B, B}
+{B, C}
+{C, C}
+```
+```c++
+for (auto&& v : combinations_with_replacement(s, 2)) {
+    cout << '{' << v[0] << ", " << v[1] << "}\n";
 }
 ```
 

From 6764946c0e886aee64b6a9f825381f0ad8bf504a Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 4 Apr 2015 13:48:31 -0700
Subject: [PATCH 1073/1866] adds zip_longest to the docs

---
 README.md | 42 +++++++++++++++++++++++++++++++++++++-----
 1 file changed, 37 insertions(+), 5 deletions(-)

diff --git a/README.md b/README.md
index 7fcfaf40..22627e5a 100644
--- a/README.md
+++ b/README.md
@@ -11,6 +11,7 @@ evaluation wherever possible.
 [range](#range)<br />
 [enumerate](#enumerate)<br />
 [zip](#zip)<br />
+[zip_longest](#zip)<br />
 [imap](#imap)<br />
 [filter](#filter)<br />
 [filterfalse](#filterfalse)<br />
@@ -329,12 +330,43 @@ for (auto&& e : zip(i,f,s,d)) {
 }
 ```
 
+zip_longest
+-----------
+Terminates on the longest sequence instead of the shortest.
+Repeatedly yields a tuple of `boost::optional<T>`s where `T` is the type 
+yielded by the sequences' respective iterators.  Because of its boost
+dependency, `zip_longest` is not in `itertools.hpp` and must be included
+separately.
+The following loop prints either "Just <item>" or "Nothing" for each
+element in each tuple yielded.
+
+```c++
+vector<int> v1 = {0, 1, 2, 3};
+vector<int> v2 = {10, 11};
+for (auto&& t : zip_longest(v1, v2)) {
+    cout << '{';
+    if (std::get<0>(t)) {
+        cout << "Just " << *std::get<0>(t);
+    } else {
+        cout << "Nothing";
+    }
+    cout << ", ";
+    if (std::get<1>(t)) {
+        cout << "Just " << *std::get<1>(t);
+    } else {
+        cout << "Nothing";
+    }
+    cout << "}\n";
+}
+```
 
-a `zip_longest` also exists where the range terminates on the longest
-range instead of the shortest. because of that you have to return a
-`boost::optional<T>` where `T` is whatever type the iterator dereferenced
-to (`std::optional` when it is released, if ever)
-
+The output is:
+```
+{Just 0, Just 10}
+{Just 1, Just 11}
+{Just 2, Nothing}
+{Just 3, Nothing}
+```
 
 imap
 ----

From 0bb0482b27bf76089ad35ee06a9463f2cfe1af27 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 4 Apr 2015 13:52:24 -0700
Subject: [PATCH 1074/1866] inserts missing br

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 22627e5a..e952655b 100644
--- a/README.md
+++ b/README.md
@@ -36,7 +36,7 @@ evaluation wherever possible.
 ##### Combinatoric fuctions
 [product](#product)<br />
 [combinations](#combinations)<br />
-[combinations_with_replacement](#combinations_with_replacement)
+[combinations_with_replacement](#combinations_with_replacement)<br />
 [permutations](#permutations)<br />
 [powerset](#powerset)<br />
 

From 4a7dc7102713b862f121d74744dd9ff21d3dad06 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 4 Apr 2015 14:03:05 -0700
Subject: [PATCH 1075/1866] removes include of zip_longest from itertools.hpp

Must be included explicitly
---
 itertools.hpp | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/itertools.hpp b/itertools.hpp
index 8e84eed3..1f54acff 100644
--- a/itertools.hpp
+++ b/itertools.hpp
@@ -1,5 +1,5 @@
-#ifndef ITERTOOLS_HPP
-#define ITERTOOLS_HPP
+#ifndef ITERTOOLS_ALL_HPP_
+#define ITERTOOLS_ALL_HPP_
 
 #include "accumulate.hpp"
 #include "chain.hpp"
@@ -28,7 +28,9 @@
 #include "unique_everseen.hpp"
 #include "unique_justseen.hpp"
 #include "zip.hpp"
-#include "zip_longest.hpp"
+
+// zip_longest is the only itertool with a boost depedency, so it must be
+// included explicitly
 
 #endif
 

From dfee40438f886f7a8f067873b5c0a54eed88bf06 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 4 Apr 2015 18:25:12 -0700
Subject: [PATCH 1076/1866] adds starmap to the docs

---
 README.md | 43 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)

diff --git a/README.md b/README.md
index a0623a8b..9cd3a1f4 100644
--- a/README.md
+++ b/README.md
@@ -29,6 +29,7 @@ evaluation wherever possible.
 [repeat](#repeat)<br />
 [count](#count)<br />
 [groupby](#groupby)<br />
+[starmap](#starmap)<br />
 [accumulate](#accumulate)<br />
 [compress](#compress)<br />
 [sorted](#sorted)<br />
@@ -287,6 +288,48 @@ for (auto&& gb : groupby(vec, [] (const string &s) {return s.length(); })) {
 It just iterates through, making a new group each time there is a key change.
 Thus, if the the group is unsorted, the same key may appear multiple times.
 
+starmap
+-------
+
+Takes a sequence of tuple-like objects (anything that works with `std::get`)
+and unpacks each object into individual arguments for each function call.
+The below example takes a `vector` of `pairs` of ints, and passes them
+to a function expecting two ints, with the elements of the `pair` being
+the first and second arguments to the function.
+
+```c++
+vector<pair<int, int>> v = {{2, 3}, {5, 2}, {3, 4}}; // {base, exponent}
+for (auto&& i : starmap([](int b, int e){return pow(b, e);}, v)) {
+    // ...
+}
+```
+
+`starmap` can also work over a tuple-like object of tuple-like objects even
+when the contained objects are different as long as the functor works with
+multiple types of calls.  For example, a `Callable` struct with overloads
+for its `operator()` will work as long as all overloads have the same
+return type
+
+```c++
+struct Callable {
+    int operator()(int i) const;
+    int operator()(int i, char c) const;
+    int operator()(double d, int i, char c) const;
+};
+```
+
+This will work with a tuple of mixed types
+
+```c++
+auto t = make_tuple(
+        make_tuple(5), // first form
+        make_pair(3, 'c'), // second
+        make_tuple(1.0, 1, '1')); // third
+for (auto&& i : starmap(Callable{}, t)) {
+    // ...
+}
+```
+
 accumulate
 -------
 Differs from `std::accumulate` (which in my humble opinion should be named 

From 1036054836800260db1d436b67e3f896dc1ab6d1 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 4 Apr 2015 18:55:42 -0700
Subject: [PATCH 1077/1866] tests that reversed iterator meets requirements

---
 catchtest/test_reversed.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/catchtest/test_reversed.cpp b/catchtest/test_reversed.cpp
index 2fc2adc6..389badd0 100644
--- a/catchtest/test_reversed.cpp
+++ b/catchtest/test_reversed.cpp
@@ -60,3 +60,9 @@ TEST_CASE("reversed: with iterable doesn't move or copy elems", "[reversed]") {
         (void)i;
     }
 }
+
+TEST_CASE("reversed: iterator meets requirements", "[reversed]") {
+    Vec v;
+    auto r = reversed(v);
+    REQUIRE( itertest::IsIterator<decltype(std::begin(r))>::value );
+}

From ef1ae7513b98dd57e090667d1e8ed9eab9b6ac3b Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 4 Apr 2015 19:00:02 -0700
Subject: [PATCH 1078/1866] tests that sorted iter meets requirements

---
 catchtest/test_sorted.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/catchtest/test_sorted.cpp b/catchtest/test_sorted.cpp
index 918dec7d..843501b7 100644
--- a/catchtest/test_sorted.cpp
+++ b/catchtest/test_sorted.cpp
@@ -171,3 +171,9 @@ TEST_CASE("sorted: doesn't move or copy elements of iterable", "[sorted]") {
         (void)i;
     }
 }
+
+TEST_CASE("sorted: iterator meets requirements", "[sorted]") {
+    Vec v;
+    auto r = sorted(v);
+    REQUIRE( itertest::IsIterator<decltype(std::begin(r))>::value );
+}

From dd46ff387bcb392e3df481dacea2488187ebd1fc Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 6 Apr 2015 21:54:01 -0700
Subject: [PATCH 1079/1866] includes requirements in readme

---
 README.md | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index e952655b..9c3c12de 100644
--- a/README.md
+++ b/README.md
@@ -7,7 +7,15 @@ evaluation wherever possible.
 
 *Note*: Everthing is inside the `iter` namespace.
 
-##### Table of Contents
+#### Requirements
+This library is **header-only** and relies only on the C++ standard
+library. The only exception is `zip_longest` which uses `boost::optional`.
+`#include <cppitertools/itertools.hpp>` will include all of the provided
+tools except for `zip_longest` which must be included separately.  You may
+also include individual pieces with the relevant header
+(`#include <cppitertools/enumerate.hpp>` for example).
+
+#### Table of Contents
 [range](#range)<br />
 [enumerate](#enumerate)<br />
 [zip](#zip)<br />

From a740829d2ff15c0869565bb526f81042c649c5f0 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 7 Apr 2015 22:47:39 -0700
Subject: [PATCH 1080/1866] moves void_t into iterbase

---
 catchtest/helpers.hpp                         |  12 +-
 examples/.gitignore                           |   5 +
 examples/SConstruct                           |  51 ++++++++
 examples/samples.hpp                          |  98 +++++++++++++++
 examples/testaccumulate.cpp                   |  35 ++++++
 examples/testchain.cpp                        |  61 +++++++++
 examples/testchainfromiterable.cpp            |  28 +++++
 examples/testcombinations.cpp                 |  75 +++++++++++
 .../testcombinations_with_replacement.cpp     |  55 ++++++++
 examples/testcommand_chains.cpp               |  78 ++++++++++++
 examples/testcompress.cpp                     |  67 ++++++++++
 examples/testcount.cpp                        |  38 ++++++
 examples/testcycle.cpp                        |  70 +++++++++++
 examples/testdropwhile.cpp                    |  35 ++++++
 examples/testenumerate.cpp                    |  60 +++++++++
 examples/testfilter.cpp                       |  83 ++++++++++++
 examples/testfilterfalse.cpp                  |  93 ++++++++++++++
 examples/testgroupby.cpp                      | 109 ++++++++++++++++
 examples/testgrouper.cpp                      |  51 ++++++++
 examples/testimap.cpp                         |  45 +++++++
 examples/testpermutations.cpp                 |  60 +++++++++
 examples/testpowerset.cpp                     |  44 +++++++
 examples/testproduct.cpp                      |  77 ++++++++++++
 examples/testrange.cpp                        |  83 ++++++++++++
 examples/testrepeat.cpp                       |  31 +++++
 examples/testreversed.cpp                     |  43 +++++++
 examples/testslice.cpp                        |  81 ++++++++++++
 examples/testsliding_window.cpp               |  53 ++++++++
 examples/testsorted.cpp                       |  36 ++++++
 examples/testtakewhile.cpp                    |  32 +++++
 examples/testunique_everseen.cpp              |  41 ++++++
 examples/testunique_justseen.cpp              |  35 ++++++
 examples/testzip.cpp                          | 118 ++++++++++++++++++
 examples/testzip_longest.cpp                  |  96 ++++++++++++++
 iterbase.hpp                                  |  12 ++
 35 files changed, 1982 insertions(+), 9 deletions(-)
 create mode 100644 examples/.gitignore
 create mode 100644 examples/SConstruct
 create mode 100644 examples/samples.hpp
 create mode 100644 examples/testaccumulate.cpp
 create mode 100644 examples/testchain.cpp
 create mode 100644 examples/testchainfromiterable.cpp
 create mode 100644 examples/testcombinations.cpp
 create mode 100644 examples/testcombinations_with_replacement.cpp
 create mode 100644 examples/testcommand_chains.cpp
 create mode 100644 examples/testcompress.cpp
 create mode 100644 examples/testcount.cpp
 create mode 100644 examples/testcycle.cpp
 create mode 100644 examples/testdropwhile.cpp
 create mode 100644 examples/testenumerate.cpp
 create mode 100644 examples/testfilter.cpp
 create mode 100644 examples/testfilterfalse.cpp
 create mode 100644 examples/testgroupby.cpp
 create mode 100644 examples/testgrouper.cpp
 create mode 100644 examples/testimap.cpp
 create mode 100644 examples/testpermutations.cpp
 create mode 100644 examples/testpowerset.cpp
 create mode 100644 examples/testproduct.cpp
 create mode 100644 examples/testrange.cpp
 create mode 100644 examples/testrepeat.cpp
 create mode 100644 examples/testreversed.cpp
 create mode 100644 examples/testslice.cpp
 create mode 100644 examples/testsliding_window.cpp
 create mode 100644 examples/testsorted.cpp
 create mode 100644 examples/testtakewhile.cpp
 create mode 100644 examples/testunique_everseen.cpp
 create mode 100644 examples/testunique_justseen.cpp
 create mode 100644 examples/testzip.cpp
 create mode 100644 examples/testzip_longest.cpp

diff --git a/catchtest/helpers.hpp b/catchtest/helpers.hpp
index 29203304..7c36ca89 100644
--- a/catchtest/helpers.hpp
+++ b/catchtest/helpers.hpp
@@ -1,6 +1,8 @@
 #ifndef TEST_HELPER_H_
 #define TEST_HELPER_H_
 
+#include <iterbase.hpp>
+
 #include <stdexcept>
 #include <type_traits>
 #include <utility>
@@ -170,15 +172,7 @@ class BasicIterable {
         }
 };
 
-
-// gcc CWG 1558
-template <typename...>
-struct void_t_help {
-    using type = void;
-};
-template <typename... Ts>
-
-using void_t = typename void_t_help<Ts...>::type;
+using iter::void_t;
 
 template <typename, typename =void>
 struct IsIterator : std::false_type { };
diff --git a/examples/.gitignore b/examples/.gitignore
new file mode 100644
index 00000000..a77d502e
--- /dev/null
+++ b/examples/.gitignore
@@ -0,0 +1,5 @@
+*.o
+*.swp
+test*
+!test*.cpp
+.sconsign.dblite
diff --git a/examples/SConstruct b/examples/SConstruct
new file mode 100644
index 00000000..74195c1e
--- /dev/null
+++ b/examples/SConstruct
@@ -0,0 +1,51 @@
+import os
+
+env = Environment(
+    ENV = {'PATH' : os.environ['PATH']},
+    CXX='c++',
+    CXXFLAGS= ['-g', '-Wall', '-Wextra',
+               '-pedantic', '-std=c++11',
+                '-fdiagnostics-color=always',
+               '-I/usr/local/include'],
+    CPPPATH='..',
+    LINKFLAGS='-L/usr/local/lib')
+
+# allows highighting to print to terminal from compiler output
+env['ENV']['TERM'] = os.environ['TERM']
+
+progs = Split('''
+              accumulate
+              cycle 
+              enumerate 
+              range 
+              zip 
+              slice 
+              reversed 
+              filter 
+              repeat 
+              takewhile 
+              dropwhile 
+              zip_longest 
+              product 
+              permutations 
+              compress 
+              combinations_with_replacement 
+              combinations 
+              powerset
+              sliding_window
+              imap
+              count
+              filterfalse
+              grouper
+              chain
+              chainfromiterable
+              groupby
+              sorted
+              unique_justseen
+              unique_everseen
+              command_chains
+              ''')
+
+
+for p in progs:
+    env.Program('test{0}.cpp'.format(p))
diff --git a/examples/samples.hpp b/examples/samples.hpp
new file mode 100644
index 00000000..9faba373
--- /dev/null
+++ b/examples/samples.hpp
@@ -0,0 +1,98 @@
+#ifndef ITERTOOLS_SAMPLE_CLASSES_HPP
+#define ITERTOOLS_SAMPLE_CLASSES_HPP
+
+#include <iostream>
+#include <utility>
+#include <cstddef>
+
+namespace itertest {
+    class MoveOnly {
+        private:
+            int i; // not an aggregate
+        public:
+            MoveOnly(int v)
+                : i{v}
+            { }
+
+            MoveOnly(const MoveOnly&) = delete;
+            MoveOnly& operator=(const MoveOnly&) = delete;
+
+            MoveOnly(MoveOnly&& other) noexcept
+                : i{other.i}
+            { }
+
+            MoveOnly& operator=(MoveOnly&& other) noexcept {
+                this->i = other.i;
+                return *this;
+            }
+
+            // for std::next_permutation compatibility
+            friend bool operator<(const MoveOnly& lhs, const MoveOnly& rhs) {
+                return lhs.i < rhs.i;
+            }
+
+            friend std::ostream& operator<<(
+                    std::ostream& out, const MoveOnly& self) {
+                return out << self.i;
+            }
+
+    };
+
+    class DerefByValue {
+        private:
+            static constexpr std::size_t N = 3;
+            int array[N] = {0, 1, 2};
+        public:
+            DerefByValue() = default;
+
+            class Iterator {
+                private:
+                    int *current;
+                public:
+                    Iterator() = default;
+                    Iterator(int *p)
+                        : current{p}
+                    { }
+
+                    bool operator!=(const Iterator& other) const {
+                        return this->current != other.current;
+                    }
+
+                    // for testing, iterator derefences to an int instead of
+                    // an int&
+                    int operator*() /*const*/ {
+                        return *this->current;
+                    }
+
+                    Iterator& operator++() {
+                        ++this->current;
+                        return *this;
+                    }
+            };
+
+            Iterator begin() {
+                return {this->array};
+            }
+
+            Iterator end() {
+                return {this->array + N};
+            }
+    };
+
+    class DerefByValueFancy {
+        private:
+            static constexpr std::size_t N = 3;
+            int array[N] = {0, 1, 2};
+        public:
+            DerefByValueFancy() = default;
+
+            int *begin() {
+                return this->array;
+            }
+
+            int *end() {
+                return this->array + N;
+            }
+    };
+}
+#endif // #ifndef ITERTOOLS_SAMPLE_CLASSES_HPP
diff --git a/examples/testaccumulate.cpp b/examples/testaccumulate.cpp
new file mode 100644
index 00000000..edf3d0a4
--- /dev/null
+++ b/examples/testaccumulate.cpp
@@ -0,0 +1,35 @@
+#include <accumulate.hpp>
+#include <range.hpp>
+
+#include <iostream>
+#include <vector>
+
+int main() {
+    // accumulate with a lambda for subtraction
+    std::vector<int> vec = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+    for (auto v : iter::accumulate(vec, [](int a, int b){return a - b;})) {
+        std::cout << v << '\n';
+    }
+
+    // using a range instead of a vector
+    for (auto v : iter::accumulate(iter::range(10),
+                [](int a, int b){return a - b;})) {
+        std::cout << v << '\n';
+    }
+
+    // using a range and the default summing behavior
+    for (auto v : iter::accumulate(iter::range(10))) {
+        std::cout << v << '\n';
+    }
+
+
+    for (auto v : iter::accumulate({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})) {
+        std::cout << v << '\n';
+    }
+
+    for (auto v : iter::accumulate(std::vector<int>{1,2,3,4,5,6,7,8,9})) {
+        std::cout << v << '\n';
+    }
+
+    return 0;
+}
diff --git a/examples/testchain.cpp b/examples/testchain.cpp
new file mode 100644
index 00000000..19ab374d
--- /dev/null
+++ b/examples/testchain.cpp
@@ -0,0 +1,61 @@
+#include <chain.hpp>
+#include <range.hpp>
+
+#include <vector>
+#include <string>
+#include <iostream>
+#include <array>
+#include <initializer_list>
+
+using iter::chain;
+using il = std::initializer_list<int>; 
+
+int main() {
+
+    {
+        std::vector<int> ivec{1, 4, 7, 9};
+        std::vector<int> lvec{100, 200, 300, 400, 500, 600};
+
+        for (auto e : chain(ivec, lvec)) {
+            std::cout << e << std::endl;
+        }
+    }
+    {
+        std::vector<int> empty{};
+        std::vector<int> vec1{1,2,3,4,5,6};
+        std::array<int,4> arr1{{7,8,9,10}};
+        std::array<int,3> arr2{{11,12,13}};
+        std::cout << std::endl << "Chain iter test" << std::endl;
+        for (auto i : iter::chain(empty,vec1,arr1)) {
+            std::cout << i << std::endl;
+        }
+        std::cout<<std::endl;
+        for (auto i : iter::chain(vec1,empty,arr1)) {
+            std::cout << i << std::endl;
+        }
+        std::cout<<std::endl;
+        for (auto i : iter::chain(vec1,arr1,empty)) {
+            std::cout << i << std::endl;
+        }
+        std::cout<<std::endl;//modifying the range
+        for (auto & i : iter::chain(vec1,arr1,arr2)) {
+            i = 0;//0 out the whole thing
+        }
+        std::cout<<std::endl;
+        for (auto i : iter::chain(vec1,arr1,arr2)) {
+            std::cout << i << std::endl;
+        }
+        //test only works with perfect forwarding
+        std::cout<<std::endl;
+        for (auto i : chain(il{1,2,3,4,5},il{6,7,8,9},il{10,11,12})) {
+            std::cout << i << std::endl;
+        }
+
+        // test with temporaries
+        std::cout << '\n';
+        for (auto i : chain(std::vector<int>{1,2,3,4},
+                    std::array<int,4>{{5,6,7,8}})) {
+            std::cout << i << '\n';
+        }
+    }
+}
diff --git a/examples/testchainfromiterable.cpp b/examples/testchainfromiterable.cpp
new file mode 100644
index 00000000..f4b6d599
--- /dev/null
+++ b/examples/testchainfromiterable.cpp
@@ -0,0 +1,28 @@
+#include <chain.hpp>
+
+#include <iostream>
+#include <vector>
+
+using iter::chain;
+
+int main() {
+    std::vector<std::vector<int>> matrix = {
+        {1, 2, 3},
+        {4, 5},
+        {6, 8, 9, 10, 11, 12}
+    };
+    for (auto i : chain.from_iterable(matrix)) {
+        std::cout << i << '\n';
+    }
+
+    std::cout << "with temporary\n";
+    for (auto i : chain.from_iterable(std::vector<std::vector<int>>{
+                    {1, 2, 3},
+                    {4, 5},
+                    {6, 8, 9, 10, 11, 12}
+                })) {
+        std::cout << i << '\n';
+    }
+
+    return 0;
+}
diff --git a/examples/testcombinations.cpp b/examples/testcombinations.cpp
new file mode 100644
index 00000000..ee444b90
--- /dev/null
+++ b/examples/testcombinations.cpp
@@ -0,0 +1,75 @@
+#include "samples.hpp"
+#include <combinations.hpp>
+#include <range.hpp>
+
+#include <vector>
+#include <string>
+#include <iostream>
+#include <array>
+
+using iter::combinations;
+int main() {
+    itertest::DerefByValue dbv; 
+    std::vector<itertest::MoveOnly> mv;
+    for (auto i : iter::range(3)) {
+        mv.emplace_back(i);
+    }
+    std::vector<int> v = {1,2,3,4,5};
+
+    for (auto&& i : combinations(mv,2)) {
+        for (auto&& j : i ) std::cout << j << " ";
+        std::cout<<std::endl;
+    }
+
+    for (auto i : combinations(v,0)) {
+        for (auto j : i ) std::cout << j << " ";
+        std::cout<<std::endl;
+    }
+
+    for (auto i : combinations(v,3)) {
+        for (auto j : i ) std::cout << j << " ";
+        std::cout<<std::endl;
+    }
+
+    for (auto i : combinations(v,1)) {
+        for (auto j : i ) std::cout << j << " ";
+        std::cout<<std::endl;
+    }
+
+    for (auto i : combinations(v,5)) {
+        for (auto j : i ) std::cout << j << " ";
+        std::cout<<std::endl;
+    }
+
+    std::cout << "deref by value\n";
+    for (auto&& i : combinations(dbv, 2)) {
+        for (auto&& j : i) std::cout << j << " ";
+        std::cout << '\n';
+    }
+
+    std::cout << "initializer list\n";
+    for (auto i : combinations({1,2,3,4},3)) {
+        for (auto j : i ) std::cout << j << " ";
+        std::cout<<std::endl;
+
+    }
+
+    std::cout << "initializer list\n";
+    for (auto i : combinations({1,2,3,4},1)) {
+        for (auto j : i ) std::cout << j << " ";
+        std::cout<<std::endl;
+    }
+
+    std::cout << "temporary\n";
+    for (auto i : combinations(std::vector<int>{1,2,3,4,5}, 3)) {
+        for (auto j : i ) std::cout << j << " ";
+        std::cout<<std::endl;
+    }
+
+    std::cout << "static array\n";
+    int array[] = {1,2,3,4,5};
+    for (auto i : combinations(array, 3)) {
+        for (auto j : i) std::cout << j << " ";
+        std::cout << '\n';
+    }
+}
diff --git a/examples/testcombinations_with_replacement.cpp b/examples/testcombinations_with_replacement.cpp
new file mode 100644
index 00000000..78b8751e
--- /dev/null
+++ b/examples/testcombinations_with_replacement.cpp
@@ -0,0 +1,55 @@
+#include "samples.hpp"
+#include <combinations_with_replacement.hpp>
+#include <range.hpp>
+
+#include <vector>
+#include <string>
+#include <iostream>
+#include <array>
+
+using iter::combinations_with_replacement;
+
+int main() {
+    std::vector<itertest::MoveOnly> mv;
+    for (auto i : iter::range(3)) {
+        mv.emplace_back(i);
+    }
+
+    std::vector<int> v = {1,2,3,};
+    for (auto i : combinations_with_replacement(v,4)) {
+        for (auto j : i ) std::cout << j << " ";
+        std::cout<<std::endl;
+    }
+
+    itertest::DerefByValue dbv;
+    std::cout << "with deref by value iterator\n";
+    for (auto i : combinations_with_replacement(dbv, 2)) {
+        for (auto j : i ) std::cout << j << " ";
+        std::cout<<std::endl;
+    }
+
+    std::cout << "with container of move-only\n";
+    for (auto i : combinations_with_replacement(mv,2)) {
+        for (auto j : i ) std::cout << j << " ";
+        std::cout<<std::endl;
+    }
+
+    std::cout << "with temporary\n";
+    for (auto i : combinations_with_replacement(std::vector<int>{1,2,3},4)) {
+        for (auto j : i ) std::cout << j << " ";
+        std::cout<<std::endl;
+    }
+
+    std::cout << "with init list\n";
+    for (auto i : combinations_with_replacement({1,2,3},4)) {
+        for (auto j : i ) std::cout << j << " ";
+        std::cout<<std::endl;
+    }
+
+    std::cout << "with static array\n";
+    int arr[] = {1, 2, 3};
+    for (auto i : combinations_with_replacement(arr,4)) {
+        for (auto j : i ) std::cout << j << " ";
+        std::cout<<std::endl;
+    }
+}
diff --git a/examples/testcommand_chains.cpp b/examples/testcommand_chains.cpp
new file mode 100644
index 00000000..e116f131
--- /dev/null
+++ b/examples/testcommand_chains.cpp
@@ -0,0 +1,78 @@
+#include <itertools.hpp>
+
+#include <vector>
+#include <tuple>
+#include <array>
+#include <iostream>
+#include <string>
+
+using namespace iter;
+
+template <typename T>
+std::ostream & operator<<(std::ostream & out, const boost::optional<T>& opt) {
+    if (opt) {
+        out << "Just " << *opt;
+    } else {
+        out << "Nothing";
+    }
+    return out;
+}
+int main() {
+    {
+        std::vector<int> vec1{1,2,3,4,5,6};
+        std::vector<int> vec2{1,2,3,4,5};
+        std::vector<std::string> strvec
+        {"his","name","was","robert","paulson","his","name","was","robert","paulson"};
+        for (auto t : zip_longest(chain(vec1,vec2),strvec)) {
+            std::cout << std::get<0>(t) << " "
+                << std::get<1>(t) << std::endl;
+        }
+    }
+
+    std::string str = "hello world";
+    std::vector<int> vec = {6, 9, 6, 9};
+    for (auto p : enumerate(enumerate(str))) { (void)p; }
+    for (auto p : enumerate(zip(str, vec))) { (void)p; }
+
+    std::cout << std::endl;
+    {
+        std::vector<int> vec1{1,2,3,4,5,6};
+        std::vector<int> vec2{7,8,9,10};
+        std::vector<std::string> strvec
+        {"We're","done","when","I","say","we're","done"};
+        for (auto t : zip(strvec,chain(slice(vec1,2,6),slice(vec2,1,4)))) {
+            std::cout << std::get<0>(t) << " "
+                << std::get<1>(t) << std::endl;
+        }
+    }
+    std::cout << std::endl;
+    {
+        std::vector<int> vec1{1,2,3,4,5,6};
+        std::vector<int> vec2{7,8,9,10};
+        for (auto s : sliding_window(chain(vec1,vec2),4)) {
+            for (auto i : s) std::cout << i << " ";
+            std::cout<<std::endl;
+        }
+    }
+    std::cout << std::endl;
+
+#if 0
+    {
+        std::vector<int> vec1{1,2,3,4,5,6};
+        std::vector<int> vec2{7,8,9,10};
+        for (auto s : grouper(chain(vec1,vec2),3)) {
+            for (auto i : s) std::cout << i << " ";
+            std::cout<<std::endl;
+        }
+    }
+#endif
+    auto prod_range = iter::product(iter::range(10), iter::range(5));
+
+    for (auto&& ij: iter::filter(
+                [](std::tuple<unsigned, unsigned> const& c)
+                {return std::get<0>(c) >= std::get<1>(c);},
+                prod_range)) {
+                    std::cout << std::get<0>(ij) << "," << std::get<1>(ij) << std::endl;
+    }
+    return 0;
+}
diff --git a/examples/testcompress.cpp b/examples/testcompress.cpp
new file mode 100644
index 00000000..5197f3e2
--- /dev/null
+++ b/examples/testcompress.cpp
@@ -0,0 +1,67 @@
+#include <compress.hpp>
+#include <range.hpp>
+
+#include <vector>
+#include <iostream>
+
+using iter::compress;
+using iter::range;
+
+template <typename DataType, typename SelectorType>
+void testcase(std::vector<DataType> data_vec,
+        std::vector<SelectorType> sel_vec)
+{
+
+    for (auto e : compress(data_vec, sel_vec)) {
+        std::cout << e << '\n';
+    }
+}
+
+int main(void)
+{
+    std::vector<int> ivec{1, 2, 3, 4, 5, 6};
+    std::vector<bool> bvec{true, false, true, false, true, false};
+    std::cout << "Should print 1 3 5\n";
+    testcase(ivec, bvec);
+
+    std::vector<bool> bvec2{false, true, false, false, false, true};
+    std::cout << "Should print 2 6\n";
+    testcase(ivec, bvec2);
+
+    std::vector<bool> bvec3{false, true};
+    std::cout << "Should print 2\n";
+    testcase(ivec, bvec3);
+
+    std::cout << "Should print 0 2 4\n";
+    for (auto i : compress(range(10), bvec)) {
+        std::cout << i << '\n';
+    }
+    
+    std::cout << "Should print 0 2 4\n";
+    for (auto i : compress({0,1,2,3,4,5}, bvec)) {
+        std::cout << i << '\n';
+    }
+
+    std::cout << "Should print 0 2 4\n";
+    for (auto i : compress(range(10), {true, false, true, false, true})) {
+        std::cout << i << '\n';
+    }
+
+    std::cout << "Should print 0 2 4\n";
+    for (auto i : compress({0, 1, 2, 3, 4, 5},
+                {true, false, true, false, true}))
+    {
+        std::cout << i << '\n';
+    }
+
+    std::cout << "Should print 0 2 4\n";
+    for (auto i : compress(std::vector<int>{0, 1, 2, 3, 4, 5},
+                std::vector<bool>{true, false, true, false, true}))
+    {
+        std::cout << i << '\n';
+    }
+
+        
+
+    return 0;
+}
diff --git a/examples/testcount.cpp b/examples/testcount.cpp
new file mode 100644
index 00000000..946d6841
--- /dev/null
+++ b/examples/testcount.cpp
@@ -0,0 +1,38 @@
+#include <count.hpp>
+
+#include <iostream>
+
+using iter::count;
+
+int main() {
+    for (auto i : count()) {
+        std::cout << i << '\n';
+        if (i == 100) {
+            break;
+        }
+    }
+
+    for (auto i : count(5.0, 0.5)){
+        std::cout << i << '\n';
+        if (i > 100) {
+            break;
+        }
+    }
+
+    for (auto i : count(0, -1)) {
+        std::cout << i << '\n';
+        if (i < -100) {
+            break;
+        }
+    }
+
+    for (auto i : count()) {
+        std::cout << i << '\n';
+        if (i > 10000) {
+            break;
+        }
+    }
+
+
+    return 0;
+}
diff --git a/examples/testcycle.cpp b/examples/testcycle.cpp
new file mode 100644
index 00000000..138692cc
--- /dev/null
+++ b/examples/testcycle.cpp
@@ -0,0 +1,70 @@
+#include <cycle.hpp>
+#include <range.hpp>
+
+#include <vector>
+#include <iostream>
+
+using iter::cycle;
+using iter::range;
+
+int main() {
+    std::vector<int> vec = {2, 4, 6};
+
+    size_t count = 0;
+    for (auto i : cycle(vec)) {
+        std::cout << i << '\n';
+        if (count == 100) {
+            break;
+        }
+        ++count;
+    }
+
+    count = 0;
+    int array[] = {68, 69, 70};
+    for (auto i : cycle(array)) {
+        std::cout << i << '\n';
+        if (count == 20) {
+            break;
+        }
+        ++count;
+    }
+
+    count = 0;
+    for (auto i : cycle({7, 8, 9})) {
+        std::cout << i << '\n';
+        if (count == 20) {
+            break;
+        }
+        ++count;
+    }
+
+    count = 0;
+    for (auto i : cycle(range(3))) {
+        std::cout << i << '\n';
+        if (count == 20) {
+            break;
+        }
+        ++count;
+    }
+
+    count = 0;
+    const std::string s("hello");
+    for (auto c : cycle(s)) {
+        std::cout << c << '\n';
+        if (count == 20) {
+            break;
+        }
+        ++count;
+    }
+
+    count = 0;
+    for (auto i : std::vector<int>{1,2,3,4,5}) {
+        std::cout << i << '\n';
+        if (count == 20) {
+            break;
+        }
+        ++count;
+    }
+
+    return 0;
+}
diff --git a/examples/testdropwhile.cpp b/examples/testdropwhile.cpp
new file mode 100644
index 00000000..3140f81a
--- /dev/null
+++ b/examples/testdropwhile.cpp
@@ -0,0 +1,35 @@
+#include <dropwhile.hpp>
+#include <range.hpp>
+
+#include <vector>
+#include <iostream>
+#include <cassert>
+
+using iter::dropwhile;
+using iter::range;
+
+int main() {
+    std::vector<int> ivec{1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4};
+    for (auto& i : dropwhile([] (int i) {return i < 5;}, ivec)) {
+        std::cout << i << '\n';
+        i = 69;
+    }
+    assert(ivec.at(0) == 1);
+    assert(ivec.at(4) == 69);
+
+    for (auto i : dropwhile([] (int i) {return i < 5;}, range(10))) {
+        std::cout << i << '\n';
+    }
+
+    for (auto i : dropwhile([] (int i) {return i < 5;}, 
+                {1, 2, 3, 4, 5, 6, 7, 8, 9})) {
+        std::cout << i << '\n';
+    }
+
+    for (auto i : dropwhile([] (int i) {return i < 5;}, 
+                std::vector<int>{1, 2, 3, 4, 5, 6, 7, 8, 9})) {
+        std::cout << i << '\n';
+    }
+
+    return 0;
+}
diff --git a/examples/testenumerate.cpp b/examples/testenumerate.cpp
new file mode 100644
index 00000000..fcc1745c
--- /dev/null
+++ b/examples/testenumerate.cpp
@@ -0,0 +1,60 @@
+#include <enumerate.hpp>
+#include <range.hpp>
+
+#include <string>
+#include <iostream>
+#include <vector>
+
+using iter::enumerate;
+using iter::range;
+
+int main() {
+    std::cout << "const std::string\n";
+    const std::string const_string("goodbye world");
+    for (auto e : enumerate(const_string)) {
+        std::cout << e.index << ": " << e.element << std::endl;
+    }
+
+
+    std::vector<int> vec;
+    for(int i = 0; i < 12; ++i) { 
+        vec.push_back(i * i);
+    }
+
+
+    std::cout << "print vector element, set it to zero, then print it again\n";
+    for (auto e : enumerate(vec)) { 
+        std::cout << e.index << ": " << e.element << std::endl;
+        e.element = 0;
+        // tests to make sure vector can be edited
+        std::cout << e.index << ": " << e.element << std::endl;
+    }
+
+    std::cout << "static array\n";
+    int array[] = {1, 9, 8, 11};
+    for (auto e : enumerate(array)) {
+        std::cout << e.index << ": " << e.element << '\n';
+    }
+
+    std::cout << "initializer list\n";
+    for (auto e : enumerate({0, 1, 4, 9, 16, 25})) {
+        std::cout << e.index << "^2 = " << e.element << '\n';
+    }
+
+    std::cout << "range(10, 20, 2)\n";
+    for (auto e : enumerate(range(10, 20, 2))) {
+        std::cout << e.index << ": " << e.element << '\n';
+    }
+
+    std::cout << "range(10, 20, 2)\n";
+    for (auto e : enumerate(enumerate(range(10, 20, 2)))) {
+        std::cout << e.index << ": " << e.element.element << '\n';
+    }
+
+    std::cout << "vector temporary\n";
+    for (auto e : enumerate(std::vector<int>(5,2))) {
+        std::cout << e.index << ": " << e.element << '\n';
+    }
+
+    return 0;
+}
diff --git a/examples/testfilter.cpp b/examples/testfilter.cpp
new file mode 100644
index 00000000..e8af2aab
--- /dev/null
+++ b/examples/testfilter.cpp
@@ -0,0 +1,83 @@
+#include <filter.hpp>
+#include <range.hpp>
+
+#include <vector>
+#include <iostream>
+
+using iter::filter;
+
+bool greater_than_four(int i) {
+    return i > 4;
+}
+
+class LessThanValue {
+    private:
+        int compare_val;
+
+    public:
+        LessThanValue() = delete;
+        LessThanValue(int v) : compare_val(v) { }
+        
+        bool operator() (int i) {
+            return i < this->compare_val;
+        }
+};
+
+
+int main() {
+    std::vector<int> vec{1, 5, 6, 7, 2, 3, 8, 3, 2, 1};
+
+    std::cout << "Greater than 4 (function pointer)\n";
+    for (auto i : filter(greater_than_four, vec)) {
+        std::cout << i << '\n';
+    }
+
+    std::cout << "Less than 4 (lambda)\n";
+    for (auto i : filter([] (const int i) { return i < 4; }, vec)) {
+        std::cout << i << '\n';
+    }
+
+    LessThanValue lv(4);
+    std::cout << "Less than 4 (callable object)\n";
+    for (auto i : filter(lv, vec)) {
+        std::cout << i << '\n';
+    }
+
+    std::cout << "Nonzero ints filter(vec2)\n";
+    std::vector<int> vec2 {0, 1, 2, 0, 3, 0, 0, 0, 4, 5, 0};
+    for (auto i : filter(vec2)) {
+        std::cout << i << '\n';
+    }
+
+    std::cout << "odd numbers in range(10) temp\n";
+    for (auto i : filter([] (const int i) {return i % 2;}, iter::range(10))) {
+        std::cout << i << '\n';
+    }
+
+    std::cout << "range(-1, 2)\n";
+    for (auto i : filter(iter::range(-1, 2))) {
+        std::cout << i << '\n';
+    }
+
+
+    std::cout << "ever numbers in initializer_list\n";
+    for (auto i : filter([] (const int i) {return i % 2 == 0;},
+                         {1, 2, 3, 4, 5, 6, 7}))
+    {
+        std::cout << i << '\n';
+    }
+
+    std::cout << "default in initialization_list\n";
+    for (auto i : filter({-2, -1, 0, 0, 0, 1, 2})) {
+        std::cout << i << '\n';
+    }
+
+    std::cout << "ever numbers in vector temporary\n";
+    for (auto i : filter([] (const int i) {return i % 2 == 0;},
+                         std::vector<int>{1, 2, 3, 4, 5, 6, 7}))
+    {
+        std::cout << i << '\n';
+    }
+
+    return 0;
+}
diff --git a/examples/testfilterfalse.cpp b/examples/testfilterfalse.cpp
new file mode 100644
index 00000000..9063d0bf
--- /dev/null
+++ b/examples/testfilterfalse.cpp
@@ -0,0 +1,93 @@
+#include <filterfalse.hpp>
+#include <range.hpp>    
+
+#include <vector>
+#include <iostream>
+
+using iter::filterfalse;
+using iter::range;
+
+bool greater_than_four(int i) {
+    return i > 4;
+}
+
+class LessThanValue {
+    private:
+        int compare_val;
+
+    public:
+        LessThanValue() = delete;
+        LessThanValue(int v) : compare_val(v) { }
+        
+        bool operator() (int i) const {
+            return i < this->compare_val;
+        }
+};
+
+
+int main() {
+    std::vector<int> vec{1, 5, 6, 7, 2, 3, 8, 3, 2, 1};
+
+    std::cout << "Greater than 4 (function pointer)\n";
+    for (auto i : filterfalse(greater_than_four, vec)) {
+        std::cout << i << '\n';
+    }
+
+    std::cout << "Less than 4 (lambda)\n";
+    for (auto i : filterfalse([] (const int i) { return i < 4; }, vec)) {
+        std::cout << i << '\n';
+    }
+
+    LessThanValue lv(4);
+    std::cout << "Less than 4 (callable object)\n";
+    for (auto i : filterfalse(lv, vec)) {
+        std::cout << i << '\n';
+    }
+
+    std::cout << "zero ints filter(vec2)\n";
+    std::vector<int> vec2 {0, 1, 2, 0, 3, 0, 0, 0, 4, 5, 0};
+    for (auto i : filterfalse(vec2)) {
+        std::cout << i << '\n';
+    }
+
+    std::cout << "Constness tests\n";
+    const std::vector<int> cvec(vec);
+    for (auto i : filterfalse(greater_than_four, cvec)) {
+        std::cout << i << '\n';
+    }
+
+    for (auto i : filterfalse([] (const int & i) { return i < 4; }, cvec)) {
+        std::cout << i << '\n';
+    }
+
+
+    std::cout << "i%2 with range(10), should print even numbers\n";
+    for (auto i : filterfalse([] (const int i) { return i % 2; }, range(10))) {
+        std::cout << i << '\n';
+    }
+
+    std::cout << "range(-1, 2)\n";
+    for (auto i : filterfalse(range(-1, 2))) {
+        std::cout << i << '\n';
+    }
+
+    std::cout << "initializer_list\n";
+    for (auto i : filterfalse([] (const int i) { return  i % 2; },
+                {10, 11, 12, 13, 14, 15, 16}))
+    {
+        std::cout << i << '\n';
+    }
+
+    std::cout << "initializer_list with default\n";
+    for (auto i : filterfalse({-1, -2, 0, 0, 0, 0, 1, 2, 3})) {
+        std::cout << i << '\n';
+    }
+
+    std::cout << "vector temporary with default\n";
+    for (auto i : filterfalse(
+                std::vector<int>{-1, -2, 0, 0, 0, 0, 1, 2, 3})) {
+        std::cout << i << '\n';
+    }
+
+    return 0;
+}
diff --git a/examples/testgroupby.cpp b/examples/testgroupby.cpp
new file mode 100644
index 00000000..9fc03ee3
--- /dev/null
+++ b/examples/testgroupby.cpp
@@ -0,0 +1,109 @@
+#include <groupby.hpp>
+
+#include <vector>
+#include <iostream>
+#include <string>
+
+using iter::groupby;
+
+
+int length(std::string s)
+{
+    return s.length();
+}
+
+int main()
+{
+    std::vector<std::string> vec = {
+        "hi", "ab", "ho",
+        "abc", "def",
+        "abcde", "efghi"
+    };
+
+    for (auto gb : groupby(vec, &length)) {
+        std::cout << "key: " << gb.first << '\n';
+        std::cout << "content: ";
+        for (auto s : gb.second) {
+            std::cout << s << "  ";
+        }
+        std::cout << '\n';
+    }
+
+    for (auto gb : groupby(vec, [] (const std::string &s) {return s.length(); })) {
+        std::cout << "key: " << gb.first << '\n';
+        std::cout << "content: ";
+        for (auto s : gb.second) {
+            std::cout << s << "  ";
+        }
+        std::cout << '\n';
+    }
+
+    std::cout << "skipping length of 3\n";
+    for (auto gb : groupby(vec, &length)) {
+        if (gb.first == 3) {
+            continue;
+        }
+        std::cout << "key: " << gb.first << '\n';
+        std::cout << "content: ";
+        for (auto s : gb.second) {
+            std::cout << s << "  ";
+        }
+        std::cout << '\n';
+    }
+   
+
+    std::vector<int> ivec = {5, 5, 6, 6, 19, 19, 19, 19, 69, 0, 10, 10};
+    for (auto gb : groupby(ivec)) {
+        std::cout << "key: " << gb.first << '\n';
+        std::cout << "content: ";
+        for (auto s : gb.second) {
+            std::cout << s << "  ";
+        }
+        std::cout << '\n';
+    }
+
+    for (auto gb : groupby("aabbccccdd", [] (const char c) {return c < 'c';})){
+        std::cout << "key: " << gb.first << '\n';
+        std::cout << "content: ";
+        for (auto s : gb.second) {
+            std::cout << s << "  ";
+        }
+        std::cout << '\n';
+    }
+    
+    for (auto gb : groupby({'a', 'a', 'b', 'b', 'c'})) {
+        std::cout << "key: " << gb.first << '\n';
+        std::cout << "content: ";
+        for (auto s : gb.second) {
+            std::cout << s << "  ";
+        }
+        std::cout << '\n';
+    }
+
+    for (auto gb : groupby({'a', 'a', 'b', 'b', 'c', 'c', 'd', 'd'},
+                [] (const char c) {return c < 'c'; })) {
+        std::cout << "key: " << gb.first << '\n';
+        std::cout << "content: ";
+        for (auto s : gb.second) {
+            std::cout << s << "  ";
+        }
+        std::cout << '\n';
+    }
+
+    std::cout << "with vector temporary:\n";
+    for (auto gb : groupby(
+                std::vector<char>{'a', 'a', 'b', 'b', 'c', 'c', 'd', 'd'},
+                [] (const char c) {return c < 'c'; })) {
+        std::cout << "key: " << gb.first << '\n';
+        std::cout << "content: ";
+        for (auto s : gb.second) {
+            std::cout << s << "  ";
+        }
+        std::cout << '\n';
+    }
+        
+
+    return 0;
+}
+
+    
diff --git a/examples/testgrouper.cpp b/examples/testgrouper.cpp
new file mode 100644
index 00000000..b16ebc98
--- /dev/null
+++ b/examples/testgrouper.cpp
@@ -0,0 +1,51 @@
+#include "grouper.hpp"
+#include <iostream>
+#include <vector>
+using iter::grouper;
+int main() {
+    std::vector<int> v {1,2,3,4,5,6,7,8,9}; 
+    for (auto sec : grouper(v,4)) {
+        for (auto i : sec) {
+            std::cout << i << " ";
+            i.get() *= 2;
+        }
+        std::cout << '\n';
+    }
+
+    for (auto sec : grouper(std::vector<int>{1,2,3,4,5,6,7,8,9}, 4)) {
+        for (auto i : sec) {
+            std::cout << i << " ";
+            i.get() *= 2;
+        }
+        std::cout << '\n';
+    }
+
+    for (auto sec : grouper(v,3)) {
+        for (auto i : sec) {
+            std::cout << i << " ";
+        }
+        std::cout << '\n';
+    }
+    std::vector<int> empty {};
+    for (auto sec : grouper(empty,3)) {
+        std::cout << "Shouldn't print\n";
+        for (auto i : sec) {
+            std::cout << i << " Shouldn't print\n";
+        }
+    }
+
+    int arr[] = {1,2,3,4,5,6,7};
+    for (auto sec : grouper(arr, 2)) {
+        for (auto i : sec) {
+            std::cout << i << ' ';
+        }
+        std::cout << '\n';
+    }
+
+    for (auto sec : grouper({1,2,3,4,5,6,7}, 2)) {
+        for (auto i : sec) {
+            std::cout << i << ' ';
+        }
+        std::cout << '\n';
+    }
+}
diff --git a/examples/testimap.cpp b/examples/testimap.cpp
new file mode 100644
index 00000000..3d6f38ca
--- /dev/null
+++ b/examples/testimap.cpp
@@ -0,0 +1,45 @@
+#include <imap.hpp>
+#include <range.hpp>
+
+#include <vector>
+#include <iostream>
+
+using iter::imap;
+
+int main() {
+    std::vector<int> vec1 = {1, 2, 3, 4, 5, 6};
+    std::vector<int> vec2 = {10, 20, 30, 40, 50, 60};
+    for (auto i : imap([] (int x, int y) { return x + y; }, vec1, vec2)) {
+        std::cout << i << '\n';
+    }
+
+    std::vector<int> vec3 = {100, 200, 300, 400, 500, 600};
+    for (auto i : imap([] (int a, int b, int c) { return a + b + c; }, 
+                vec1, vec2, vec3)) {
+        std::cout << i << '\n';
+    }
+
+    for (auto i : imap([] (int i) {return i * i; }, vec1)) {
+        std::cout << i << '\n';
+    }
+
+    std::vector<int> vec{1, 2, 3, 4, 5};
+    for (auto i : imap([] (int x) {return x * x;}, vec)) {
+        std::cout << i << '\n';
+    }
+
+    std::vector<int> vec4{1, 2, 3};
+    for (auto i : imap([] (int a, int b) { return a + b; }, vec, vec4)) {
+        std::cout << i << '\n';
+    }
+
+    for (auto i : imap([] (const int x) { return x*x; }, iter::range(10))) {
+        std::cout << i << '\n';
+    }
+
+    for (auto i : imap([] (const int x) { return x*x; },
+                       std::vector<int>{1,2,3,4,5})){
+        std::cout << i << '\n';
+    }
+    return 0;
+}
diff --git a/examples/testpermutations.cpp b/examples/testpermutations.cpp
new file mode 100644
index 00000000..a73a2a3b
--- /dev/null
+++ b/examples/testpermutations.cpp
@@ -0,0 +1,60 @@
+#include "samples.hpp"
+
+#include <permutations.hpp>
+#include <range.hpp>
+
+#include <iostream>
+#include <vector>
+#include <string>
+
+int main() {
+    using iter::permutations;
+    std::vector<int> v = {1,2,3};
+    for (auto vec : permutations(v)) {
+        for (auto i : vec) {
+            std::cout << i << " ";
+        }
+        std::cout << std::endl;
+    }
+    //try with string
+    std::string s = "aba";
+    for (auto vec : permutations(s)) {
+        for (auto c : vec) {
+            std::cout << c << " ";
+        }
+        std::cout << std::endl;
+    }
+    s = "abc";
+    for (auto vec : permutations(s)) {
+        for (auto c : vec) {
+            std::cout << c << " ";
+        }
+        std::cout << std::endl;
+    }
+
+    std::cout << "init list\n";
+    //std::next_permutation doesn't work on initializer_lists
+    for (auto vec : permutations({1,2,3,4})) {
+        for (auto c : vec) {
+            std::cout << c << " ";
+        }
+        std::cout << std::endl;
+    }
+
+    std::cout << "with container of move-only objects\n";
+    std::vector<itertest::MoveOnly> mv;
+    for (auto i : iter::range(3)) {
+        mv.emplace_back(i);
+    }
+    for (auto v : permutations(mv)) {
+        for (auto i : v) std::cout << i << " ";
+        std::cout << std::endl;
+    }
+
+    std::cout << "with deref-by-value iterator\n";
+    itertest::DerefByValue dbv;
+    for (auto v : permutations(dbv)) {
+        for (auto i : v) std::cout << i << " ";
+        std::cout << std::endl;
+    }
+}
diff --git a/examples/testpowerset.cpp b/examples/testpowerset.cpp
new file mode 100644
index 00000000..20ca0098
--- /dev/null
+++ b/examples/testpowerset.cpp
@@ -0,0 +1,44 @@
+#include "samples.hpp"
+#include <powerset.hpp>
+#include <range.hpp>
+#include <vector>
+#include <iostream>
+
+using iter::powerset;
+
+int main() {
+    std::vector<int> vec {1,2,3,4,5,6,7,8,9};
+    for (auto v : powerset(vec)) {
+        for (auto i : v) std::cout << i << " ";
+        std::cout << std::endl;
+    }
+    std::cout << "with temporary\n";
+    for (auto v : powerset(std::vector<int>{1,2,3})) {
+        for (auto i : v) std::cout << i << " ";
+        std::cout << std::endl;
+    }
+    std::cout << "with initializer_list\n";
+    for (auto v : powerset({1,2,3})) {
+        for (auto i : v) std::cout << i << " ";
+        std::cout << std::endl;
+    }
+
+    std::cout << "with container of move-only objects\n";
+    std::vector<itertest::MoveOnly> mv;
+    for (auto i : iter::range(3)) {
+        mv.emplace_back(i);
+    }
+    for (auto v : powerset(mv)) {
+        for (auto i : v) std::cout << i << " ";
+        std::cout << std::endl;
+    }
+
+    std::cout << "with deref-by-value iterator\n";
+    itertest::DerefByValue dbv;
+    for (auto v : powerset(dbv)) {
+        for (auto i : v) std::cout << i << " ";
+        std::cout << std::endl;
+    }
+
+    return 0;
+}
diff --git a/examples/testproduct.cpp b/examples/testproduct.cpp
new file mode 100644
index 00000000..22d132ec
--- /dev/null
+++ b/examples/testproduct.cpp
@@ -0,0 +1,77 @@
+#include "samples.hpp"
+
+#include <product.hpp>
+#include <range.hpp>
+
+#include <vector>
+#include <iostream>
+#include <string>
+
+using iter::product;
+int main() {
+
+    std::vector<itertest::MoveOnly> mv;
+    for (auto i : iter::range(10)) {
+        mv.emplace_back(i);
+    }
+    std::vector<int> empty{};
+    std::vector<int> v1{1,2,3};
+    std::vector<int> v2{7,8};
+    std::vector<std::string> v3{"the","cat"};
+    std::vector<std::string> v4{"hi","what","up","dude"};
+
+    for (auto t : product(v1, mv)) {
+        std::cout << std::get<0>(t) << ", "
+            << std::get<1>(t) << std::endl;
+    }
+    for (auto t : product(empty,v1)) {
+        std::cout << std::get<0>(t) << ", "
+            << std::get<1>(t) << std::endl;
+    }
+    for (auto t : product(v1,empty)) {
+        std::cout << std::get<0>(t) << ", "
+            << std::get<1>(t) << std::endl;
+    }
+    std::cout<<std::endl;
+    for (auto t : product(v1,v2)) {
+        std::cout << std::get<0>(t) << ", "
+            << std::get<1>(t) << std::endl;
+    }
+    std::cout<<std::endl;
+    for (auto t : product(v1,v2,v3,v4)) {
+        std::cout << std::get<0>(t) << ", "
+            << std::get<1>(t) << ", "
+            << std::get<2>(t) << ", " 
+            << std::get<3>(t) << std::endl;
+    }
+    std::cout<<std::endl;
+    for (auto t : product(v1)) {
+        std::cout << std::get<0>(t)  << std::endl;
+    }
+    std::cout<<std::endl;
+    for (auto t : product(v1,v4)) {
+        std::cout << std::get<0>(t) << ", "
+          << std::get<1>(t)  << std::endl;
+    }
+    std::cout << '\n';
+
+    for (auto t : product()) { t=t; }
+
+    for (auto t : product(std::string{"hi"}, v1)) {
+        std::cout << std::get<0>(t) << ", "
+            << std::get<1>(t) << std::endl;
+    }
+    std::cout << '\n';
+
+    int arr[] = {1,2};
+    for (auto t : product(std::string{"hi"}, arr)) {
+        std::cout << std::get<0>(t) << ", "
+            << std::get<1>(t) << std::endl;
+    }
+    std::cout << '\n';
+    for (auto&& ij: iter::product(iter::range(10), iter::range(5))) {
+        std::cout << std::get<0>(ij) << "," << std::get<1>(ij) << std::endl;
+    }
+
+    return 0;
+}
diff --git a/examples/testrange.cpp b/examples/testrange.cpp
new file mode 100644
index 00000000..9404ae57
--- /dev/null
+++ b/examples/testrange.cpp
@@ -0,0 +1,83 @@
+#include <range.hpp>
+
+#include <iostream>
+
+using iter::range;
+
+int main()
+{
+    for (auto i : range(10)) {
+        std::cout << i << std::endl;
+    }
+    for (auto i : range(20, 30)) {
+        std::cout << i << std::endl;
+    }
+    for (auto i : range(50, 60, 2)) {
+        std::cout << i << std::endl;
+    }
+
+    std::cout << "Negative Tests\n";
+    for (auto i: range(-10, 0)) {
+        std::cout << i << std::endl;
+    }
+
+    for (auto i : range(-10, 10, 2)) {
+        std::cout << i << std::endl;
+    }
+
+    std::cout << "Tests where (stop - start)%step != 0" << std::endl;
+    for (auto i : range(1, 10, 2)) {
+        std::cout << i << std::endl;
+    }
+
+    for (auto i : range(-1, -10, -2)) {
+        std::cout << i << std::endl;
+    }
+    
+    std::cout << "Tests with different types" << std::endl;
+    for(auto i : range(5.0, 10.0, 0.5)) {
+        std::cout << i << std::endl;
+    }
+	std::cout << "test unsigned" << std::endl;
+	std::cout << "empty range: " << std::endl;
+	size_t len = 0;
+	for(auto i : range(len)){
+	  std::cout << i << std::endl;
+	}
+	std::cout << "stop only" << std::endl;
+	len = 3;
+	for(auto i : range(len)){
+	  std::cout << i << std::endl;
+	}
+	std::cout << "start stop" << std::endl;
+	size_t start = 1;
+	for(auto i : range(start, len)){
+	  std::cout << i << std::endl;
+	}
+
+	std::cout << "start stop skip" << std::endl;
+	len = 10;
+	size_t skip = 3;
+	for(auto i : range(start, len, skip)){
+	  std::cout << i << std::endl;
+	}
+	
+
+
+    // invalid ranges:
+    std::cout << "Should not print anything after this line until exception\n";
+    for (auto i : range(-10, 0, -1)) {
+        std::cout << i << std::endl;
+    }
+
+    for (auto i : range(0, 1, -1)) {
+        std::cout << i << std::endl;
+    }
+
+    std::cout << "Should see exception now\n";
+    for (auto i : range(0, 10, 0) ) {
+        std::cout << i << std::endl;
+    }
+
+    return 0;
+}
diff --git a/examples/testrepeat.cpp b/examples/testrepeat.cpp
new file mode 100644
index 00000000..b91fba03
--- /dev/null
+++ b/examples/testrepeat.cpp
@@ -0,0 +1,31 @@
+#include "repeat.hpp"
+#include <iostream>
+#include <vector>
+#include <array>
+#include <string>
+#include <memory>
+
+int main () {
+    int a = 10;
+    int i = 0;
+    for (auto num : iter::repeat(a)) {//goes infintely
+        std::cout << num << std::endl;
+        ++i;
+        if (i > 20) break;
+    }
+    std::cout<<std::endl;
+    for (auto num : iter::repeat(a,10)) {//goes ten times
+        std::cout << num << std::endl;
+    }
+    
+    std::cout << "with temporary\n";
+    for (auto s : iter::repeat(std::string{"hey"}, 2)) {
+        std::cout <<  s << '\n';
+    }
+
+    std::cout << "with uptr temporary\n";
+    for (auto& p : iter::repeat(std::unique_ptr<int>{new int{2}}, 2)) {
+        std::cout << *p << '\n';
+    }
+
+}
diff --git a/examples/testreversed.cpp b/examples/testreversed.cpp
new file mode 100644
index 00000000..c6d0ab46
--- /dev/null
+++ b/examples/testreversed.cpp
@@ -0,0 +1,43 @@
+#include <reversed.hpp>
+
+#include <iostream>
+#include <vector>
+#include <array>
+#include <string>
+
+int main () {
+    std::vector<int> a{1,2,3,4,5,6,7};
+    std::vector<std::string> b{"hey","how","are","you","doing"};
+    std::cout << std::endl << "reversed range test" << std::endl << std::endl;
+    for (auto i : iter::reversed(a)) {
+        std::cout << i << std::endl;
+    }
+    std::cout<<std::endl;
+    //modify a
+    for (auto & i : iter::reversed(a)) {
+        std::cout << i << std::endl;
+        i = 9;
+    }
+    std::cout<<std::endl;
+    for (auto i : iter::reversed(a)) {
+        std::cout << i << std::endl;
+    }
+    std::cout<<std::endl;
+    //try strings
+    for (auto s : iter::reversed(b)) {
+        std::cout << s << std::endl;
+    }
+
+    std::cout << "with temporary\n";
+    for (auto i : iter::reversed(std::vector<int>{1, 2, 3, 4, 5, 6, 7})) {
+        std::cout << i << '\n';
+    }
+
+    std::cout << "statically sized array\n";
+    int arr[] = {1, 2, 3, 4, 5, 6, 7};
+    for (auto i : iter::reversed(arr)) {
+        std::cout << i << '\n';
+    }
+
+
+}
diff --git a/examples/testslice.cpp b/examples/testslice.cpp
new file mode 100644
index 00000000..eaf8e1ce
--- /dev/null
+++ b/examples/testslice.cpp
@@ -0,0 +1,81 @@
+#include <iostream>
+
+#include <slice.hpp>
+#include <range.hpp>
+
+#include <vector>
+#include <array>
+
+int main() {
+    std::cout << std::endl << "Slice range test" << std::endl << std::endl;
+    std::vector<int> a{0,1,2,3,4,5,6,7,8,9,10,11,12,13};
+    std::vector<std::string> b{"hey","how","are","you","doing"};
+
+    std::cout << "step out of slice\n";
+    for (auto i : iter::slice(a, 1, 4, 5)) {
+        std::cout << i << '\n';
+    }
+    std::cout << "end step out\n";
+
+    for (auto i : iter::slice(a,2)) {
+        std::cout << i << std::endl;
+    }
+    std::cout<<std::endl;
+    for (auto & s : iter::slice(b,3,4)) {
+        std::cout << s << std::endl;
+        s = "test";
+    }
+    std::cout<<std::endl;
+    for (auto s : b) {
+        std::cout << s << std::endl;
+    }
+    std::cout<<std::endl;
+    for (auto i : iter::slice(a,0,15,3)) {
+        std::cout << i << std::endl;
+    }
+
+    std::cout<< "\n13 down to 0\n";
+    for (auto i : iter::slice(a,13,-1,-1)) {
+        std::cout << i << std::endl;
+    }
+
+    std::cout<< "\nunevent step [0:5:3]\n";
+    for (auto i : iter::slice(a, 0, 5, 3)) {
+        std::cout << i << '\n';
+    }
+
+    std::cout<< "\nInvalid range [1:10:-1]\n";
+    for (auto i : iter::slice(a,1,10,-1)) {
+        //invalid range returns two begin iters
+        std::cout << i << std::endl;
+    }
+    std::cout<< "\nOversize range [1:100:1]\n";
+    for (auto i : iter::slice(a,1,100,1)) {
+        //invalid range returns two begin iters
+        std::cout << i << std::endl;
+    }
+    std::cout<< "\nOversize range and undersize[1:100:1]\n";
+    for (auto i : iter::slice(a,-100,100,1)) {
+        //invalid range returns two begin iters
+        std::cout << i << std::endl;
+    }
+
+    std::cout<< "\nstatic array[1:8:2]\n";
+    int arr[10] = {0,1,2,3,4,5,6,7,8,9};
+    for (auto i : iter::slice(arr,1,8,2)) {
+        //invalid range returns two begin iters
+        std::cout << i << std::endl;
+    }
+
+    std::cout << "\ninitializer list\n";
+    for (auto i : iter::slice({1, 2, 4, 8, 16, 32, 64, 128}, 2, 6)) {
+        std::cout << i << '\n';
+    }
+
+    std::cout << "\nvector temporary\n";
+    for (auto i : iter::slice(
+                std::vector<int>{1, 2, 4, 8, 16, 32, 64, 128}, 2, 6)) {
+        std::cout << i << '\n';
+    }
+
+}
diff --git a/examples/testsliding_window.cpp b/examples/testsliding_window.cpp
new file mode 100644
index 00000000..16708db7
--- /dev/null
+++ b/examples/testsliding_window.cpp
@@ -0,0 +1,53 @@
+#include "sliding_window.hpp"
+
+#include <iostream>
+#include <vector>
+
+using iter::sliding_window;
+
+int main() {
+    std::vector<int> v = {1,2,3,4,5,6,7,8,9}; 
+    for (auto sec : sliding_window(v,4)) {
+        for (auto i : sec) {
+            std::cout << i << " ";
+            i.get() = 90;
+        }
+        std::cout << std::endl;
+    }
+
+    std::cout << "with temporary\n";
+    for (auto sec : sliding_window(std::vector<int>{1,2,3,4,5,6,7,8,9}, 4)) {
+        for (auto i : sec) {
+            std::cout << i << " ";
+            i.get() = 90;
+        }
+        std::cout << std::endl;
+    }
+
+    std::cout << "with init list\n";
+    for (auto sec : sliding_window({1,2,3,4,5,6,7,8,9}, 4)) {
+        for (auto i : sec) {
+            std::cout << i << " ";
+        }
+        std::cout << std::endl;
+    }
+
+    std::cout << "with window_size > length\n";
+    for (auto sec : sliding_window({1,2,3}, 10)) {
+        for (auto i : sec) {
+            std::cout << i << " ";
+        }
+        std::cout << std::endl;
+    }
+
+    std::cout << "with static array\n";
+    int arr[] = {1,2,3,4,5,6,7,8,9};
+    for (auto sec : sliding_window(arr, 4)) {
+        for (auto i : sec) {
+            std::cout << i << " ";
+        }
+        std::cout << std::endl;
+    }
+
+    return 0;
+}
diff --git a/examples/testsorted.cpp b/examples/testsorted.cpp
new file mode 100644
index 00000000..aed57d32
--- /dev/null
+++ b/examples/testsorted.cpp
@@ -0,0 +1,36 @@
+#include <sorted.hpp>
+
+#include <iostream>
+#include <vector>
+#include <string>
+
+using iter::sorted;
+
+int main()
+{
+    std::vector<int> vec = {19, 45, 32, 10, 0, 90, 15, 1, 7, 5, 6, 69};
+    for (auto i : sorted(vec)) {
+        std::cout << i << '\n';
+    }
+
+    const std::vector<int> cvec(vec);
+    for (auto i : sorted(cvec)) {
+        std::cout << i << '\n';
+    }
+
+    std::cout << "Sort by first character only\n";
+    std::vector<std::string> svec = {"hello", "everyone", "thanks", "for",
+                                     "having", "me", "here", "today"};
+    for (auto s : sorted(svec,
+                [] (const std::string & s1, const std::string & s2) {
+                    return s1[0] < s2[0]; })) {
+        std::cout << s << '\n';
+    }
+        
+
+    for (auto i : sorted(
+                std::vector<int>{19, 45, 32, 10, 0, 90, 15, 1, 7, 5, 6, 69})) {
+        std::cout << i << '\n';
+    }
+    return 0;
+}
diff --git a/examples/testtakewhile.cpp b/examples/testtakewhile.cpp
new file mode 100644
index 00000000..bec3aeae
--- /dev/null
+++ b/examples/testtakewhile.cpp
@@ -0,0 +1,32 @@
+#include <takewhile.hpp>
+#include <range.hpp>
+
+#include <vector>
+#include <iostream>
+
+using iter::takewhile;
+using iter::range;
+
+int main() {
+    std::vector<int> ivec{1, 2, 3, 4, 5, 6, 7, 6, 5, 4, 3, 2, 1};
+    for (auto i : takewhile([] (int i) {return i < 5;}, ivec)) {
+        std::cout << i << '\n';
+    }
+
+    for (auto i : takewhile([] (int i) {return i < 5;}, range(10))) {
+        std::cout << i << '\n';
+    }
+
+    for (auto i : takewhile([] (int i) {return i < 5;}, 
+                {1, 2, 3, 4, 5, 6, 7, 8, 9})) {
+        std::cout << i << '\n';
+    }
+
+    std::cout << "with temporary\n";
+    for (auto i : takewhile([] (int i) {return i < 5;}, 
+                std::vector<int>{1, 2, 3, 4, 5, 6, 7, 8, 9})) {
+        std::cout << i << '\n';
+    }
+
+    return 0;
+}
diff --git a/examples/testunique_everseen.cpp b/examples/testunique_everseen.cpp
new file mode 100644
index 00000000..015adb7d
--- /dev/null
+++ b/examples/testunique_everseen.cpp
@@ -0,0 +1,41 @@
+
+#include <vector>
+#include <iostream>
+
+#include <unique_everseen.hpp>
+using iter::unique_everseen;
+
+int main() {
+    {
+        //should work same as justseen here
+        std::vector<int> v {1,1,1,2,2,3,4,4,5,6,7,8,8,8,8,9,9};
+        for (auto i : unique_everseen(v)) {
+            std::cout << i << " ";
+        }std::cout << std::endl;
+    }
+    {
+        std::vector<int> v {1,2,3,4,3,2,1,5,6,7,7,8,9,8,9,6};
+        for (auto i : unique_everseen(v)) {
+            std::cout << i << " ";
+        }std::cout << std::endl;
+    }
+
+    for (auto i : unique_everseen(
+                std::vector<int>{1,2,1,3,4,3,2,1,5,6,7,7,8,9,8,9,6})) {
+        std::cout << i << " ";
+    }
+    std::cout << std::endl;
+
+    int arr[] = {1,2,1,3,4,3,2,1,5,6,7,7,8,9,8,9,6};
+    for (auto i : unique_everseen(arr)) {
+        std::cout << i << ' ';
+    }
+    std::cout << '\n';
+
+    for (auto i : unique_everseen({1,2,1,3,4,3,2,1,5,6,7,7,8,9,8,9,6})) {
+        std::cout << i << ' ';
+    }
+    std::cout << '\n';
+
+    return 0;
+}
diff --git a/examples/testunique_justseen.cpp b/examples/testunique_justseen.cpp
new file mode 100644
index 00000000..8f454b6d
--- /dev/null
+++ b/examples/testunique_justseen.cpp
@@ -0,0 +1,35 @@
+
+#include <vector>
+#include <iostream>
+
+#include <unique_justseen.hpp>
+using iter::unique_justseen;
+
+int main() {
+    std::vector<int> v {1,1,1,2,2,4,4,5,6,7,8,8,8,8,9,9};
+    for (auto i : unique_justseen(v)) {
+        std::cout << i << " ";
+    }
+    std::cout << '\n';
+
+    std::cout << "with temporary\n";
+    for (auto i : unique_justseen(std::vector<int>{1,1,1,2,3,3})) {
+        std::cout << i << " ";
+    }
+    std::cout << '\n';
+
+    std::cout << "with init list\n";
+    for (auto i : unique_justseen({1,1,1,2,3,3})) {
+        std::cout << i << " ";
+    }
+    std::cout << '\n';
+
+    std::cout << "with static array\n";
+    int arr[] = {1, 1, 2, 3, 3, 3, 4};
+    for (auto i : unique_justseen(arr)) {
+        std::cout << i << " ";
+    }
+    std::cout << '\n';
+
+    return 0;
+}
diff --git a/examples/testzip.cpp b/examples/testzip.cpp
new file mode 100644
index 00000000..76a95fd7
--- /dev/null
+++ b/examples/testzip.cpp
@@ -0,0 +1,118 @@
+#include <zip.hpp>
+#include <chain.hpp>
+#include <range.hpp>
+
+#include <vector>
+#include <string>
+#include <iostream>
+#include <array>
+#include <cassert>
+
+using iter::zip;
+
+int main() {
+    //Ryan's test
+    {
+        for (auto t : zip()) { t=t; }
+
+        std::vector<int> ivec{1, 4, 9, 16, 25, 36};
+        std::vector<std::string> svec{"hello", "good day", "goodbye"};
+
+        constexpr int magic_value = 69;
+        for (auto e : zip(ivec, svec)) {
+            auto &i = std::get<0>(e);
+            std::cout << i << std::endl;
+            i = magic_value;
+            std::cout << std::get<1>(e) << std::endl;
+        }
+        assert(ivec.at(0) == magic_value);
+        for (auto e : zip(ivec, svec)) {
+            std::cout << std::get<0>(e) << std::endl;
+            std::cout << std::get<1>(e) << std::endl;
+        }
+
+        for (auto e : zip(std::vector<int>{5,6,7})) {
+            std::cout << std::get<0>(e) << std::endl;
+        }
+        for (auto e : zip(std::vector<int>{5,6,7}, std::array<int,2>{{1,2}})){
+            std::cout << std::get<0>(e) << std::endl;
+            std::cout << std::get<1>(e) << std::endl;
+        }
+
+        for (auto e : zip(iter::range(10), iter::range(10, 20))) {
+            std::cout << std::get<0>(e) << '\n';
+            std::cout << std::get<1>(e) << '\n';
+        }
+
+        int arr[] = {1,2,3,3,4};
+        for (auto e : zip(iter::range(10), arr)) {
+            std::cout << std::get<0>(e) << '\n';
+            std::cout << std::get<1>(e) << '\n';
+        }
+            
+    }
+    //Aaron's test
+    {
+        std::array<int,4> i{{1,2,3,4}};
+        std::vector<float> f{1.2,1.4,12.3,4.5,9.9};
+        std::vector<std::string> s{"i","like","apples","alot","dude"};
+        std::array<double,5> d{{1.2,1.2,1.2,1.2,1.2}};
+        std::cout << std::endl << "Variadic template zip iterator" << std::endl;
+        for (auto e : iter::zip(i,f,s,d)) {
+            std::cout << std::get<0>(e) << " " 
+                << std::get<1>(e) << " " 
+                << std::get<2>(e) << " "
+                << std::get<3>(e) << std::endl;
+            std::get<1>(e)=2.2f; //modify the float array
+        }
+        std::cout<<std::endl;
+        for (auto e : iter::zip(i,s,f,d)) {
+            std::cout << std::get<0>(e) << " " 
+                << std::get<1>(e) << " "
+                << std::get<2>(e) << " " 
+                << std::get<3>(e) << std::endl;
+        }
+        std::cout << std::endl << "Try some weird range differences" << std::endl;
+        std::vector<int> empty{};
+        for (auto e : iter::zip(empty,f,s,d)) {
+            std::cout << std::get<0>(e) << " " 
+                << std::get<1>(e) << " " 
+                << std::get<2>(e) << " "
+                << std::get<3>(e) << std::endl;
+        }
+        std::cout<<std::endl;
+        for (auto e : iter::zip(f,s,empty,d)) {
+            std::cout << std::get<0>(e) << " " 
+                << std::get<1>(e) << " " 
+                << std::get<2>(e) << " "
+                << std::get<3>(e) << std::endl;
+        }//both should print nothing
+        std::cout<<std::endl;
+        for (auto e : iter::zip(f,s,i,d)) { //i should be the limiter now
+            std::cout << std::get<0>(e) << " " 
+                << std::get<1>(e) << " " 
+                << std::get<2>(e) << " "
+                << std::get<3>(e) << std::endl;
+        }
+        std::cout<<std::endl;
+        const std::vector<double> constvector{1.1,2.2,3.3,4.4};
+        for (auto e : zip(
+                    iter::chain(std::vector<int>{5,6},
+                               std::array<int,2>{{1,2}}),
+                    std::initializer_list<const char *>{
+                         "asdfas","aaron","ryan","apple","juice"},
+                    std::initializer_list<int>{1, 2, 3, 4},
+                    constvector)) 
+        { 
+
+            std::cout << std::get<0>(e) << " " 
+                << std::get<1>(e) << " "
+                << std::get<2>(e)
+                << '\n';
+        }
+    }
+
+
+    return 0;
+}
+
diff --git a/examples/testzip_longest.cpp b/examples/testzip_longest.cpp
new file mode 100644
index 00000000..63dc8fd0
--- /dev/null
+++ b/examples/testzip_longest.cpp
@@ -0,0 +1,96 @@
+#include <zip_longest.hpp>
+
+#include <vector>
+#include <string>
+#include <iostream>
+#include <array>
+#include <boost/optional.hpp>
+
+using iter::zip_longest;
+
+template <typename T>
+std::ostream & operator<<(std::ostream & out, const boost::optional<T>& opt) {
+    if (opt) {
+        out << "Just " << *opt;
+    } else {
+        out << "Nothing";
+    }
+    return out;
+}
+
+int main() {
+    //Ryan's test
+    {
+        std::vector<int> ivec{1, 4, 9, 16, 25, 36};
+        std::vector<std::string> svec{"hello", "good day", "goodbye"};
+
+        for (auto e : zip_longest(ivec, svec)) {
+            std::cout << std::get<0>(e) << std::endl; 
+            std::cout << std::get<1>(e) << std::endl; 
+        }
+
+        for (auto e : zip_longest("helloworld",
+                    std::vector<int>{1,2,3})) {
+            std::cout << std::get<0>(e) << std::endl; 
+            std::cout << std::get<1>(e) << std::endl; 
+        }
+    }
+    //Aaron's test
+    {
+        std::array<int,4> i{{1,2,3,4}};
+        std::vector<float> f{1.2,1.4,12.3,4.5,9.9};
+        std::vector<std::string> s{"i","like","apples","alot","dude"};
+        std::array<double,5> d{{1.2,1.2,1.2,1.2,1.2}};
+        std::cout << std::endl << "Variadic template zip_longest" << std::endl;
+        for (auto e : iter::zip_longest(i,f,s,d)) {
+            std::cout << std::get<0>(e) << ' '
+                << std::get<1>(e) << ' '
+                << std::get<2>(e) << ' '
+                << std::get<3>(e) << std::endl;
+            *std::get<1>(e)=2.2f; //modify the float array
+        }
+        std::cout<<"modified array" <<std::endl;
+        for (auto e : iter::zip_longest(i,s,f,d)) {
+            std::cout << std::get<0>(e) << ' '
+                << std::get<1>(e) << ' '
+                << std::get<2>(e) << ' '
+                << std::get<3>(e) << std::endl;
+        }
+        std::cout << std::endl << "Try some weird range differences" << std::endl;
+        std::vector<int> empty{};
+        for (auto e : iter::zip_longest(empty,f,s,d)) {
+            std::cout << std::get<0>(e) << ' '
+                << std::get<1>(e) << ' '
+                << std::get<2>(e) << ' '
+                << std::get<3>(e) << std::endl;
+        }
+        std::cout<<std::endl;
+        for (auto e : iter::zip_longest(f,empty,s,d)) {
+            std::cout << std::get<0>(e) << ' '
+                << std::get<1>(e) << ' '
+                << std::get<2>(e) << ' '
+                << std::get<3>(e) << std::endl;
+        }
+        std::cout<<std::endl;
+        for (auto e : iter::zip_longest(f,s,i,d)) { 
+            std::cout << std::get<0>(e) << ' '
+                << std::get<1>(e) << ' '
+                << std::get<2>(e) << ' '
+                << std::get<3>(e) << std::endl;
+        }
+        std::cout<<std::endl;
+        for (auto e : iter::zip_longest(std::initializer_list<int>{1,2,3,4,5,6},
+                    std::initializer_list<double>{1.1,2.2,3.3,4.4},
+                    std::initializer_list<double>{1.1,2.2,3.3,4.4},
+                    std::array<int,3>{{1,2,3}})) { 
+            std::cout << std::get<0>(e) << ' '
+                << std::get<1>(e) << ' '
+                << std::get<2>(e) << ' '
+                << std::get<3>(e) << std::endl;
+        }
+        std::cout<<std::endl;
+
+    }
+    return 0;
+}
+
diff --git a/iterbase.hpp b/iterbase.hpp
index dc65fcfc..be7d71db 100644
--- a/iterbase.hpp
+++ b/iterbase.hpp
@@ -219,6 +219,18 @@ namespace iter {
             }
     };
 
+    template <typename T>
+    struct type_is {
+        using type = T;
+    };
+
+    // gcc CWG 1558
+    template <typename...>
+    struct void_t_help {
+        using type = void;
+    };
+    template <typename... Ts>
+    using void_t = typename void_t_help<Ts...>::type;
 
 }
 

From afb2b623cced68f805433fea856b1127a03fedb5 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 7 Apr 2015 22:49:13 -0700
Subject: [PATCH 1081/1866] lets iteratoriterator work with const things

---
 iteratoriterator.hpp | 72 ++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 70 insertions(+), 2 deletions(-)

diff --git a/iteratoriterator.hpp b/iteratoriterator.hpp
index 5bd807bc..bf4fc35b 100644
--- a/iteratoriterator.hpp
+++ b/iteratoriterator.hpp
@@ -15,6 +15,13 @@
 // behave like some_collection<T> when iterated over or indexed
 
 namespace iter {
+    template <typename T, typename =void>
+    struct HasConstDeref : std::false_type { };
+
+    template <typename T>
+    struct HasConstDeref<T, void_t<decltype(*std::declval<const T&>())>>
+        : std::true_type { };
+
     template <typename Iter,
          typename Diff =typename std::iterator_traits<Iter>::difference_type>
     class IteratorIterator : public std::iterator<
@@ -142,8 +149,35 @@ namespace iter {
             using size_type = typename Container::size_type;
             using iterator =
                 IteratorIterator<typename Container::iterator>;
+            using const_iterator =
+                IteratorIterator<typename Container::const_iterator>;
             using reverse_iterator =
                 IteratorIterator<typename Container::reverse_iterator>;
+            using const_reverse_iterator =
+                IteratorIterator<typename Container::const_reverse_iterator>;
+
+            template <typename U =Container, typename =void>
+            struct ConstAtTypeOrVoid : type_is<void> { };
+
+            template <typename U>
+            struct ConstAtTypeOrVoid <
+                U, void_t<decltype(*std::declval<const U&>().at(0))>>
+            : type_is<decltype(*std::declval<const U&>().at(0))>
+            { };
+
+            using const_at_type_or_void_t = typename ConstAtTypeOrVoid<>::type;
+
+            template <typename U =Container, typename =void>
+            struct ConstIndexTypeOrVoid : type_is<void> { };
+
+            template <typename U>
+            struct ConstIndexTypeOrVoid <
+                U, void_t<decltype(*std::declval<const U&>()[0])>>
+            : type_is<decltype(*std::declval<const U&>()[0])>
+            { };
+
+            using const_index_type_or_void_t =
+                typename ConstIndexTypeOrVoid<>::type;
 
         public:
             IterIterWrapper() = default;
@@ -160,7 +194,9 @@ namespace iter {
                 return *container.at(pos);
             }
 
-            auto at(size_type pos) const -> decltype(*container.at(pos)) {
+            auto at(size_type pos) const ->
+                const_at_type_or_void_t 
+            {
                 return *container.at(pos);
             }
 
@@ -173,7 +209,7 @@ namespace iter {
 
             auto operator[](size_type pos) const
                 noexcept(noexcept(*container[pos]))
-                -> decltype(*container[pos])
+                -> const_index_type_or_void_t
             {
                 return *container[pos];
             }
@@ -194,6 +230,22 @@ namespace iter {
                 return {container.end()};
             }
 
+            const_iterator begin() const noexcept {
+                return {container.begin()};
+            }
+
+            const_iterator end() const noexcept {
+                return {container.end()};
+            }
+
+            const_iterator cbegin() const noexcept {
+                return {container.cbegin()};
+            }
+
+            const_iterator cend() const noexcept {
+                return {container.cend()};
+            }
+
             reverse_iterator rbegin() noexcept {
                 return {container.rbegin()};
             }
@@ -202,6 +254,22 @@ namespace iter {
                 return {container.rend()};
             }
 
+            const_reverse_iterator rbegin() const noexcept {
+                return {container.rbegin()};
+            }
+
+            const_reverse_iterator rend() const noexcept {
+                return {container.rend()};
+            }
+
+            const_reverse_iterator crbegin() const noexcept {
+                return {container.rbegin()};
+            }
+
+            const_reverse_iterator crend() const noexcept {
+                return {container.rend()};
+            }
+
             // get() exposes the underlying container.  this allows the
             // itertools to manipulate the iterators in the container
             // and should not be depended on anywhere else.

From 7b22090f634203c49623596a2adf15ab2e298551 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 7 Apr 2015 23:08:44 -0700
Subject: [PATCH 1082/1866] updates permutations reqs

---
 README.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 9c3c12de..72e751bb 100644
--- a/README.md
+++ b/README.md
@@ -611,7 +611,8 @@ for (auto&& v : combinations_with_replacement(s, 2)) {
 permutations
 -----------
 
-Generates all the permutations of a range using `std::next_permutation`  
+Generates all the permutations of a range using `std::next_permutation`.  The
+iterators of the sequence passed must have an `operator*() const`
 
 Example usage:
 ```c++

From a6942eadd72f5617548f092ef34bfa187e363ea7 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 16 Apr 2015 20:58:00 -0700
Subject: [PATCH 1083/1866] converts testrange to a set of examples

---
 examples/range_examples.cpp | 61 +++++++++++++++++++++++++++++++++++++
 1 file changed, 61 insertions(+)
 create mode 100644 examples/range_examples.cpp

diff --git a/examples/range_examples.cpp b/examples/range_examples.cpp
new file mode 100644
index 00000000..a0e742ee
--- /dev/null
+++ b/examples/range_examples.cpp
@@ -0,0 +1,61 @@
+#include <range.hpp>
+
+#include <iostream>
+
+int main() {
+    std::cout << "range(10): { ";
+    for (auto i : iter::range(10)) {
+        std::cout << i << ' ';
+    }
+    std::cout << "}\n";
+
+    // range works with a start and exclusive stop
+    std::cout << "range(20, 30): { ";
+    for (auto i : iter::range(20, 30)) {
+        std::cout << i << ' ';
+    }
+    std::cout << "}\n";
+
+    // range supports a step size (prints 50, 52 ... 58)
+    std::cout << "range(50, 60, 2): { ";
+    for (auto i : iter::range(50, 60, 2)) {
+        std::cout << i << ' ';
+    }
+    std::cout << "}\n";
+
+    // ranges can cover negative values
+    std::cout << "range(-10, 10, 2): { ";
+    for (auto i : iter::range(-10, 10, 2)) {
+        std::cout << i << ' ';
+    }
+    std::cout << "}\n";
+
+    // the step size doesn't need to evenly divide the distance
+    std::cout << "range(0, 5, 4): { ";
+    for (auto i : iter::range(0, 5, 4)) {
+        std::cout << i << ' ';
+    }
+    std::cout << "}\n";
+
+    // ranges can go down with a negative step
+    std::cout << "range(-1, -10, -2): { ";
+    for (auto i : iter::range(-1, -10, -2)) {
+        std::cout << i << ' ';
+    }
+    std::cout << "}\n";
+
+    // ranges can work with floats and other types that act like numbers
+    // the normal concerns with comparing floats still hold here
+    std::cout << "range(5.0, 9.9, 0.5): { ";
+    for (auto i : iter::range(5.0, 9.9, 0.5)) {
+        std::cout << i << ' ';
+    }
+    std::cout << "}\n";
+
+    // ranges of course support unsigned values
+    std::cout << "range(10u): { ";
+    for (auto i : iter::range(10u)) {
+        std::cout << i << ' ';
+    }
+    std::cout << "}\n";
+}

From 1d1239803f6202e219ef51590654cc66f087d3b4 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 16 Apr 2015 21:14:24 -0700
Subject: [PATCH 1084/1866] converts testenumerate into examples

---
 examples/enumerate_examples.cpp | 42 +++++++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 examples/enumerate_examples.cpp

diff --git a/examples/enumerate_examples.cpp b/examples/enumerate_examples.cpp
new file mode 100644
index 00000000..39786696
--- /dev/null
+++ b/examples/enumerate_examples.cpp
@@ -0,0 +1,42 @@
+#include <enumerate.hpp>
+
+#include <string>
+#include <iostream>
+#include <vector>
+#include <cassert>
+
+
+int main() {
+    std::cout << "enumerating the characters of a string \"hello\":\n";
+    const std::string const_string("hello");
+    for (auto&& e : iter::enumerate(const_string)) {
+        std::cout << '(' << e.index << ", " << e.element << ") ";
+    }
+    std::cout << '\n';
+
+    std::vector<int> vec = {20, 30, 50};
+    std::cout << "enumerating a vector of {20, 30, 50}:\n";
+    for (auto&& e : iter::enumerate(vec)) { 
+        std::cout << '(' << e.index << ", " << e.element << ") ";
+        e.element = 0;
+    }
+    std::cout << '\n';
+    assert(vec[0] == 0);
+    assert(vec[1] == 0);
+    assert(vec[2] == 0);
+
+    // itertools supports raw arrays
+    std::cout << "statically sized arrays can be enumerated\n";
+    int array[] = {1, 9, 8, 11};
+    for (auto&& e : iter::enumerate(array)) {
+        std::cout << '(' << e.index << ", " << e.element << ") ";
+    }
+    std::cout << '\n';
+
+    // itertools supports temporaries
+    std::cout << "vector temporary of {5, 2}\n";
+    for (auto&& e : iter::enumerate(std::vector<int>(5,2))) {
+        std::cout << '(' << e.index << ", " << e.element << ") ";
+    }
+    std::cout << '\n';
+}

From 9d23f2f0bcf8407f4aeb8b85eaa811157d27f698 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 16 Apr 2015 21:23:01 -0700
Subject: [PATCH 1085/1866] converts testaccumulate into examples

---
 examples/accumulate_examples.cpp | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 examples/accumulate_examples.cpp

diff --git a/examples/accumulate_examples.cpp b/examples/accumulate_examples.cpp
new file mode 100644
index 00000000..9d9a2f67
--- /dev/null
+++ b/examples/accumulate_examples.cpp
@@ -0,0 +1,22 @@
+#include <accumulate.hpp>
+#include <range.hpp>
+
+#include <iostream>
+#include <vector>
+
+int main() {
+    std::vector<int> vec = {0, 1, 2, 3, 4, 5};
+    // accumulate adds elements by default
+    std::cout << "accumulate({1, 2, 3, 4, 5}): { ";
+    for (auto i : iter::accumulate(vec)) {
+        std::cout << i << ' ';
+    }
+    std::cout << "}\n";
+
+    // accumulate with a lambda for subtraction
+    std::cout << "accumulate({1, 2, 3, 4, 5}, subtract): { ";
+    for (auto i : iter::accumulate(vec, [](int a, int b){return a - b;})) {
+        std::cout << i << ' ';
+    }
+    std::cout << "}\n";
+}

From d50a93eb149d0aff2d4304d369d70c7fc9d322bc Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 16 Apr 2015 22:01:15 -0700
Subject: [PATCH 1086/1866] replaces testzip with zip examples

---
 examples/zip_examples.cpp | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 examples/zip_examples.cpp

diff --git a/examples/zip_examples.cpp b/examples/zip_examples.cpp
new file mode 100644
index 00000000..0b7f347a
--- /dev/null
+++ b/examples/zip_examples.cpp
@@ -0,0 +1,17 @@
+#include <zip.hpp>
+
+#include <vector>
+#include <string>
+#include <iostream>
+
+int main() {
+    std::vector<int> ivec{1, 4, 9, 16, 25, 36};
+    std::vector<std::string> svec{"hello", "good day", "goodbye"};
+
+    // zip terminates on the shortest sequence, and is variadic
+    std::cout << "zipping a vector of ints and a vector of strings\n";
+    for (auto&& e : iter::zip(ivec, svec)) {
+        std::cout << '(' << std::get<0>(e) << ", " << std::get<1>(e) << ")\n";
+    }
+}
+

From 54b1dd30b1a241efa95f1e075f1065ad4fb7b682 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 16 Apr 2015 22:15:57 -0700
Subject: [PATCH 1087/1866] replaces testchain with chain examples

---
 examples/chain_examples.cpp | 45 +++++++++++++++++++++++++++++++++++++
 1 file changed, 45 insertions(+)
 create mode 100644 examples/chain_examples.cpp

diff --git a/examples/chain_examples.cpp b/examples/chain_examples.cpp
new file mode 100644
index 00000000..607fa040
--- /dev/null
+++ b/examples/chain_examples.cpp
@@ -0,0 +1,45 @@
+#include <chain.hpp>
+
+#include <vector>
+#include <string>
+#include <list>
+#include <iostream>
+#include <array>
+
+int main() {
+    // chaining combines two sequences for iteration
+    std::vector<int> ivec = {1, 4, 7, 9};
+    std::vector<int> lvec = {100, 200, 300, 400, 500, 600};
+    std::cout << "chaining two int vectors together:\n";
+    for (auto&& e : iter::chain(ivec, lvec)) {
+        std::cout << e << ' ';
+    }
+    std::cout << '\n';
+
+    std::vector<char> vec1 = {'c', 'h'};
+    std::array<char,4> arr1{{'a', 'i', 'n', 'i'}};
+    std::string s{"ng different "};
+    std::list<char> lst = {'t', 'y', 'p', 'e', 's'};
+
+    // chain can mix different sequence types as long as the type yielded
+    // by their underlying iterators is *exactly* the same
+    std::cout << "mixing: ";
+    for (auto&& c : iter::chain(vec1, arr1, s, lst)) {
+        std::cout << c;
+    }
+    std::cout << '\n';
+
+    std::vector<std::vector<int>> matrix = {
+        {2, 4, 6},
+        {8, 10, 12},
+        {14, 16, 18}
+    };
+
+    // chain.from_iterable effectively flattens a sequence by one level
+    std::cout << "chain.from_iterable to flatten matrix:\n";
+    for (auto&& i : iter::chain.from_iterable(matrix)) {
+        std::cout << i << ' ';
+    }
+    std::cout << '\n';
+
+}

From 1ed29ab234209efc5dfde01812bcbccb508cadba Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 17 Apr 2015 08:56:16 -0700
Subject: [PATCH 1088/1866] adds examples for all combinatorics

---
 examples/combinatoric_examples.cpp | 63 ++++++++++++++++++++++++++++++
 1 file changed, 63 insertions(+)
 create mode 100644 examples/combinatoric_examples.cpp

diff --git a/examples/combinatoric_examples.cpp b/examples/combinatoric_examples.cpp
new file mode 100644
index 00000000..d7111a56
--- /dev/null
+++ b/examples/combinatoric_examples.cpp
@@ -0,0 +1,63 @@
+#include <combinations.hpp>
+#include <combinations_with_replacement.hpp>
+#include <permutations.hpp>
+#include <product.hpp>
+#include <powerset.hpp>
+
+#include <vector>
+#include <string>
+#include <iostream>
+
+int main() {
+    const std::vector<int> v1 = {1,2,3,4,5};
+
+    std::cout << "combinations({1,2,3,4,5}, 3}:\n";
+    for (auto&& ns : iter::combinations(v1,3)) {
+        std::cout << "{ ";
+        for (auto&& j : ns ) {
+            std::cout << j << ' ';
+        }
+        std::cout << "}\n";
+    }
+
+
+
+    // allows elements to be used repeatedly
+    std::cout << "combinations_with_replacement({1, 2}, 4):\n";
+    std::vector<int> v2 = {1,2};
+    for (auto&& ns : iter::combinations_with_replacement(v2, 4)) {
+        std::cout << "{ ";
+        for (auto&& j : ns ) {
+            std::cout << j << ' ';
+        }
+        std::cout << "}\n";
+    }
+
+    std::cout << "permutations(\"abc\"):\n";
+    std::string s{"abc"};
+    for (auto&& cs : iter::permutations(s)) {
+        std::cout << "{ ";
+        for (auto&& c : cs ) {
+            std::cout << c << ' ';
+        }
+        std::cout << "}\n";
+    }
+
+    std::vector<std::string> v3 = {"abc", "def"};
+    std::cout << "product of three vectors (int, int, string):\n";
+    for (auto&& t : iter::product(v1,v2,v3)) {
+        std::cout << "{ "
+            << std::get<0>(t) << ' '
+            << std::get<1>(t) << ' '
+            << std::get<2>(t) << " }\n";
+    }
+
+    std::cout << "powerset({1,2,3,4,5}):\n";
+    for (auto&& ns : iter::powerset(v1)) {
+        std::cout << "{ ";
+        for (auto&& i : ns ) {
+            std::cout << i << ' ';
+        }
+        std::cout << "}\n";
+    }
+}

From c295d8abf622aa8633b91c13b78165ca754f20a4 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 18 Apr 2015 18:05:50 -0700
Subject: [PATCH 1089/1866] cycle_examples added

---
 examples/cycle_examples.cpp | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 examples/cycle_examples.cpp

diff --git a/examples/cycle_examples.cpp b/examples/cycle_examples.cpp
new file mode 100644
index 00000000..51eecafb
--- /dev/null
+++ b/examples/cycle_examples.cpp
@@ -0,0 +1,29 @@
+#include <cycle.hpp>
+
+#include <vector>
+#include <string>
+#include <iostream>
+
+int main() {
+    std::cout << "cycle({2, 4, 6}) run 20 times:\n";
+    std::vector<int> vec = {2, 4, 6};
+    size_t count = 0;
+    for (auto&& i : iter::cycle(vec)) {
+        std::cout << i << '\n';
+        if (count == 20) {
+            break;
+        }
+        ++count;
+    }
+
+    std::cout << "cycle(\"hello\") run 20 times:\n";
+    count = 0;
+    const std::string s("hello");
+    for (auto&& c : iter::cycle(s)) {
+        std::cout << c << '\n';
+        if (count == 20) {
+            break;
+        }
+        ++count;
+    }
+}

From 4628ea06c5e4f902257626105fa2d8c68cc4180d Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 18 Apr 2015 18:38:07 -0700
Subject: [PATCH 1090/1866] adds slice_examples

---
 examples/slice_examples.cpp | 58 +++++++++++++++++++++++++++++++++++++
 1 file changed, 58 insertions(+)
 create mode 100644 examples/slice_examples.cpp

diff --git a/examples/slice_examples.cpp b/examples/slice_examples.cpp
new file mode 100644
index 00000000..42a16e33
--- /dev/null
+++ b/examples/slice_examples.cpp
@@ -0,0 +1,58 @@
+#include <iostream>
+
+#include <slice.hpp>
+#include <range.hpp>
+
+#include <vector>
+#include <array>
+
+int main() {
+    std::string a = "hello world";
+
+    std::cout << "a = { ";
+    for (auto&& i : a) {
+        std::cout << i << ' ';
+    }
+    std::cout << "}\n";
+
+
+    // just like range(), the step doesn't have to make it end anywhere
+    // specific, below, the step is too great to cover more than two elements
+    std::cout << "slice(a, 1, 4, 7): { ";
+    for (auto&& i : iter::slice(a, 1, 4, 5)) {
+        std::cout << i << ' ';
+    }
+    std::cout << "\n";
+
+    std::cout << "slice(a, 2): { ";
+    for (auto&& i : iter::slice(a, 2)) {
+        std::cout << i << ' ';
+    }
+    std::cout << "}\n";
+    
+    std::cout << "slice(a, 1, 5): { ";
+    for (auto&& i : iter::slice(a, 1, 5)) {
+        std::cout << i << ' ';
+    }
+    std::cout << "}\n";
+
+    std::cout << "slice(a, 2, 8, 2): { ";
+    for (auto&& i : iter::slice(a, 2, 8, 2)) {
+        std::cout << i << ' ';
+    }
+    std::cout << "}\n";
+    
+    // the stop can be beyond the end
+    std::cout << "slice(a, 100): { ";
+    for (auto&& i : iter::slice(a, 100)) {
+        std::cout << i << ' ';
+    }
+    std::cout << "}\n";
+
+    // the start can too
+    std::cout << "slice(a, 100, 200): { ";
+    for (auto&& i : iter::slice(a, 100, 200)) {
+        std::cout << i << ' ';
+    }
+    std::cout << "}\n";
+}

From b33ec175daab8f1a01c04ec9e4a638c5b0055e41 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 18 Apr 2015 19:07:00 -0700
Subject: [PATCH 1091/1866] adds compress examples

---
 examples/compress_examples.cpp | 43 ++++++++++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)
 create mode 100644 examples/compress_examples.cpp

diff --git a/examples/compress_examples.cpp b/examples/compress_examples.cpp
new file mode 100644
index 00000000..b60197a9
--- /dev/null
+++ b/examples/compress_examples.cpp
@@ -0,0 +1,43 @@
+#include <compress.hpp>
+
+#include <vector>
+#include <iostream>
+
+template <typename DataType, typename SelectorType>
+void testcase(std::vector<DataType> data_vec,
+        std::vector<SelectorType> sel_vec)
+{
+
+    for (auto e : compress(data_vec, sel_vec)) {
+        std::cout << e << '\n';
+    }
+}
+
+int main(void) {
+    using BVec = const std::vector<bool>;
+
+    std::vector<int> ns{0, 1, 2, 3, 4, 5};
+    std::cout << "ns = { ";
+    for (auto&& i : ns) {
+        std::cout << i << ' ';
+    }
+    std::cout << "}\n";
+
+    BVec b1{true, false, true, false, true, false};
+
+    std::cout << "compress(ns, {true, false, true, false, true, false}): { ";
+    for (auto&& i : iter::compress(ns, b1)) {
+        std::cout << i << ' ';
+    }
+    std::cout << "}\n";
+    
+
+    BVec b2 {true}; 
+    // compress terminates on the shortest sequence (either one)
+    std::cout << "compress(ns, {true}): { ";
+    for (auto&& i : iter::compress(ns, b2)) {
+        std::cout << i << ' ';
+    }
+    std::cout << "}\n";
+    
+}

From 1d83d161b0a539b565b1563c9ae8c68e60e6ccc2 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 18 Apr 2015 19:36:21 -0700
Subject: [PATCH 1092/1866] replaces testcount with count_examples

---
 examples/count_examples.cpp | 37 +++++++++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 examples/count_examples.cpp

diff --git a/examples/count_examples.cpp b/examples/count_examples.cpp
new file mode 100644
index 00000000..10ac8a72
--- /dev/null
+++ b/examples/count_examples.cpp
@@ -0,0 +1,37 @@
+#include <count.hpp>
+
+#include <iostream>
+
+int main() {
+    std::cout << "count() counts towards infinity, breaks at 10\n";
+    for (auto i : iter::count()) {
+        std::cout << i << '\n';
+        if (i == 10) {
+            break;
+        }
+    }
+
+    std::cout << "count(20) starts counting from 20, breaks at 30\n";
+    for (auto i : iter::count(20)) {
+        std::cout << i << '\n';
+        if (i == 30) {
+            break;
+        }
+    }
+
+    std::cout << "count(50, 2) counts by 2 starting at 50, breaks at 70\n";
+    for (auto i : iter::count(50, 2)) {
+        std::cout << i << '\n';
+        if (i >= 70) {
+            break;
+        }
+    }
+
+    std::cout << "count(0, -1) counts down towards -infinity, breaks at -10\n";
+    for (auto i : iter::count(0, -1)) {
+        std::cout << i << '\n';
+        if (i == -10) {
+            break;
+        }
+    }
+}

From 535c0a620882920b1afcac4375fdcf50cb7d1dbd Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 18 Apr 2015 19:47:44 -0700
Subject: [PATCH 1093/1866] replaces testdropwhile with dropwhile_examples

---
 examples/dropwhile_examples.cpp | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 examples/dropwhile_examples.cpp

diff --git a/examples/dropwhile_examples.cpp b/examples/dropwhile_examples.cpp
new file mode 100644
index 00000000..8c628f1a
--- /dev/null
+++ b/examples/dropwhile_examples.cpp
@@ -0,0 +1,19 @@
+#include <dropwhile.hpp>
+
+#include <vector>
+#include <iostream>
+
+
+int main() {
+    std::vector<int> ns = {0, 1, 2, 3, 4, 5};
+    std::cout << "ns = { ";
+    for (auto&& i : ns) {
+        std::cout << i << ' ';
+    }
+    std::cout << "}\n";
+
+    std::cout << "dropwhile elements are less than 5\n";
+    for (auto&& i : iter::dropwhile([] (int i) {return i < 5;}, ns)) {
+        std::cout << i << '\n';
+    }
+}

From 40255292c17713ecf867feb60a7f3c31edf67c8a Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 18 Apr 2015 20:03:28 -0700
Subject: [PATCH 1094/1866] replaces testfilter with filter_examples

---
 examples/filter_examples.cpp | 58 ++++++++++++++++++++++++++++++++++++
 1 file changed, 58 insertions(+)
 create mode 100644 examples/filter_examples.cpp

diff --git a/examples/filter_examples.cpp b/examples/filter_examples.cpp
new file mode 100644
index 00000000..d28c443a
--- /dev/null
+++ b/examples/filter_examples.cpp
@@ -0,0 +1,58 @@
+#include <filter.hpp>
+
+#include <vector>
+#include <iostream>
+
+bool greater_than_four(int i) {
+    return i > 4;
+}
+
+class LessThanValue {
+    private:
+        int compare_val;
+
+    public:
+        LessThanValue() = delete;
+        LessThanValue(int v) : compare_val(v) { }
+
+        bool operator() (int i) {
+            return i < this->compare_val;
+        }
+};
+
+
+int main() {
+    std::vector<int> ns{1, 5, 6, 0, 7, 2, 3, 8, 3, 0, 2, 1};
+    std::cout << "ns = { ";
+    for (auto&& i : ns) {
+        std::cout << i << ' ';
+    }
+    std::cout << "}\n";
+
+    std::cout << "Greater than 4 (function pointer)\n";
+    for (auto&& i : iter::filter(greater_than_four, ns)) {
+        std::cout << i << '\n';
+    }
+
+    std::cout << "Less than 4 (lambda)\n";
+    for (auto&& i : iter::filter([] (const int i) { return i < 4; }, ns)) {
+        std::cout << i << '\n';
+    }
+
+    LessThanValue lv(4);
+    std::cout << "Less than 4 (callable object)\n";
+    for (auto&& i : iter::filter(lv, ns)) {
+        std::cout << i << '\n';
+    }
+
+    // filter(seq) with no predicate uses the truthiness of the values
+    std::cout << "Nonzero ints filter(ns)\n";
+    for (auto&& i : iter::filter(ns)) {
+        std::cout << i << '\n';
+    }
+
+    std::cout << "odd numbers\n";
+    for (auto&& i : iter::filter([] (const int i) {return i % 2;}, ns)) {
+        std::cout << i << '\n';
+    }
+}

From 31d5da8dfc2b6e2ea477dc957e5d47e2c8311c87 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 18 Apr 2015 20:46:54 -0700
Subject: [PATCH 1095/1866] replaces testfilterfalse with filterfalse_examples

---
 examples/filterfalse_examples.cpp | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 examples/filterfalse_examples.cpp

diff --git a/examples/filterfalse_examples.cpp b/examples/filterfalse_examples.cpp
new file mode 100644
index 00000000..772005a8
--- /dev/null
+++ b/examples/filterfalse_examples.cpp
@@ -0,0 +1,29 @@
+#include <filterfalse.hpp>
+
+#include <vector>
+#include <iostream>
+
+bool greater_than_four(int i) {
+    return i > 4;
+}
+
+int main() {
+    std::vector<int> ns{1, 5, 6, 0, 7, 2, 3, 8, 3, 0, 2, 1};
+    std::cout << "ns = { ";
+    for (auto&& i : ns) {
+        std::cout << i << ' ';
+    }
+    std::cout << "}\n";
+
+    // like filter() but only shows elements that are false under the predicate
+    std::cout << "Greater than 4\n";
+    for (auto&& i : iter::filterfalse(greater_than_four, ns)) {
+        std::cout << i << '\n';
+    }
+
+    // single argument version only shows falsey values
+    std::cout << "filterfalse(ns):\n";
+    for (auto&& i : iter::filterfalse(ns)) {
+        std::cout << i << '\n';
+    }
+}

From 16e7239ebad96291a410594c0282f27bdbfa0861 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 1 May 2015 18:53:27 -0700
Subject: [PATCH 1096/1866] replaces testgroupby with groupby examples

---
 examples/groupby_examples.cpp | 51 +++++++++++++++++++++++++++++++++++
 1 file changed, 51 insertions(+)
 create mode 100644 examples/groupby_examples.cpp

diff --git a/examples/groupby_examples.cpp b/examples/groupby_examples.cpp
new file mode 100644
index 00000000..e4ae4048
--- /dev/null
+++ b/examples/groupby_examples.cpp
@@ -0,0 +1,51 @@
+#include <groupby.hpp>
+
+#include <vector>
+#include <iostream>
+#include <string>
+#include <functional>
+
+
+int main() {
+    auto len = std::mem_fn(&std::string::length);
+    std::vector<std::string> vec = {
+        "hi", "ab", "ho",
+        "abc", "def",
+        "abcde", "efghi"
+    };
+
+    std::cout << "strings grouped by their length\n";
+    for (auto&& gb : iter::groupby(vec, len)) {
+        std::cout << "key(" << gb.first << "): ";
+        for (auto&& s : gb.second) {
+            std::cout << s << "  ";
+        }
+        std::cout << '\n';
+    }
+
+    // groups may be skipped entirely or partially consumed
+    std::cout << "skipping length of 3\n";
+    for (auto&& gb : iter::groupby(vec, len)) {
+        if (gb.first == 3) {
+            continue;
+        }
+        std::cout << "key(" << gb.first << "): ";
+        for (auto&& s : gb.second) {
+            std::cout << s << "  ";
+        }
+        std::cout << '\n';
+    }
+   
+
+    std::cout << "ints grouped by their value:\n";
+    std::vector<int> ivec = {5, 5, 6, 6, 19, 19, 19, 19, 69, 0, 10, 10};
+    for (auto gb : iter::groupby(ivec)) {
+        std::cout << "key(" << gb.first << "): ";
+        for (auto s : gb.second) {
+            std::cout << s << "  ";
+        }
+        std::cout << '\n';
+    }
+}
+
+    

From b9352fe91e828c30c157e28efc85f8f0205aea5d Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 1 May 2015 18:57:55 -0700
Subject: [PATCH 1097/1866] replaces testgrouper with grouper examples

---
 examples/grouper_examples.cpp | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 examples/grouper_examples.cpp

diff --git a/examples/grouper_examples.cpp b/examples/grouper_examples.cpp
new file mode 100644
index 00000000..0ae6bb40
--- /dev/null
+++ b/examples/grouper_examples.cpp
@@ -0,0 +1,23 @@
+#include <grouper.hpp>
+
+#include <iostream>
+#include <vector>
+
+int main() {
+    std::cout << "chunk size: 4\n";
+    std::vector<int> v {1,2,3,4,5,6,7,8,9}; 
+    for (auto&& sec : iter::grouper(v, 4)) {
+        for (auto&& i : sec) {
+            std::cout << i << " ";
+        }
+        std::cout << '\n';
+    }
+
+    std::cout << "chunk size: 3\n";
+    for (auto&& sec : iter::grouper(v,3)) {
+        for (auto&& i : sec) {
+            std::cout << i << " ";
+        }
+        std::cout << '\n';
+    }
+}

From 18c8d22bf4d7dda91408fd01c135139b1c84932d Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 1 May 2015 19:09:34 -0700
Subject: [PATCH 1098/1866] replaces testimap with imap examples

---
 examples/imap_examples.cpp | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 examples/imap_examples.cpp

diff --git a/examples/imap_examples.cpp b/examples/imap_examples.cpp
new file mode 100644
index 00000000..812281b6
--- /dev/null
+++ b/examples/imap_examples.cpp
@@ -0,0 +1,33 @@
+#include <imap.hpp>
+
+#include <vector>
+#include <iostream>
+
+int main() {
+    // applies the function on its way through the sequence
+    std::cout << "mapping i*i over [1, 7): ";
+    std::vector<int> vec1 = {1, 2, 3, 4, 5, 6};
+    for (auto i : iter::imap([] (int i) {return i * i; }, vec1)) {
+        std::cout << i << ' ';
+    }
+    std::cout << '\n';
+
+    // multiple sequences can be used, each iterator will be advanced
+    // f(a[0], b[0]) then f(a[1], b[1]) etc.
+    std::cout << "vector sum of <1, 2, ..., 6> and <10, 20, ..., 60>: ";
+    std::vector<int> vec2 = {10, 20, 30, 40, 50, 60};
+    for (auto i : iter::imap([] (int x, int y) { return x + y; }, vec1, vec2)) {
+        std::cout << i << ' ';
+    }
+    std::cout << '\n';
+
+    // it will terminate on the shortest sequence
+    std::cout << "vector sum of <1, 2, ..., 6>, <10, 20, ..., 60>, and "
+        "<100, 200, 300>: ";
+    std::vector<int> vec3 = {100, 200, 300};
+    for (auto i : iter::imap([] (int a, int b, int c) { return a + b + c; }, 
+                vec1, vec2, vec3)) {
+        std::cout << i << ' ';
+    }
+    std::cout << '\n';
+}

From a327d096a70bf62b7844f68c0fa740b272ce6280 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 2 May 2015 09:13:07 -0700
Subject: [PATCH 1099/1866] renamed testrange as range_examples

---
 examples/range_examples.cpp | 104 ++++++++++++++++++++++--------------
 examples/testrange.cpp      |  83 ----------------------------
 2 files changed, 63 insertions(+), 124 deletions(-)
 delete mode 100644 examples/testrange.cpp

diff --git a/examples/range_examples.cpp b/examples/range_examples.cpp
index a0e742ee..9404ae57 100644
--- a/examples/range_examples.cpp
+++ b/examples/range_examples.cpp
@@ -2,60 +2,82 @@
 
 #include <iostream>
 
-int main() {
-    std::cout << "range(10): { ";
-    for (auto i : iter::range(10)) {
-        std::cout << i << ' ';
+using iter::range;
+
+int main()
+{
+    for (auto i : range(10)) {
+        std::cout << i << std::endl;
+    }
+    for (auto i : range(20, 30)) {
+        std::cout << i << std::endl;
+    }
+    for (auto i : range(50, 60, 2)) {
+        std::cout << i << std::endl;
     }
-    std::cout << "}\n";
 
-    // range works with a start and exclusive stop
-    std::cout << "range(20, 30): { ";
-    for (auto i : iter::range(20, 30)) {
-        std::cout << i << ' ';
+    std::cout << "Negative Tests\n";
+    for (auto i: range(-10, 0)) {
+        std::cout << i << std::endl;
     }
-    std::cout << "}\n";
 
-    // range supports a step size (prints 50, 52 ... 58)
-    std::cout << "range(50, 60, 2): { ";
-    for (auto i : iter::range(50, 60, 2)) {
-        std::cout << i << ' ';
+    for (auto i : range(-10, 10, 2)) {
+        std::cout << i << std::endl;
     }
-    std::cout << "}\n";
 
-    // ranges can cover negative values
-    std::cout << "range(-10, 10, 2): { ";
-    for (auto i : iter::range(-10, 10, 2)) {
-        std::cout << i << ' ';
+    std::cout << "Tests where (stop - start)%step != 0" << std::endl;
+    for (auto i : range(1, 10, 2)) {
+        std::cout << i << std::endl;
     }
-    std::cout << "}\n";
 
-    // the step size doesn't need to evenly divide the distance
-    std::cout << "range(0, 5, 4): { ";
-    for (auto i : iter::range(0, 5, 4)) {
-        std::cout << i << ' ';
+    for (auto i : range(-1, -10, -2)) {
+        std::cout << i << std::endl;
+    }
+    
+    std::cout << "Tests with different types" << std::endl;
+    for(auto i : range(5.0, 10.0, 0.5)) {
+        std::cout << i << std::endl;
     }
-    std::cout << "}\n";
+	std::cout << "test unsigned" << std::endl;
+	std::cout << "empty range: " << std::endl;
+	size_t len = 0;
+	for(auto i : range(len)){
+	  std::cout << i << std::endl;
+	}
+	std::cout << "stop only" << std::endl;
+	len = 3;
+	for(auto i : range(len)){
+	  std::cout << i << std::endl;
+	}
+	std::cout << "start stop" << std::endl;
+	size_t start = 1;
+	for(auto i : range(start, len)){
+	  std::cout << i << std::endl;
+	}
 
-    // ranges can go down with a negative step
-    std::cout << "range(-1, -10, -2): { ";
-    for (auto i : iter::range(-1, -10, -2)) {
-        std::cout << i << ' ';
+	std::cout << "start stop skip" << std::endl;
+	len = 10;
+	size_t skip = 3;
+	for(auto i : range(start, len, skip)){
+	  std::cout << i << std::endl;
+	}
+	
+
+
+    // invalid ranges:
+    std::cout << "Should not print anything after this line until exception\n";
+    for (auto i : range(-10, 0, -1)) {
+        std::cout << i << std::endl;
     }
-    std::cout << "}\n";
 
-    // ranges can work with floats and other types that act like numbers
-    // the normal concerns with comparing floats still hold here
-    std::cout << "range(5.0, 9.9, 0.5): { ";
-    for (auto i : iter::range(5.0, 9.9, 0.5)) {
-        std::cout << i << ' ';
+    for (auto i : range(0, 1, -1)) {
+        std::cout << i << std::endl;
     }
-    std::cout << "}\n";
 
-    // ranges of course support unsigned values
-    std::cout << "range(10u): { ";
-    for (auto i : iter::range(10u)) {
-        std::cout << i << ' ';
+    std::cout << "Should see exception now\n";
+    for (auto i : range(0, 10, 0) ) {
+        std::cout << i << std::endl;
     }
-    std::cout << "}\n";
+
+    return 0;
 }
diff --git a/examples/testrange.cpp b/examples/testrange.cpp
deleted file mode 100644
index 9404ae57..00000000
--- a/examples/testrange.cpp
+++ /dev/null
@@ -1,83 +0,0 @@
-#include <range.hpp>
-
-#include <iostream>
-
-using iter::range;
-
-int main()
-{
-    for (auto i : range(10)) {
-        std::cout << i << std::endl;
-    }
-    for (auto i : range(20, 30)) {
-        std::cout << i << std::endl;
-    }
-    for (auto i : range(50, 60, 2)) {
-        std::cout << i << std::endl;
-    }
-
-    std::cout << "Negative Tests\n";
-    for (auto i: range(-10, 0)) {
-        std::cout << i << std::endl;
-    }
-
-    for (auto i : range(-10, 10, 2)) {
-        std::cout << i << std::endl;
-    }
-
-    std::cout << "Tests where (stop - start)%step != 0" << std::endl;
-    for (auto i : range(1, 10, 2)) {
-        std::cout << i << std::endl;
-    }
-
-    for (auto i : range(-1, -10, -2)) {
-        std::cout << i << std::endl;
-    }
-    
-    std::cout << "Tests with different types" << std::endl;
-    for(auto i : range(5.0, 10.0, 0.5)) {
-        std::cout << i << std::endl;
-    }
-	std::cout << "test unsigned" << std::endl;
-	std::cout << "empty range: " << std::endl;
-	size_t len = 0;
-	for(auto i : range(len)){
-	  std::cout << i << std::endl;
-	}
-	std::cout << "stop only" << std::endl;
-	len = 3;
-	for(auto i : range(len)){
-	  std::cout << i << std::endl;
-	}
-	std::cout << "start stop" << std::endl;
-	size_t start = 1;
-	for(auto i : range(start, len)){
-	  std::cout << i << std::endl;
-	}
-
-	std::cout << "start stop skip" << std::endl;
-	len = 10;
-	size_t skip = 3;
-	for(auto i : range(start, len, skip)){
-	  std::cout << i << std::endl;
-	}
-	
-
-
-    // invalid ranges:
-    std::cout << "Should not print anything after this line until exception\n";
-    for (auto i : range(-10, 0, -1)) {
-        std::cout << i << std::endl;
-    }
-
-    for (auto i : range(0, 1, -1)) {
-        std::cout << i << std::endl;
-    }
-
-    std::cout << "Should see exception now\n";
-    for (auto i : range(0, 10, 0) ) {
-        std::cout << i << std::endl;
-    }
-
-    return 0;
-}

From 0673c8db80bf93fe26b6a85496e7470960bff505 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 2 May 2015 09:17:18 -0700
Subject: [PATCH 1100/1866] replaces testrepeat with repeat examples

---
 examples/repeat_examples.cpp | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 examples/repeat_examples.cpp

diff --git a/examples/repeat_examples.cpp b/examples/repeat_examples.cpp
new file mode 100644
index 00000000..24d37a8d
--- /dev/null
+++ b/examples/repeat_examples.cpp
@@ -0,0 +1,22 @@
+#include <repeat.hpp>
+
+#include <iostream>
+
+int main () {
+    int a = 10;
+    int i = 0;
+
+    std::cout << "repeat(10) breaks after 20: ";
+    for (auto&& num : iter::repeat(a)) { 
+        std::cout << num << ' ';
+        ++i;
+        if (i >= 20) break;
+    }
+    std::cout << '\n';
+
+    std::cout << "repeat(" << a << ", 15): repeats 15 times: ";
+    for (auto&& num : iter::repeat(a,15)) {
+        std::cout << num << ' ';
+    }
+    std::cout << '\n';
+}

From b7c75586ba5b1650b93db06c8daa496a44f35ad6 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 2 May 2015 09:25:55 -0700
Subject: [PATCH 1101/1866] replaces testreversed with reversed examples

---
 examples/reversed_examples.cpp | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 examples/reversed_examples.cpp

diff --git a/examples/reversed_examples.cpp b/examples/reversed_examples.cpp
new file mode 100644
index 00000000..d4d804d9
--- /dev/null
+++ b/examples/reversed_examples.cpp
@@ -0,0 +1,29 @@
+#include <reversed.hpp>
+
+#include <iostream>
+#include <vector>
+#include <string>
+
+int main () {
+    std::vector<int> nums{1,2,3,4,5,6,7};
+    std::vector<std::string> words{"hey","how","are","you","doing"};
+
+    std::cout << "numbers reversed: ";
+    for (auto&& i : iter::reversed(nums)) {
+        std::cout << i << ' ';
+    }
+    std::cout << '\n';
+
+    std::cout << "greeting reversed: ";
+    for (auto&& s : iter::reversed(words)) {
+        std::cout << s << ' ';
+    }
+    std::cout << '\n';
+
+    std::cout << "statically sized array: ";
+    int arr[] = {1, 2, 3, 4, 5, 6, 7};
+    for (auto&& i : iter::reversed(arr)) {
+        std::cout << i << ' ';
+    }
+    std::cout << '\n';
+}

From 540d3b72e4d1528cc9a25285fc37b17ce66ffb2b Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 2 May 2015 09:34:20 -0700
Subject: [PATCH 1102/1866] replaces testsliding_window with examples

---
 examples/sliding_window_examples.cpp | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 examples/sliding_window_examples.cpp

diff --git a/examples/sliding_window_examples.cpp b/examples/sliding_window_examples.cpp
new file mode 100644
index 00000000..3c0d39dd
--- /dev/null
+++ b/examples/sliding_window_examples.cpp
@@ -0,0 +1,22 @@
+#include "sliding_window.hpp"
+
+#include <iostream>
+#include <vector>
+
+int main() {
+    std::vector<int> v = {1,2,3,4,5,6,7,8,9}; 
+    for (auto&& sec : iter::sliding_window(v,4)) {
+        for (auto&& i : sec) {
+            std::cout << i << ' ';
+        }
+        std::cout << '\n';
+    }
+
+    std::cout << "Empty when window size is > length\n";
+    for (auto&& sec : iter::sliding_window({1,2,3}, 10)) {
+        for (auto&& i : sec) {
+            std::cout << i << ' ';
+        }
+        std::cout << '\n';
+    }
+}

From 57b72235ade33a94a4b6a18c2e78db2ca7b858da Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 2 May 2015 09:46:13 -0700
Subject: [PATCH 1103/1866] replaces testsorted with sorted examples

---
 examples/sorted_examples.cpp | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 examples/sorted_examples.cpp

diff --git a/examples/sorted_examples.cpp b/examples/sorted_examples.cpp
new file mode 100644
index 00000000..109d137d
--- /dev/null
+++ b/examples/sorted_examples.cpp
@@ -0,0 +1,33 @@
+#include <sorted.hpp>
+
+#include <iostream>
+#include <vector>
+#include <unordered_set>
+#include <string>
+
+int main() {
+    std::vector<int> vec = {19, 45, 32, 10, 0, 90, 15, 1, 7, 5, 6, 69};
+    std::cout << "sorted(vector): ";
+    for (auto&& i : iter::sorted(vec)) {
+        std::cout << i << ' ';
+    }
+    std::cout << '\n';
+
+    std::cout << "sorted by last character: ";
+    std::vector<std::string> svec = {"hello", "everyone", "thanks", "for",
+                                     "having", "me", "here", "today"};
+    for (auto&& s : iter::sorted(svec,
+                [] (const std::string& s1, const std::string& s2) {
+                    return *s1.rbegin() < *s2.rbegin();})) {
+        std::cout << s << ' ';
+    }
+    std::cout << '\n';
+
+    // works even if the container isn't sortable
+    std::cout << "unordered_set<int> sorted: ";
+    std::unordered_set<int> uset = {10, 1, 20, 4, 50, 3};
+    for (auto&& i : iter::sorted(uset)) {
+        std::cout << i << ' ';
+    }
+    std::cout << '\n';
+}

From 445bac2274db8aaf3f4f95e34e42ef87da3dddd1 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 2 May 2015 09:57:00 -0700
Subject: [PATCH 1104/1866] replaces testtakewhile with takewhile examples

---
 examples/takewhile_examples.cpp | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 examples/takewhile_examples.cpp

diff --git a/examples/takewhile_examples.cpp b/examples/takewhile_examples.cpp
new file mode 100644
index 00000000..3062a141
--- /dev/null
+++ b/examples/takewhile_examples.cpp
@@ -0,0 +1,13 @@
+#include <takewhile.hpp>
+
+#include <vector>
+#include <iostream>
+
+int main() {
+    std::vector<int> ivec{1, 2, 3, 4, 5, 6, 7, 6, 5, 4, 3, 2, 1};
+    std::cout << "take ints as long as they are less than 5: ";
+    for (auto&& i : iter::takewhile([] (int i) {return i < 5;}, ivec)) {
+        std::cout << i << ' ';
+    }
+    std::cout << '\n';
+}

From b6649e83e2d154131dde41f94bc5b5804a2820ef Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 2 May 2015 10:03:04 -0700
Subject: [PATCH 1105/1866] replaces testuniquejustseen with examples

---
 examples/unique_justseen_examples.cpp | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 examples/unique_justseen_examples.cpp

diff --git a/examples/unique_justseen_examples.cpp b/examples/unique_justseen_examples.cpp
new file mode 100644
index 00000000..878cd4f8
--- /dev/null
+++ b/examples/unique_justseen_examples.cpp
@@ -0,0 +1,20 @@
+#include <unique_justseen.hpp>
+
+#include <vector>
+#include <iostream>
+
+int main() {
+    std::cout << "omits consecutive duplicates: ";
+    std::vector<int> v = {1,1,1,2,2,4,4,5,6,7,8,8,8,8,9,9};
+    for (auto&& i : iter::unique_justseen(v)) {
+        std::cout << i << ' ';
+    }
+    std::cout << '\n';
+
+    std::cout << "doesn't omit non-consecutive duplicates: ";
+    std::vector<int> v2 = {1,2,3,2,1,2,3};
+    for (auto&& i : iter::unique_justseen(v2)) {
+        std::cout << i << ' ';
+    }
+    std::cout << '\n';
+}

From 44347d4cd92381c5471bb960fa9378cca574db13 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 2 May 2015 10:15:56 -0700
Subject: [PATCH 1106/1866] replaces testzip_longest with zip_longest examples

---
 examples/zip_longest_examples.cpp | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 examples/zip_longest_examples.cpp

diff --git a/examples/zip_longest_examples.cpp b/examples/zip_longest_examples.cpp
new file mode 100644
index 00000000..1bbffbf8
--- /dev/null
+++ b/examples/zip_longest_examples.cpp
@@ -0,0 +1,29 @@
+#include <zip_longest.hpp>
+
+#include <vector>
+#include <string>
+#include <iostream>
+#include <array>
+#include <boost/optional.hpp>
+
+// prints Just VALUE or Nothing
+template <typename T>
+std::ostream & operator<<(std::ostream & out, const boost::optional<T>& opt) {
+    if (opt) {
+        out << "Just " << *opt;
+    } else {
+        out << "Nothing";
+    }
+    return out;
+}
+
+int main() {
+    std::vector<int> ivec = {1, 4, 9, 16, 25, 36};
+    std::vector<std::string> svec = {"hello", "good day", "goodbye"};
+
+    std::cout << "zipping a vector of strings with a vector of ints:\n";
+    for (auto&& e : iter::zip_longest(ivec, svec)) {
+        std::cout << '(' << std::get<0>(e) << ", "
+            << std::get<1>(e)  << ")\n";
+    }
+}

From 09e3f323bbb0bf6b55b1aef554dc905ffa98df1d Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 2 May 2015 10:26:31 -0700
Subject: [PATCH 1107/1866] replaces testcommand_chains with mixed examples

---
 examples/mixed_examples.cpp | 69 +++++++++++++++++++++++++++++++++++++
 1 file changed, 69 insertions(+)
 create mode 100644 examples/mixed_examples.cpp

diff --git a/examples/mixed_examples.cpp b/examples/mixed_examples.cpp
new file mode 100644
index 00000000..08ff774b
--- /dev/null
+++ b/examples/mixed_examples.cpp
@@ -0,0 +1,69 @@
+#include <itertools.hpp>
+#include <zip_longest.hpp>
+
+#include <vector>
+#include <tuple>
+#include <array>
+#include <iostream>
+#include <string>
+
+template <typename T>
+std::ostream & operator<<(std::ostream & out, const boost::optional<T>& opt) {
+    if (opt) {
+        out << "Just " << *opt;
+    } else {
+        out << "Nothing";
+    }
+    return out;
+}
+int main() {
+    {
+        std::vector<int> vec1{1,2,3,4,5,6};
+        std::vector<int> vec2{1,2,3,4,5};
+        std::vector<std::string> strvec = 
+            {"his","name","was","robert","paulson","his",
+                "name","was","robert","paulson"};
+        for (auto&& t : iter::zip_longest(iter::chain(vec1,vec2),strvec)) {
+            std::cout << std::get<0>(t) << " "
+                << std::get<1>(t) << std::endl;
+        }
+    }
+
+    std::string str = "hello world";
+    std::vector<int> vec = {6, 9, 6, 9};
+    for (auto&& p : iter::enumerate(iter::enumerate(str))) { (void)p; }
+    for (auto&& p : iter::enumerate(iter::zip(str, vec))) { (void)p; }
+
+    std::cout << std::endl;
+    {
+        std::vector<int> vec1{1,2,3,4,5,6};
+        std::vector<int> vec2{7,8,9,10};
+        std::vector<std::string> strvec
+        {"We're","done","when","I","say","we're","done"};
+        for (auto&& t : iter::zip(strvec,
+                    iter::chain(iter::slice(vec1,2,6),
+                        iter::slice(vec2,1,4)))) {
+            std::cout << std::get<0>(t) << " "
+                << std::get<1>(t) << std::endl;
+        }
+    }
+    std::cout << std::endl;
+    {
+        std::vector<int> vec1{1,2,3,4,5,6};
+        std::vector<int> vec2{7,8,9,10};
+        for (auto&& s : iter::sliding_window(iter::chain(vec1,vec2),4)) {
+            for (auto&& i : s) std::cout << i << " ";
+            std::cout<<std::endl;
+        }
+    }
+    std::cout << std::endl;
+
+    auto prod_range = iter::product(iter::range(10), iter::range(5));
+
+    for (auto&& ij: iter::filter(
+                [](std::tuple<unsigned, unsigned> const& c)
+                {return std::get<0>(c) >= std::get<1>(c);},
+                prod_range)) {
+                    std::cout << std::get<0>(ij) << "," << std::get<1>(ij) << std::endl;
+    }
+}

From 4c8307fd0c0b0edb0439a3694ae49ab222ef8712 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 2 May 2015 10:30:39 -0700
Subject: [PATCH 1108/1866] removes old test files

---
 examples/testaccumulate.cpp                   |  35 ------
 examples/testchain.cpp                        |  61 ---------
 examples/testchainfromiterable.cpp            |  28 -----
 examples/testcombinations.cpp                 |  75 -----------
 .../testcombinations_with_replacement.cpp     |  55 --------
 examples/testcommand_chains.cpp               |  78 ------------
 examples/testcompress.cpp                     |  67 ----------
 examples/testcount.cpp                        |  38 ------
 examples/testcycle.cpp                        |  70 -----------
 examples/testdropwhile.cpp                    |  35 ------
 examples/testenumerate.cpp                    |  60 ---------
 examples/testfilter.cpp                       |  83 ------------
 examples/testfilterfalse.cpp                  |  93 --------------
 examples/testgroupby.cpp                      | 109 ----------------
 examples/testgrouper.cpp                      |  51 --------
 examples/testimap.cpp                         |  45 -------
 examples/testpermutations.cpp                 |  60 ---------
 examples/testpowerset.cpp                     |  44 -------
 examples/testproduct.cpp                      |  77 ------------
 examples/testrepeat.cpp                       |  31 -----
 examples/testreversed.cpp                     |  43 -------
 examples/testslice.cpp                        |  81 ------------
 examples/testsliding_window.cpp               |  53 --------
 examples/testsorted.cpp                       |  36 ------
 examples/testtakewhile.cpp                    |  32 -----
 examples/testunique_everseen.cpp              |  41 ------
 examples/testunique_justseen.cpp              |  35 ------
 examples/testzip.cpp                          | 118 ------------------
 examples/testzip_longest.cpp                  |  96 --------------
 tests/.gitignore                              |   5 -
 tests/SConstruct                              |  51 --------
 tests/samples.hpp                             |  98 ---------------
 tests/testaccumulate.cpp                      |  33 -----
 tests/testchain.cpp                           |  61 ---------
 tests/testchainfromiterable.cpp               |  28 -----
 tests/testcombinations.cpp                    |  75 -----------
 tests/testcombinations_with_replacement.cpp   |  55 --------
 tests/testcommand_chains.cpp                  |  78 ------------
 tests/testcompress.cpp                        |  67 ----------
 tests/testcount.cpp                           |  38 ------
 tests/testcycle.cpp                           |  70 -----------
 tests/testdropwhile.cpp                       |  35 ------
 tests/testenumerate.cpp                       |  60 ---------
 tests/testfilter.cpp                          |  83 ------------
 tests/testfilterfalse.cpp                     |  93 --------------
 tests/testgroupby.cpp                         | 109 ----------------
 tests/testgrouper.cpp                         |  51 --------
 tests/testimap.cpp                            |  45 -------
 tests/testpermutations.cpp                    |  60 ---------
 tests/testpowerset.cpp                        |  44 -------
 tests/testproduct.cpp                         |  77 ------------
 tests/testrange.cpp                           |  83 ------------
 tests/testrepeat.cpp                          |  31 -----
 tests/testreversed.cpp                        |  43 -------
 tests/testslice.cpp                           |  81 ------------
 tests/testsliding_window.cpp                  |  53 --------
 tests/testsorted.cpp                          |  36 ------
 tests/testtakewhile.cpp                       |  32 -----
 tests/testunique_everseen.cpp                 |  41 ------
 tests/testunique_justseen.cpp                 |  35 ------
 tests/testzip.cpp                             | 118 ------------------
 tests/testzip_longest.cpp                     |  96 --------------
 62 files changed, 3695 deletions(-)
 delete mode 100644 examples/testaccumulate.cpp
 delete mode 100644 examples/testchain.cpp
 delete mode 100644 examples/testchainfromiterable.cpp
 delete mode 100644 examples/testcombinations.cpp
 delete mode 100644 examples/testcombinations_with_replacement.cpp
 delete mode 100644 examples/testcommand_chains.cpp
 delete mode 100644 examples/testcompress.cpp
 delete mode 100644 examples/testcount.cpp
 delete mode 100644 examples/testcycle.cpp
 delete mode 100644 examples/testdropwhile.cpp
 delete mode 100644 examples/testenumerate.cpp
 delete mode 100644 examples/testfilter.cpp
 delete mode 100644 examples/testfilterfalse.cpp
 delete mode 100644 examples/testgroupby.cpp
 delete mode 100644 examples/testgrouper.cpp
 delete mode 100644 examples/testimap.cpp
 delete mode 100644 examples/testpermutations.cpp
 delete mode 100644 examples/testpowerset.cpp
 delete mode 100644 examples/testproduct.cpp
 delete mode 100644 examples/testrepeat.cpp
 delete mode 100644 examples/testreversed.cpp
 delete mode 100644 examples/testslice.cpp
 delete mode 100644 examples/testsliding_window.cpp
 delete mode 100644 examples/testsorted.cpp
 delete mode 100644 examples/testtakewhile.cpp
 delete mode 100644 examples/testunique_everseen.cpp
 delete mode 100644 examples/testunique_justseen.cpp
 delete mode 100644 examples/testzip.cpp
 delete mode 100644 examples/testzip_longest.cpp
 delete mode 100644 tests/.gitignore
 delete mode 100644 tests/SConstruct
 delete mode 100644 tests/samples.hpp
 delete mode 100644 tests/testaccumulate.cpp
 delete mode 100644 tests/testchain.cpp
 delete mode 100644 tests/testchainfromiterable.cpp
 delete mode 100644 tests/testcombinations.cpp
 delete mode 100644 tests/testcombinations_with_replacement.cpp
 delete mode 100644 tests/testcommand_chains.cpp
 delete mode 100644 tests/testcompress.cpp
 delete mode 100644 tests/testcount.cpp
 delete mode 100644 tests/testcycle.cpp
 delete mode 100644 tests/testdropwhile.cpp
 delete mode 100644 tests/testenumerate.cpp
 delete mode 100644 tests/testfilter.cpp
 delete mode 100644 tests/testfilterfalse.cpp
 delete mode 100644 tests/testgroupby.cpp
 delete mode 100644 tests/testgrouper.cpp
 delete mode 100644 tests/testimap.cpp
 delete mode 100644 tests/testpermutations.cpp
 delete mode 100644 tests/testpowerset.cpp
 delete mode 100644 tests/testproduct.cpp
 delete mode 100644 tests/testrange.cpp
 delete mode 100644 tests/testrepeat.cpp
 delete mode 100644 tests/testreversed.cpp
 delete mode 100644 tests/testslice.cpp
 delete mode 100644 tests/testsliding_window.cpp
 delete mode 100644 tests/testsorted.cpp
 delete mode 100644 tests/testtakewhile.cpp
 delete mode 100644 tests/testunique_everseen.cpp
 delete mode 100644 tests/testunique_justseen.cpp
 delete mode 100644 tests/testzip.cpp
 delete mode 100644 tests/testzip_longest.cpp

diff --git a/examples/testaccumulate.cpp b/examples/testaccumulate.cpp
deleted file mode 100644
index edf3d0a4..00000000
--- a/examples/testaccumulate.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-#include <accumulate.hpp>
-#include <range.hpp>
-
-#include <iostream>
-#include <vector>
-
-int main() {
-    // accumulate with a lambda for subtraction
-    std::vector<int> vec = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
-    for (auto v : iter::accumulate(vec, [](int a, int b){return a - b;})) {
-        std::cout << v << '\n';
-    }
-
-    // using a range instead of a vector
-    for (auto v : iter::accumulate(iter::range(10),
-                [](int a, int b){return a - b;})) {
-        std::cout << v << '\n';
-    }
-
-    // using a range and the default summing behavior
-    for (auto v : iter::accumulate(iter::range(10))) {
-        std::cout << v << '\n';
-    }
-
-
-    for (auto v : iter::accumulate({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})) {
-        std::cout << v << '\n';
-    }
-
-    for (auto v : iter::accumulate(std::vector<int>{1,2,3,4,5,6,7,8,9})) {
-        std::cout << v << '\n';
-    }
-
-    return 0;
-}
diff --git a/examples/testchain.cpp b/examples/testchain.cpp
deleted file mode 100644
index 19ab374d..00000000
--- a/examples/testchain.cpp
+++ /dev/null
@@ -1,61 +0,0 @@
-#include <chain.hpp>
-#include <range.hpp>
-
-#include <vector>
-#include <string>
-#include <iostream>
-#include <array>
-#include <initializer_list>
-
-using iter::chain;
-using il = std::initializer_list<int>; 
-
-int main() {
-
-    {
-        std::vector<int> ivec{1, 4, 7, 9};
-        std::vector<int> lvec{100, 200, 300, 400, 500, 600};
-
-        for (auto e : chain(ivec, lvec)) {
-            std::cout << e << std::endl;
-        }
-    }
-    {
-        std::vector<int> empty{};
-        std::vector<int> vec1{1,2,3,4,5,6};
-        std::array<int,4> arr1{{7,8,9,10}};
-        std::array<int,3> arr2{{11,12,13}};
-        std::cout << std::endl << "Chain iter test" << std::endl;
-        for (auto i : iter::chain(empty,vec1,arr1)) {
-            std::cout << i << std::endl;
-        }
-        std::cout<<std::endl;
-        for (auto i : iter::chain(vec1,empty,arr1)) {
-            std::cout << i << std::endl;
-        }
-        std::cout<<std::endl;
-        for (auto i : iter::chain(vec1,arr1,empty)) {
-            std::cout << i << std::endl;
-        }
-        std::cout<<std::endl;//modifying the range
-        for (auto & i : iter::chain(vec1,arr1,arr2)) {
-            i = 0;//0 out the whole thing
-        }
-        std::cout<<std::endl;
-        for (auto i : iter::chain(vec1,arr1,arr2)) {
-            std::cout << i << std::endl;
-        }
-        //test only works with perfect forwarding
-        std::cout<<std::endl;
-        for (auto i : chain(il{1,2,3,4,5},il{6,7,8,9},il{10,11,12})) {
-            std::cout << i << std::endl;
-        }
-
-        // test with temporaries
-        std::cout << '\n';
-        for (auto i : chain(std::vector<int>{1,2,3,4},
-                    std::array<int,4>{{5,6,7,8}})) {
-            std::cout << i << '\n';
-        }
-    }
-}
diff --git a/examples/testchainfromiterable.cpp b/examples/testchainfromiterable.cpp
deleted file mode 100644
index f4b6d599..00000000
--- a/examples/testchainfromiterable.cpp
+++ /dev/null
@@ -1,28 +0,0 @@
-#include <chain.hpp>
-
-#include <iostream>
-#include <vector>
-
-using iter::chain;
-
-int main() {
-    std::vector<std::vector<int>> matrix = {
-        {1, 2, 3},
-        {4, 5},
-        {6, 8, 9, 10, 11, 12}
-    };
-    for (auto i : chain.from_iterable(matrix)) {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "with temporary\n";
-    for (auto i : chain.from_iterable(std::vector<std::vector<int>>{
-                    {1, 2, 3},
-                    {4, 5},
-                    {6, 8, 9, 10, 11, 12}
-                })) {
-        std::cout << i << '\n';
-    }
-
-    return 0;
-}
diff --git a/examples/testcombinations.cpp b/examples/testcombinations.cpp
deleted file mode 100644
index ee444b90..00000000
--- a/examples/testcombinations.cpp
+++ /dev/null
@@ -1,75 +0,0 @@
-#include "samples.hpp"
-#include <combinations.hpp>
-#include <range.hpp>
-
-#include <vector>
-#include <string>
-#include <iostream>
-#include <array>
-
-using iter::combinations;
-int main() {
-    itertest::DerefByValue dbv; 
-    std::vector<itertest::MoveOnly> mv;
-    for (auto i : iter::range(3)) {
-        mv.emplace_back(i);
-    }
-    std::vector<int> v = {1,2,3,4,5};
-
-    for (auto&& i : combinations(mv,2)) {
-        for (auto&& j : i ) std::cout << j << " ";
-        std::cout<<std::endl;
-    }
-
-    for (auto i : combinations(v,0)) {
-        for (auto j : i ) std::cout << j << " ";
-        std::cout<<std::endl;
-    }
-
-    for (auto i : combinations(v,3)) {
-        for (auto j : i ) std::cout << j << " ";
-        std::cout<<std::endl;
-    }
-
-    for (auto i : combinations(v,1)) {
-        for (auto j : i ) std::cout << j << " ";
-        std::cout<<std::endl;
-    }
-
-    for (auto i : combinations(v,5)) {
-        for (auto j : i ) std::cout << j << " ";
-        std::cout<<std::endl;
-    }
-
-    std::cout << "deref by value\n";
-    for (auto&& i : combinations(dbv, 2)) {
-        for (auto&& j : i) std::cout << j << " ";
-        std::cout << '\n';
-    }
-
-    std::cout << "initializer list\n";
-    for (auto i : combinations({1,2,3,4},3)) {
-        for (auto j : i ) std::cout << j << " ";
-        std::cout<<std::endl;
-
-    }
-
-    std::cout << "initializer list\n";
-    for (auto i : combinations({1,2,3,4},1)) {
-        for (auto j : i ) std::cout << j << " ";
-        std::cout<<std::endl;
-    }
-
-    std::cout << "temporary\n";
-    for (auto i : combinations(std::vector<int>{1,2,3,4,5}, 3)) {
-        for (auto j : i ) std::cout << j << " ";
-        std::cout<<std::endl;
-    }
-
-    std::cout << "static array\n";
-    int array[] = {1,2,3,4,5};
-    for (auto i : combinations(array, 3)) {
-        for (auto j : i) std::cout << j << " ";
-        std::cout << '\n';
-    }
-}
diff --git a/examples/testcombinations_with_replacement.cpp b/examples/testcombinations_with_replacement.cpp
deleted file mode 100644
index 78b8751e..00000000
--- a/examples/testcombinations_with_replacement.cpp
+++ /dev/null
@@ -1,55 +0,0 @@
-#include "samples.hpp"
-#include <combinations_with_replacement.hpp>
-#include <range.hpp>
-
-#include <vector>
-#include <string>
-#include <iostream>
-#include <array>
-
-using iter::combinations_with_replacement;
-
-int main() {
-    std::vector<itertest::MoveOnly> mv;
-    for (auto i : iter::range(3)) {
-        mv.emplace_back(i);
-    }
-
-    std::vector<int> v = {1,2,3,};
-    for (auto i : combinations_with_replacement(v,4)) {
-        for (auto j : i ) std::cout << j << " ";
-        std::cout<<std::endl;
-    }
-
-    itertest::DerefByValue dbv;
-    std::cout << "with deref by value iterator\n";
-    for (auto i : combinations_with_replacement(dbv, 2)) {
-        for (auto j : i ) std::cout << j << " ";
-        std::cout<<std::endl;
-    }
-
-    std::cout << "with container of move-only\n";
-    for (auto i : combinations_with_replacement(mv,2)) {
-        for (auto j : i ) std::cout << j << " ";
-        std::cout<<std::endl;
-    }
-
-    std::cout << "with temporary\n";
-    for (auto i : combinations_with_replacement(std::vector<int>{1,2,3},4)) {
-        for (auto j : i ) std::cout << j << " ";
-        std::cout<<std::endl;
-    }
-
-    std::cout << "with init list\n";
-    for (auto i : combinations_with_replacement({1,2,3},4)) {
-        for (auto j : i ) std::cout << j << " ";
-        std::cout<<std::endl;
-    }
-
-    std::cout << "with static array\n";
-    int arr[] = {1, 2, 3};
-    for (auto i : combinations_with_replacement(arr,4)) {
-        for (auto j : i ) std::cout << j << " ";
-        std::cout<<std::endl;
-    }
-}
diff --git a/examples/testcommand_chains.cpp b/examples/testcommand_chains.cpp
deleted file mode 100644
index e116f131..00000000
--- a/examples/testcommand_chains.cpp
+++ /dev/null
@@ -1,78 +0,0 @@
-#include <itertools.hpp>
-
-#include <vector>
-#include <tuple>
-#include <array>
-#include <iostream>
-#include <string>
-
-using namespace iter;
-
-template <typename T>
-std::ostream & operator<<(std::ostream & out, const boost::optional<T>& opt) {
-    if (opt) {
-        out << "Just " << *opt;
-    } else {
-        out << "Nothing";
-    }
-    return out;
-}
-int main() {
-    {
-        std::vector<int> vec1{1,2,3,4,5,6};
-        std::vector<int> vec2{1,2,3,4,5};
-        std::vector<std::string> strvec
-        {"his","name","was","robert","paulson","his","name","was","robert","paulson"};
-        for (auto t : zip_longest(chain(vec1,vec2),strvec)) {
-            std::cout << std::get<0>(t) << " "
-                << std::get<1>(t) << std::endl;
-        }
-    }
-
-    std::string str = "hello world";
-    std::vector<int> vec = {6, 9, 6, 9};
-    for (auto p : enumerate(enumerate(str))) { (void)p; }
-    for (auto p : enumerate(zip(str, vec))) { (void)p; }
-
-    std::cout << std::endl;
-    {
-        std::vector<int> vec1{1,2,3,4,5,6};
-        std::vector<int> vec2{7,8,9,10};
-        std::vector<std::string> strvec
-        {"We're","done","when","I","say","we're","done"};
-        for (auto t : zip(strvec,chain(slice(vec1,2,6),slice(vec2,1,4)))) {
-            std::cout << std::get<0>(t) << " "
-                << std::get<1>(t) << std::endl;
-        }
-    }
-    std::cout << std::endl;
-    {
-        std::vector<int> vec1{1,2,3,4,5,6};
-        std::vector<int> vec2{7,8,9,10};
-        for (auto s : sliding_window(chain(vec1,vec2),4)) {
-            for (auto i : s) std::cout << i << " ";
-            std::cout<<std::endl;
-        }
-    }
-    std::cout << std::endl;
-
-#if 0
-    {
-        std::vector<int> vec1{1,2,3,4,5,6};
-        std::vector<int> vec2{7,8,9,10};
-        for (auto s : grouper(chain(vec1,vec2),3)) {
-            for (auto i : s) std::cout << i << " ";
-            std::cout<<std::endl;
-        }
-    }
-#endif
-    auto prod_range = iter::product(iter::range(10), iter::range(5));
-
-    for (auto&& ij: iter::filter(
-                [](std::tuple<unsigned, unsigned> const& c)
-                {return std::get<0>(c) >= std::get<1>(c);},
-                prod_range)) {
-                    std::cout << std::get<0>(ij) << "," << std::get<1>(ij) << std::endl;
-    }
-    return 0;
-}
diff --git a/examples/testcompress.cpp b/examples/testcompress.cpp
deleted file mode 100644
index 5197f3e2..00000000
--- a/examples/testcompress.cpp
+++ /dev/null
@@ -1,67 +0,0 @@
-#include <compress.hpp>
-#include <range.hpp>
-
-#include <vector>
-#include <iostream>
-
-using iter::compress;
-using iter::range;
-
-template <typename DataType, typename SelectorType>
-void testcase(std::vector<DataType> data_vec,
-        std::vector<SelectorType> sel_vec)
-{
-
-    for (auto e : compress(data_vec, sel_vec)) {
-        std::cout << e << '\n';
-    }
-}
-
-int main(void)
-{
-    std::vector<int> ivec{1, 2, 3, 4, 5, 6};
-    std::vector<bool> bvec{true, false, true, false, true, false};
-    std::cout << "Should print 1 3 5\n";
-    testcase(ivec, bvec);
-
-    std::vector<bool> bvec2{false, true, false, false, false, true};
-    std::cout << "Should print 2 6\n";
-    testcase(ivec, bvec2);
-
-    std::vector<bool> bvec3{false, true};
-    std::cout << "Should print 2\n";
-    testcase(ivec, bvec3);
-
-    std::cout << "Should print 0 2 4\n";
-    for (auto i : compress(range(10), bvec)) {
-        std::cout << i << '\n';
-    }
-    
-    std::cout << "Should print 0 2 4\n";
-    for (auto i : compress({0,1,2,3,4,5}, bvec)) {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "Should print 0 2 4\n";
-    for (auto i : compress(range(10), {true, false, true, false, true})) {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "Should print 0 2 4\n";
-    for (auto i : compress({0, 1, 2, 3, 4, 5},
-                {true, false, true, false, true}))
-    {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "Should print 0 2 4\n";
-    for (auto i : compress(std::vector<int>{0, 1, 2, 3, 4, 5},
-                std::vector<bool>{true, false, true, false, true}))
-    {
-        std::cout << i << '\n';
-    }
-
-        
-
-    return 0;
-}
diff --git a/examples/testcount.cpp b/examples/testcount.cpp
deleted file mode 100644
index 946d6841..00000000
--- a/examples/testcount.cpp
+++ /dev/null
@@ -1,38 +0,0 @@
-#include <count.hpp>
-
-#include <iostream>
-
-using iter::count;
-
-int main() {
-    for (auto i : count()) {
-        std::cout << i << '\n';
-        if (i == 100) {
-            break;
-        }
-    }
-
-    for (auto i : count(5.0, 0.5)){
-        std::cout << i << '\n';
-        if (i > 100) {
-            break;
-        }
-    }
-
-    for (auto i : count(0, -1)) {
-        std::cout << i << '\n';
-        if (i < -100) {
-            break;
-        }
-    }
-
-    for (auto i : count()) {
-        std::cout << i << '\n';
-        if (i > 10000) {
-            break;
-        }
-    }
-
-
-    return 0;
-}
diff --git a/examples/testcycle.cpp b/examples/testcycle.cpp
deleted file mode 100644
index 138692cc..00000000
--- a/examples/testcycle.cpp
+++ /dev/null
@@ -1,70 +0,0 @@
-#include <cycle.hpp>
-#include <range.hpp>
-
-#include <vector>
-#include <iostream>
-
-using iter::cycle;
-using iter::range;
-
-int main() {
-    std::vector<int> vec = {2, 4, 6};
-
-    size_t count = 0;
-    for (auto i : cycle(vec)) {
-        std::cout << i << '\n';
-        if (count == 100) {
-            break;
-        }
-        ++count;
-    }
-
-    count = 0;
-    int array[] = {68, 69, 70};
-    for (auto i : cycle(array)) {
-        std::cout << i << '\n';
-        if (count == 20) {
-            break;
-        }
-        ++count;
-    }
-
-    count = 0;
-    for (auto i : cycle({7, 8, 9})) {
-        std::cout << i << '\n';
-        if (count == 20) {
-            break;
-        }
-        ++count;
-    }
-
-    count = 0;
-    for (auto i : cycle(range(3))) {
-        std::cout << i << '\n';
-        if (count == 20) {
-            break;
-        }
-        ++count;
-    }
-
-    count = 0;
-    const std::string s("hello");
-    for (auto c : cycle(s)) {
-        std::cout << c << '\n';
-        if (count == 20) {
-            break;
-        }
-        ++count;
-    }
-
-    count = 0;
-    for (auto i : std::vector<int>{1,2,3,4,5}) {
-        std::cout << i << '\n';
-        if (count == 20) {
-            break;
-        }
-        ++count;
-    }
-
-    return 0;
-}
diff --git a/examples/testdropwhile.cpp b/examples/testdropwhile.cpp
deleted file mode 100644
index 3140f81a..00000000
--- a/examples/testdropwhile.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-#include <dropwhile.hpp>
-#include <range.hpp>
-
-#include <vector>
-#include <iostream>
-#include <cassert>
-
-using iter::dropwhile;
-using iter::range;
-
-int main() {
-    std::vector<int> ivec{1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4};
-    for (auto& i : dropwhile([] (int i) {return i < 5;}, ivec)) {
-        std::cout << i << '\n';
-        i = 69;
-    }
-    assert(ivec.at(0) == 1);
-    assert(ivec.at(4) == 69);
-
-    for (auto i : dropwhile([] (int i) {return i < 5;}, range(10))) {
-        std::cout << i << '\n';
-    }
-
-    for (auto i : dropwhile([] (int i) {return i < 5;}, 
-                {1, 2, 3, 4, 5, 6, 7, 8, 9})) {
-        std::cout << i << '\n';
-    }
-
-    for (auto i : dropwhile([] (int i) {return i < 5;}, 
-                std::vector<int>{1, 2, 3, 4, 5, 6, 7, 8, 9})) {
-        std::cout << i << '\n';
-    }
-
-    return 0;
-}
diff --git a/examples/testenumerate.cpp b/examples/testenumerate.cpp
deleted file mode 100644
index fcc1745c..00000000
--- a/examples/testenumerate.cpp
+++ /dev/null
@@ -1,60 +0,0 @@
-#include <enumerate.hpp>
-#include <range.hpp>
-
-#include <string>
-#include <iostream>
-#include <vector>
-
-using iter::enumerate;
-using iter::range;
-
-int main() {
-    std::cout << "const std::string\n";
-    const std::string const_string("goodbye world");
-    for (auto e : enumerate(const_string)) {
-        std::cout << e.index << ": " << e.element << std::endl;
-    }
-
-
-    std::vector<int> vec;
-    for(int i = 0; i < 12; ++i) { 
-        vec.push_back(i * i);
-    }
-
-
-    std::cout << "print vector element, set it to zero, then print it again\n";
-    for (auto e : enumerate(vec)) { 
-        std::cout << e.index << ": " << e.element << std::endl;
-        e.element = 0;
-        // tests to make sure vector can be edited
-        std::cout << e.index << ": " << e.element << std::endl;
-    }
-
-    std::cout << "static array\n";
-    int array[] = {1, 9, 8, 11};
-    for (auto e : enumerate(array)) {
-        std::cout << e.index << ": " << e.element << '\n';
-    }
-
-    std::cout << "initializer list\n";
-    for (auto e : enumerate({0, 1, 4, 9, 16, 25})) {
-        std::cout << e.index << "^2 = " << e.element << '\n';
-    }
-
-    std::cout << "range(10, 20, 2)\n";
-    for (auto e : enumerate(range(10, 20, 2))) {
-        std::cout << e.index << ": " << e.element << '\n';
-    }
-
-    std::cout << "range(10, 20, 2)\n";
-    for (auto e : enumerate(enumerate(range(10, 20, 2)))) {
-        std::cout << e.index << ": " << e.element.element << '\n';
-    }
-
-    std::cout << "vector temporary\n";
-    for (auto e : enumerate(std::vector<int>(5,2))) {
-        std::cout << e.index << ": " << e.element << '\n';
-    }
-
-    return 0;
-}
diff --git a/examples/testfilter.cpp b/examples/testfilter.cpp
deleted file mode 100644
index e8af2aab..00000000
--- a/examples/testfilter.cpp
+++ /dev/null
@@ -1,83 +0,0 @@
-#include <filter.hpp>
-#include <range.hpp>
-
-#include <vector>
-#include <iostream>
-
-using iter::filter;
-
-bool greater_than_four(int i) {
-    return i > 4;
-}
-
-class LessThanValue {
-    private:
-        int compare_val;
-
-    public:
-        LessThanValue() = delete;
-        LessThanValue(int v) : compare_val(v) { }
-        
-        bool operator() (int i) {
-            return i < this->compare_val;
-        }
-};
-
-
-int main() {
-    std::vector<int> vec{1, 5, 6, 7, 2, 3, 8, 3, 2, 1};
-
-    std::cout << "Greater than 4 (function pointer)\n";
-    for (auto i : filter(greater_than_four, vec)) {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "Less than 4 (lambda)\n";
-    for (auto i : filter([] (const int i) { return i < 4; }, vec)) {
-        std::cout << i << '\n';
-    }
-
-    LessThanValue lv(4);
-    std::cout << "Less than 4 (callable object)\n";
-    for (auto i : filter(lv, vec)) {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "Nonzero ints filter(vec2)\n";
-    std::vector<int> vec2 {0, 1, 2, 0, 3, 0, 0, 0, 4, 5, 0};
-    for (auto i : filter(vec2)) {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "odd numbers in range(10) temp\n";
-    for (auto i : filter([] (const int i) {return i % 2;}, iter::range(10))) {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "range(-1, 2)\n";
-    for (auto i : filter(iter::range(-1, 2))) {
-        std::cout << i << '\n';
-    }
-
-
-    std::cout << "ever numbers in initializer_list\n";
-    for (auto i : filter([] (const int i) {return i % 2 == 0;},
-                         {1, 2, 3, 4, 5, 6, 7}))
-    {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "default in initialization_list\n";
-    for (auto i : filter({-2, -1, 0, 0, 0, 1, 2})) {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "ever numbers in vector temporary\n";
-    for (auto i : filter([] (const int i) {return i % 2 == 0;},
-                         std::vector<int>{1, 2, 3, 4, 5, 6, 7}))
-    {
-        std::cout << i << '\n';
-    }
-
-    return 0;
-}
diff --git a/examples/testfilterfalse.cpp b/examples/testfilterfalse.cpp
deleted file mode 100644
index 9063d0bf..00000000
--- a/examples/testfilterfalse.cpp
+++ /dev/null
@@ -1,93 +0,0 @@
-#include <filterfalse.hpp>
-#include <range.hpp>    
-
-#include <vector>
-#include <iostream>
-
-using iter::filterfalse;
-using iter::range;
-
-bool greater_than_four(int i) {
-    return i > 4;
-}
-
-class LessThanValue {
-    private:
-        int compare_val;
-
-    public:
-        LessThanValue() = delete;
-        LessThanValue(int v) : compare_val(v) { }
-        
-        bool operator() (int i) const {
-            return i < this->compare_val;
-        }
-};
-
-
-int main() {
-    std::vector<int> vec{1, 5, 6, 7, 2, 3, 8, 3, 2, 1};
-
-    std::cout << "Greater than 4 (function pointer)\n";
-    for (auto i : filterfalse(greater_than_four, vec)) {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "Less than 4 (lambda)\n";
-    for (auto i : filterfalse([] (const int i) { return i < 4; }, vec)) {
-        std::cout << i << '\n';
-    }
-
-    LessThanValue lv(4);
-    std::cout << "Less than 4 (callable object)\n";
-    for (auto i : filterfalse(lv, vec)) {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "zero ints filter(vec2)\n";
-    std::vector<int> vec2 {0, 1, 2, 0, 3, 0, 0, 0, 4, 5, 0};
-    for (auto i : filterfalse(vec2)) {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "Constness tests\n";
-    const std::vector<int> cvec(vec);
-    for (auto i : filterfalse(greater_than_four, cvec)) {
-        std::cout << i << '\n';
-    }
-
-    for (auto i : filterfalse([] (const int & i) { return i < 4; }, cvec)) {
-        std::cout << i << '\n';
-    }
-
-
-    std::cout << "i%2 with range(10), should print even numbers\n";
-    for (auto i : filterfalse([] (const int i) { return i % 2; }, range(10))) {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "range(-1, 2)\n";
-    for (auto i : filterfalse(range(-1, 2))) {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "initializer_list\n";
-    for (auto i : filterfalse([] (const int i) { return  i % 2; },
-                {10, 11, 12, 13, 14, 15, 16}))
-    {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "initializer_list with default\n";
-    for (auto i : filterfalse({-1, -2, 0, 0, 0, 0, 1, 2, 3})) {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "vector temporary with default\n";
-    for (auto i : filterfalse(
-                std::vector<int>{-1, -2, 0, 0, 0, 0, 1, 2, 3})) {
-        std::cout << i << '\n';
-    }
-
-    return 0;
-}
diff --git a/examples/testgroupby.cpp b/examples/testgroupby.cpp
deleted file mode 100644
index 9fc03ee3..00000000
--- a/examples/testgroupby.cpp
+++ /dev/null
@@ -1,109 +0,0 @@
-#include <groupby.hpp>
-
-#include <vector>
-#include <iostream>
-#include <string>
-
-using iter::groupby;
-
-
-int length(std::string s)
-{
-    return s.length();
-}
-
-int main()
-{
-    std::vector<std::string> vec = {
-        "hi", "ab", "ho",
-        "abc", "def",
-        "abcde", "efghi"
-    };
-
-    for (auto gb : groupby(vec, &length)) {
-        std::cout << "key: " << gb.first << '\n';
-        std::cout << "content: ";
-        for (auto s : gb.second) {
-            std::cout << s << "  ";
-        }
-        std::cout << '\n';
-    }
-
-    for (auto gb : groupby(vec, [] (const std::string &s) {return s.length(); })) {
-        std::cout << "key: " << gb.first << '\n';
-        std::cout << "content: ";
-        for (auto s : gb.second) {
-            std::cout << s << "  ";
-        }
-        std::cout << '\n';
-    }
-
-    std::cout << "skipping length of 3\n";
-    for (auto gb : groupby(vec, &length)) {
-        if (gb.first == 3) {
-            continue;
-        }
-        std::cout << "key: " << gb.first << '\n';
-        std::cout << "content: ";
-        for (auto s : gb.second) {
-            std::cout << s << "  ";
-        }
-        std::cout << '\n';
-    }
-   
-
-    std::vector<int> ivec = {5, 5, 6, 6, 19, 19, 19, 19, 69, 0, 10, 10};
-    for (auto gb : groupby(ivec)) {
-        std::cout << "key: " << gb.first << '\n';
-        std::cout << "content: ";
-        for (auto s : gb.second) {
-            std::cout << s << "  ";
-        }
-        std::cout << '\n';
-    }
-
-    for (auto gb : groupby("aabbccccdd", [] (const char c) {return c < 'c';})){
-        std::cout << "key: " << gb.first << '\n';
-        std::cout << "content: ";
-        for (auto s : gb.second) {
-            std::cout << s << "  ";
-        }
-        std::cout << '\n';
-    }
-    
-    for (auto gb : groupby({'a', 'a', 'b', 'b', 'c'})) {
-        std::cout << "key: " << gb.first << '\n';
-        std::cout << "content: ";
-        for (auto s : gb.second) {
-            std::cout << s << "  ";
-        }
-        std::cout << '\n';
-    }
-
-    for (auto gb : groupby({'a', 'a', 'b', 'b', 'c', 'c', 'd', 'd'},
-                [] (const char c) {return c < 'c'; })) {
-        std::cout << "key: " << gb.first << '\n';
-        std::cout << "content: ";
-        for (auto s : gb.second) {
-            std::cout << s << "  ";
-        }
-        std::cout << '\n';
-    }
-
-    std::cout << "with vector temporary:\n";
-    for (auto gb : groupby(
-                std::vector<char>{'a', 'a', 'b', 'b', 'c', 'c', 'd', 'd'},
-                [] (const char c) {return c < 'c'; })) {
-        std::cout << "key: " << gb.first << '\n';
-        std::cout << "content: ";
-        for (auto s : gb.second) {
-            std::cout << s << "  ";
-        }
-        std::cout << '\n';
-    }
-        
-
-    return 0;
-}
-
-    
diff --git a/examples/testgrouper.cpp b/examples/testgrouper.cpp
deleted file mode 100644
index b16ebc98..00000000
--- a/examples/testgrouper.cpp
+++ /dev/null
@@ -1,51 +0,0 @@
-#include "grouper.hpp"
-#include <iostream>
-#include <vector>
-using iter::grouper;
-int main() {
-    std::vector<int> v {1,2,3,4,5,6,7,8,9}; 
-    for (auto sec : grouper(v,4)) {
-        for (auto i : sec) {
-            std::cout << i << " ";
-            i.get() *= 2;
-        }
-        std::cout << '\n';
-    }
-
-    for (auto sec : grouper(std::vector<int>{1,2,3,4,5,6,7,8,9}, 4)) {
-        for (auto i : sec) {
-            std::cout << i << " ";
-            i.get() *= 2;
-        }
-        std::cout << '\n';
-    }
-
-    for (auto sec : grouper(v,3)) {
-        for (auto i : sec) {
-            std::cout << i << " ";
-        }
-        std::cout << '\n';
-    }
-    std::vector<int> empty {};
-    for (auto sec : grouper(empty,3)) {
-        std::cout << "Shouldn't print\n";
-        for (auto i : sec) {
-            std::cout << i << " Shouldn't print\n";
-        }
-    }
-
-    int arr[] = {1,2,3,4,5,6,7};
-    for (auto sec : grouper(arr, 2)) {
-        for (auto i : sec) {
-            std::cout << i << ' ';
-        }
-        std::cout << '\n';
-    }
-
-    for (auto sec : grouper({1,2,3,4,5,6,7}, 2)) {
-        for (auto i : sec) {
-            std::cout << i << ' ';
-        }
-        std::cout << '\n';
-    }
-}
diff --git a/examples/testimap.cpp b/examples/testimap.cpp
deleted file mode 100644
index 3d6f38ca..00000000
--- a/examples/testimap.cpp
+++ /dev/null
@@ -1,45 +0,0 @@
-#include <imap.hpp>
-#include <range.hpp>
-
-#include <vector>
-#include <iostream>
-
-using iter::imap;
-
-int main() {
-    std::vector<int> vec1 = {1, 2, 3, 4, 5, 6};
-    std::vector<int> vec2 = {10, 20, 30, 40, 50, 60};
-    for (auto i : imap([] (int x, int y) { return x + y; }, vec1, vec2)) {
-        std::cout << i << '\n';
-    }
-
-    std::vector<int> vec3 = {100, 200, 300, 400, 500, 600};
-    for (auto i : imap([] (int a, int b, int c) { return a + b + c; }, 
-                vec1, vec2, vec3)) {
-        std::cout << i << '\n';
-    }
-
-    for (auto i : imap([] (int i) {return i * i; }, vec1)) {
-        std::cout << i << '\n';
-    }
-
-    std::vector<int> vec{1, 2, 3, 4, 5};
-    for (auto i : imap([] (int x) {return x * x;}, vec)) {
-        std::cout << i << '\n';
-    }
-
-    std::vector<int> vec4{1, 2, 3};
-    for (auto i : imap([] (int a, int b) { return a + b; }, vec, vec4)) {
-        std::cout << i << '\n';
-    }
-
-    for (auto i : imap([] (const int x) { return x*x; }, iter::range(10))) {
-        std::cout << i << '\n';
-    }
-
-    for (auto i : imap([] (const int x) { return x*x; },
-                       std::vector<int>{1,2,3,4,5})){
-        std::cout << i << '\n';
-    }
-    return 0;
-}
diff --git a/examples/testpermutations.cpp b/examples/testpermutations.cpp
deleted file mode 100644
index a73a2a3b..00000000
--- a/examples/testpermutations.cpp
+++ /dev/null
@@ -1,60 +0,0 @@
-#include "samples.hpp"
-
-#include <permutations.hpp>
-#include <range.hpp>
-
-#include <iostream>
-#include <vector>
-#include <string>
-
-int main() {
-    using iter::permutations;
-    std::vector<int> v = {1,2,3};
-    for (auto vec : permutations(v)) {
-        for (auto i : vec) {
-            std::cout << i << " ";
-        }
-        std::cout << std::endl;
-    }
-    //try with string
-    std::string s = "aba";
-    for (auto vec : permutations(s)) {
-        for (auto c : vec) {
-            std::cout << c << " ";
-        }
-        std::cout << std::endl;
-    }
-    s = "abc";
-    for (auto vec : permutations(s)) {
-        for (auto c : vec) {
-            std::cout << c << " ";
-        }
-        std::cout << std::endl;
-    }
-
-    std::cout << "init list\n";
-    //std::next_permutation doesn't work on initializer_lists
-    for (auto vec : permutations({1,2,3,4})) {
-        for (auto c : vec) {
-            std::cout << c << " ";
-        }
-        std::cout << std::endl;
-    }
-
-    std::cout << "with container of move-only objects\n";
-    std::vector<itertest::MoveOnly> mv;
-    for (auto i : iter::range(3)) {
-        mv.emplace_back(i);
-    }
-    for (auto v : permutations(mv)) {
-        for (auto i : v) std::cout << i << " ";
-        std::cout << std::endl;
-    }
-
-    std::cout << "with deref-by-value iterator\n";
-    itertest::DerefByValue dbv;
-    for (auto v : permutations(dbv)) {
-        for (auto i : v) std::cout << i << " ";
-        std::cout << std::endl;
-    }
-}
diff --git a/examples/testpowerset.cpp b/examples/testpowerset.cpp
deleted file mode 100644
index 20ca0098..00000000
--- a/examples/testpowerset.cpp
+++ /dev/null
@@ -1,44 +0,0 @@
-#include "samples.hpp"
-#include <powerset.hpp>
-#include <range.hpp>
-#include <vector>
-#include <iostream>
-
-using iter::powerset;
-
-int main() {
-    std::vector<int> vec {1,2,3,4,5,6,7,8,9};
-    for (auto v : powerset(vec)) {
-        for (auto i : v) std::cout << i << " ";
-        std::cout << std::endl;
-    }
-    std::cout << "with temporary\n";
-    for (auto v : powerset(std::vector<int>{1,2,3})) {
-        for (auto i : v) std::cout << i << " ";
-        std::cout << std::endl;
-    }
-    std::cout << "with initializer_list\n";
-    for (auto v : powerset({1,2,3})) {
-        for (auto i : v) std::cout << i << " ";
-        std::cout << std::endl;
-    }
-
-    std::cout << "with container of move-only objects\n";
-    std::vector<itertest::MoveOnly> mv;
-    for (auto i : iter::range(3)) {
-        mv.emplace_back(i);
-    }
-    for (auto v : powerset(mv)) {
-        for (auto i : v) std::cout << i << " ";
-        std::cout << std::endl;
-    }
-
-    std::cout << "with deref-by-value iterator\n";
-    itertest::DerefByValue dbv;
-    for (auto v : powerset(dbv)) {
-        for (auto i : v) std::cout << i << " ";
-        std::cout << std::endl;
-    }
-
-    return 0;
-}
diff --git a/examples/testproduct.cpp b/examples/testproduct.cpp
deleted file mode 100644
index 22d132ec..00000000
--- a/examples/testproduct.cpp
+++ /dev/null
@@ -1,77 +0,0 @@
-#include "samples.hpp"
-
-#include <product.hpp>
-#include <range.hpp>
-
-#include <vector>
-#include <iostream>
-#include <string>
-
-using iter::product;
-int main() {
-
-    std::vector<itertest::MoveOnly> mv;
-    for (auto i : iter::range(10)) {
-        mv.emplace_back(i);
-    }
-    std::vector<int> empty{};
-    std::vector<int> v1{1,2,3};
-    std::vector<int> v2{7,8};
-    std::vector<std::string> v3{"the","cat"};
-    std::vector<std::string> v4{"hi","what","up","dude"};
-
-    for (auto t : product(v1, mv)) {
-        std::cout << std::get<0>(t) << ", "
-            << std::get<1>(t) << std::endl;
-    }
-    for (auto t : product(empty,v1)) {
-        std::cout << std::get<0>(t) << ", "
-            << std::get<1>(t) << std::endl;
-    }
-    for (auto t : product(v1,empty)) {
-        std::cout << std::get<0>(t) << ", "
-            << std::get<1>(t) << std::endl;
-    }
-    std::cout<<std::endl;
-    for (auto t : product(v1,v2)) {
-        std::cout << std::get<0>(t) << ", "
-            << std::get<1>(t) << std::endl;
-    }
-    std::cout<<std::endl;
-    for (auto t : product(v1,v2,v3,v4)) {
-        std::cout << std::get<0>(t) << ", "
-            << std::get<1>(t) << ", "
-            << std::get<2>(t) << ", " 
-            << std::get<3>(t) << std::endl;
-    }
-    std::cout<<std::endl;
-    for (auto t : product(v1)) {
-        std::cout << std::get<0>(t)  << std::endl;
-    }
-    std::cout<<std::endl;
-    for (auto t : product(v1,v4)) {
-        std::cout << std::get<0>(t) << ", "
-          << std::get<1>(t)  << std::endl;
-    }
-    std::cout << '\n';
-
-    for (auto t : product()) { t=t; }
-
-    for (auto t : product(std::string{"hi"}, v1)) {
-        std::cout << std::get<0>(t) << ", "
-            << std::get<1>(t) << std::endl;
-    }
-    std::cout << '\n';
-
-    int arr[] = {1,2};
-    for (auto t : product(std::string{"hi"}, arr)) {
-        std::cout << std::get<0>(t) << ", "
-            << std::get<1>(t) << std::endl;
-    }
-    std::cout << '\n';
-    for (auto&& ij: iter::product(iter::range(10), iter::range(5))) {
-        std::cout << std::get<0>(ij) << "," << std::get<1>(ij) << std::endl;
-    }
-
-    return 0;
-}
diff --git a/examples/testrepeat.cpp b/examples/testrepeat.cpp
deleted file mode 100644
index b91fba03..00000000
--- a/examples/testrepeat.cpp
+++ /dev/null
@@ -1,31 +0,0 @@
-#include "repeat.hpp"
-#include <iostream>
-#include <vector>
-#include <array>
-#include <string>
-#include <memory>
-
-int main () {
-    int a = 10;
-    int i = 0;
-    for (auto num : iter::repeat(a)) {//goes infintely
-        std::cout << num << std::endl;
-        ++i;
-        if (i > 20) break;
-    }
-    std::cout<<std::endl;
-    for (auto num : iter::repeat(a,10)) {//goes ten times
-        std::cout << num << std::endl;
-    }
-    
-    std::cout << "with temporary\n";
-    for (auto s : iter::repeat(std::string{"hey"}, 2)) {
-        std::cout <<  s << '\n';
-    }
-
-    std::cout << "with uptr temporary\n";
-    for (auto& p : iter::repeat(std::unique_ptr<int>{new int{2}}, 2)) {
-        std::cout << *p << '\n';
-    }
-
-}
diff --git a/examples/testreversed.cpp b/examples/testreversed.cpp
deleted file mode 100644
index c6d0ab46..00000000
--- a/examples/testreversed.cpp
+++ /dev/null
@@ -1,43 +0,0 @@
-#include <reversed.hpp>
-
-#include <iostream>
-#include <vector>
-#include <array>
-#include <string>
-
-int main () {
-    std::vector<int> a{1,2,3,4,5,6,7};
-    std::vector<std::string> b{"hey","how","are","you","doing"};
-    std::cout << std::endl << "reversed range test" << std::endl << std::endl;
-    for (auto i : iter::reversed(a)) {
-        std::cout << i << std::endl;
-    }
-    std::cout<<std::endl;
-    //modify a
-    for (auto & i : iter::reversed(a)) {
-        std::cout << i << std::endl;
-        i = 9;
-    }
-    std::cout<<std::endl;
-    for (auto i : iter::reversed(a)) {
-        std::cout << i << std::endl;
-    }
-    std::cout<<std::endl;
-    //try strings
-    for (auto s : iter::reversed(b)) {
-        std::cout << s << std::endl;
-    }
-
-    std::cout << "with temporary\n";
-    for (auto i : iter::reversed(std::vector<int>{1, 2, 3, 4, 5, 6, 7})) {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "statically sized array\n";
-    int arr[] = {1, 2, 3, 4, 5, 6, 7};
-    for (auto i : iter::reversed(arr)) {
-        std::cout << i << '\n';
-    }
-
-
-}
diff --git a/examples/testslice.cpp b/examples/testslice.cpp
deleted file mode 100644
index eaf8e1ce..00000000
--- a/examples/testslice.cpp
+++ /dev/null
@@ -1,81 +0,0 @@
-#include <iostream>
-
-#include <slice.hpp>
-#include <range.hpp>
-
-#include <vector>
-#include <array>
-
-int main() {
-    std::cout << std::endl << "Slice range test" << std::endl << std::endl;
-    std::vector<int> a{0,1,2,3,4,5,6,7,8,9,10,11,12,13};
-    std::vector<std::string> b{"hey","how","are","you","doing"};
-
-    std::cout << "step out of slice\n";
-    for (auto i : iter::slice(a, 1, 4, 5)) {
-        std::cout << i << '\n';
-    }
-    std::cout << "end step out\n";
-
-    for (auto i : iter::slice(a,2)) {
-        std::cout << i << std::endl;
-    }
-    std::cout<<std::endl;
-    for (auto & s : iter::slice(b,3,4)) {
-        std::cout << s << std::endl;
-        s = "test";
-    }
-    std::cout<<std::endl;
-    for (auto s : b) {
-        std::cout << s << std::endl;
-    }
-    std::cout<<std::endl;
-    for (auto i : iter::slice(a,0,15,3)) {
-        std::cout << i << std::endl;
-    }
-
-    std::cout<< "\n13 down to 0\n";
-    for (auto i : iter::slice(a,13,-1,-1)) {
-        std::cout << i << std::endl;
-    }
-
-    std::cout<< "\nunevent step [0:5:3]\n";
-    for (auto i : iter::slice(a, 0, 5, 3)) {
-        std::cout << i << '\n';
-    }
-
-    std::cout<< "\nInvalid range [1:10:-1]\n";
-    for (auto i : iter::slice(a,1,10,-1)) {
-        //invalid range returns two begin iters
-        std::cout << i << std::endl;
-    }
-    std::cout<< "\nOversize range [1:100:1]\n";
-    for (auto i : iter::slice(a,1,100,1)) {
-        //invalid range returns two begin iters
-        std::cout << i << std::endl;
-    }
-    std::cout<< "\nOversize range and undersize[1:100:1]\n";
-    for (auto i : iter::slice(a,-100,100,1)) {
-        //invalid range returns two begin iters
-        std::cout << i << std::endl;
-    }
-
-    std::cout<< "\nstatic array[1:8:2]\n";
-    int arr[10] = {0,1,2,3,4,5,6,7,8,9};
-    for (auto i : iter::slice(arr,1,8,2)) {
-        //invalid range returns two begin iters
-        std::cout << i << std::endl;
-    }
-
-    std::cout << "\ninitializer list\n";
-    for (auto i : iter::slice({1, 2, 4, 8, 16, 32, 64, 128}, 2, 6)) {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "\nvector temporary\n";
-    for (auto i : iter::slice(
-                std::vector<int>{1, 2, 4, 8, 16, 32, 64, 128}, 2, 6)) {
-        std::cout << i << '\n';
-    }
-
-}
diff --git a/examples/testsliding_window.cpp b/examples/testsliding_window.cpp
deleted file mode 100644
index 16708db7..00000000
--- a/examples/testsliding_window.cpp
+++ /dev/null
@@ -1,53 +0,0 @@
-#include "sliding_window.hpp"
-
-#include <iostream>
-#include <vector>
-
-using iter::sliding_window;
-
-int main() {
-    std::vector<int> v = {1,2,3,4,5,6,7,8,9}; 
-    for (auto sec : sliding_window(v,4)) {
-        for (auto i : sec) {
-            std::cout << i << " ";
-            i.get() = 90;
-        }
-        std::cout << std::endl;
-    }
-
-    std::cout << "with temporary\n";
-    for (auto sec : sliding_window(std::vector<int>{1,2,3,4,5,6,7,8,9}, 4)) {
-        for (auto i : sec) {
-            std::cout << i << " ";
-            i.get() = 90;
-        }
-        std::cout << std::endl;
-    }
-
-    std::cout << "with init list\n";
-    for (auto sec : sliding_window({1,2,3,4,5,6,7,8,9}, 4)) {
-        for (auto i : sec) {
-            std::cout << i << " ";
-        }
-        std::cout << std::endl;
-    }
-
-    std::cout << "with window_size > length\n";
-    for (auto sec : sliding_window({1,2,3}, 10)) {
-        for (auto i : sec) {
-            std::cout << i << " ";
-        }
-        std::cout << std::endl;
-    }
-
-    std::cout << "with static array\n";
-    int arr[] = {1,2,3,4,5,6,7,8,9};
-    for (auto sec : sliding_window(arr, 4)) {
-        for (auto i : sec) {
-            std::cout << i << " ";
-        }
-        std::cout << std::endl;
-    }
-
-    return 0;
-}
diff --git a/examples/testsorted.cpp b/examples/testsorted.cpp
deleted file mode 100644
index aed57d32..00000000
--- a/examples/testsorted.cpp
+++ /dev/null
@@ -1,36 +0,0 @@
-#include <sorted.hpp>
-
-#include <iostream>
-#include <vector>
-#include <string>
-
-using iter::sorted;
-
-int main()
-{
-    std::vector<int> vec = {19, 45, 32, 10, 0, 90, 15, 1, 7, 5, 6, 69};
-    for (auto i : sorted(vec)) {
-        std::cout << i << '\n';
-    }
-
-    const std::vector<int> cvec(vec);
-    for (auto i : sorted(cvec)) {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "Sort by first character only\n";
-    std::vector<std::string> svec = {"hello", "everyone", "thanks", "for",
-                                     "having", "me", "here", "today"};
-    for (auto s : sorted(svec,
-                [] (const std::string & s1, const std::string & s2) {
-                    return s1[0] < s2[0]; })) {
-        std::cout << s << '\n';
-    }
-        
-
-    for (auto i : sorted(
-                std::vector<int>{19, 45, 32, 10, 0, 90, 15, 1, 7, 5, 6, 69})) {
-        std::cout << i << '\n';
-    }
-    return 0;
-}
diff --git a/examples/testtakewhile.cpp b/examples/testtakewhile.cpp
deleted file mode 100644
index bec3aeae..00000000
--- a/examples/testtakewhile.cpp
+++ /dev/null
@@ -1,32 +0,0 @@
-#include <takewhile.hpp>
-#include <range.hpp>
-
-#include <vector>
-#include <iostream>
-
-using iter::takewhile;
-using iter::range;
-
-int main() {
-    std::vector<int> ivec{1, 2, 3, 4, 5, 6, 7, 6, 5, 4, 3, 2, 1};
-    for (auto i : takewhile([] (int i) {return i < 5;}, ivec)) {
-        std::cout << i << '\n';
-    }
-
-    for (auto i : takewhile([] (int i) {return i < 5;}, range(10))) {
-        std::cout << i << '\n';
-    }
-
-    for (auto i : takewhile([] (int i) {return i < 5;}, 
-                {1, 2, 3, 4, 5, 6, 7, 8, 9})) {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "with temporary\n";
-    for (auto i : takewhile([] (int i) {return i < 5;}, 
-                std::vector<int>{1, 2, 3, 4, 5, 6, 7, 8, 9})) {
-        std::cout << i << '\n';
-    }
-
-    return 0;
-}
diff --git a/examples/testunique_everseen.cpp b/examples/testunique_everseen.cpp
deleted file mode 100644
index 015adb7d..00000000
--- a/examples/testunique_everseen.cpp
+++ /dev/null
@@ -1,41 +0,0 @@
-
-#include <vector>
-#include <iostream>
-
-#include <unique_everseen.hpp>
-using iter::unique_everseen;
-
-int main() {
-    {
-        //should work same as justseen here
-        std::vector<int> v {1,1,1,2,2,3,4,4,5,6,7,8,8,8,8,9,9};
-        for (auto i : unique_everseen(v)) {
-            std::cout << i << " ";
-        }std::cout << std::endl;
-    }
-    {
-        std::vector<int> v {1,2,3,4,3,2,1,5,6,7,7,8,9,8,9,6};
-        for (auto i : unique_everseen(v)) {
-            std::cout << i << " ";
-        }std::cout << std::endl;
-    }
-
-    for (auto i : unique_everseen(
-                std::vector<int>{1,2,1,3,4,3,2,1,5,6,7,7,8,9,8,9,6})) {
-        std::cout << i << " ";
-    }
-    std::cout << std::endl;
-
-    int arr[] = {1,2,1,3,4,3,2,1,5,6,7,7,8,9,8,9,6};
-    for (auto i : unique_everseen(arr)) {
-        std::cout << i << ' ';
-    }
-    std::cout << '\n';
-
-    for (auto i : unique_everseen({1,2,1,3,4,3,2,1,5,6,7,7,8,9,8,9,6})) {
-        std::cout << i << ' ';
-    }
-    std::cout << '\n';
-
-    return 0;
-}
diff --git a/examples/testunique_justseen.cpp b/examples/testunique_justseen.cpp
deleted file mode 100644
index 8f454b6d..00000000
--- a/examples/testunique_justseen.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-
-#include <vector>
-#include <iostream>
-
-#include <unique_justseen.hpp>
-using iter::unique_justseen;
-
-int main() {
-    std::vector<int> v {1,1,1,2,2,4,4,5,6,7,8,8,8,8,9,9};
-    for (auto i : unique_justseen(v)) {
-        std::cout << i << " ";
-    }
-    std::cout << '\n';
-
-    std::cout << "with temporary\n";
-    for (auto i : unique_justseen(std::vector<int>{1,1,1,2,3,3})) {
-        std::cout << i << " ";
-    }
-    std::cout << '\n';
-
-    std::cout << "with init list\n";
-    for (auto i : unique_justseen({1,1,1,2,3,3})) {
-        std::cout << i << " ";
-    }
-    std::cout << '\n';
-
-    std::cout << "with static array\n";
-    int arr[] = {1, 1, 2, 3, 3, 3, 4};
-    for (auto i : unique_justseen(arr)) {
-        std::cout << i << " ";
-    }
-    std::cout << '\n';
-
-    return 0;
-}
diff --git a/examples/testzip.cpp b/examples/testzip.cpp
deleted file mode 100644
index 76a95fd7..00000000
--- a/examples/testzip.cpp
+++ /dev/null
@@ -1,118 +0,0 @@
-#include <zip.hpp>
-#include <chain.hpp>
-#include <range.hpp>
-
-#include <vector>
-#include <string>
-#include <iostream>
-#include <array>
-#include <cassert>
-
-using iter::zip;
-
-int main() {
-    //Ryan's test
-    {
-        for (auto t : zip()) { t=t; }
-
-        std::vector<int> ivec{1, 4, 9, 16, 25, 36};
-        std::vector<std::string> svec{"hello", "good day", "goodbye"};
-
-        constexpr int magic_value = 69;
-        for (auto e : zip(ivec, svec)) {
-            auto &i = std::get<0>(e);
-            std::cout << i << std::endl;
-            i = magic_value;
-            std::cout << std::get<1>(e) << std::endl;
-        }
-        assert(ivec.at(0) == magic_value);
-        for (auto e : zip(ivec, svec)) {
-            std::cout << std::get<0>(e) << std::endl;
-            std::cout << std::get<1>(e) << std::endl;
-        }
-
-        for (auto e : zip(std::vector<int>{5,6,7})) {
-            std::cout << std::get<0>(e) << std::endl;
-        }
-        for (auto e : zip(std::vector<int>{5,6,7}, std::array<int,2>{{1,2}})){
-            std::cout << std::get<0>(e) << std::endl;
-            std::cout << std::get<1>(e) << std::endl;
-        }
-
-        for (auto e : zip(iter::range(10), iter::range(10, 20))) {
-            std::cout << std::get<0>(e) << '\n';
-            std::cout << std::get<1>(e) << '\n';
-        }
-
-        int arr[] = {1,2,3,3,4};
-        for (auto e : zip(iter::range(10), arr)) {
-            std::cout << std::get<0>(e) << '\n';
-            std::cout << std::get<1>(e) << '\n';
-        }
-            
-    }
-    //Aaron's test
-    {
-        std::array<int,4> i{{1,2,3,4}};
-        std::vector<float> f{1.2,1.4,12.3,4.5,9.9};
-        std::vector<std::string> s{"i","like","apples","alot","dude"};
-        std::array<double,5> d{{1.2,1.2,1.2,1.2,1.2}};
-        std::cout << std::endl << "Variadic template zip iterator" << std::endl;
-        for (auto e : iter::zip(i,f,s,d)) {
-            std::cout << std::get<0>(e) << " " 
-                << std::get<1>(e) << " " 
-                << std::get<2>(e) << " "
-                << std::get<3>(e) << std::endl;
-            std::get<1>(e)=2.2f; //modify the float array
-        }
-        std::cout<<std::endl;
-        for (auto e : iter::zip(i,s,f,d)) {
-            std::cout << std::get<0>(e) << " " 
-                << std::get<1>(e) << " "
-                << std::get<2>(e) << " " 
-                << std::get<3>(e) << std::endl;
-        }
-        std::cout << std::endl << "Try some weird range differences" << std::endl;
-        std::vector<int> empty{};
-        for (auto e : iter::zip(empty,f,s,d)) {
-            std::cout << std::get<0>(e) << " " 
-                << std::get<1>(e) << " " 
-                << std::get<2>(e) << " "
-                << std::get<3>(e) << std::endl;
-        }
-        std::cout<<std::endl;
-        for (auto e : iter::zip(f,s,empty,d)) {
-            std::cout << std::get<0>(e) << " " 
-                << std::get<1>(e) << " " 
-                << std::get<2>(e) << " "
-                << std::get<3>(e) << std::endl;
-        }//both should print nothing
-        std::cout<<std::endl;
-        for (auto e : iter::zip(f,s,i,d)) { //i should be the limiter now
-            std::cout << std::get<0>(e) << " " 
-                << std::get<1>(e) << " " 
-                << std::get<2>(e) << " "
-                << std::get<3>(e) << std::endl;
-        }
-        std::cout<<std::endl;
-        const std::vector<double> constvector{1.1,2.2,3.3,4.4};
-        for (auto e : zip(
-                    iter::chain(std::vector<int>{5,6},
-                               std::array<int,2>{{1,2}}),
-                    std::initializer_list<const char *>{
-                         "asdfas","aaron","ryan","apple","juice"},
-                    std::initializer_list<int>{1, 2, 3, 4},
-                    constvector)) 
-        { 
-
-            std::cout << std::get<0>(e) << " " 
-                << std::get<1>(e) << " "
-                << std::get<2>(e)
-                << '\n';
-        }
-    }
-
-
-    return 0;
-}
-
diff --git a/examples/testzip_longest.cpp b/examples/testzip_longest.cpp
deleted file mode 100644
index 63dc8fd0..00000000
--- a/examples/testzip_longest.cpp
+++ /dev/null
@@ -1,96 +0,0 @@
-#include <zip_longest.hpp>
-
-#include <vector>
-#include <string>
-#include <iostream>
-#include <array>
-#include <boost/optional.hpp>
-
-using iter::zip_longest;
-
-template <typename T>
-std::ostream & operator<<(std::ostream & out, const boost::optional<T>& opt) {
-    if (opt) {
-        out << "Just " << *opt;
-    } else {
-        out << "Nothing";
-    }
-    return out;
-}
-
-int main() {
-    //Ryan's test
-    {
-        std::vector<int> ivec{1, 4, 9, 16, 25, 36};
-        std::vector<std::string> svec{"hello", "good day", "goodbye"};
-
-        for (auto e : zip_longest(ivec, svec)) {
-            std::cout << std::get<0>(e) << std::endl; 
-            std::cout << std::get<1>(e) << std::endl; 
-        }
-
-        for (auto e : zip_longest("helloworld",
-                    std::vector<int>{1,2,3})) {
-            std::cout << std::get<0>(e) << std::endl; 
-            std::cout << std::get<1>(e) << std::endl; 
-        }
-    }
-    //Aaron's test
-    {
-        std::array<int,4> i{{1,2,3,4}};
-        std::vector<float> f{1.2,1.4,12.3,4.5,9.9};
-        std::vector<std::string> s{"i","like","apples","alot","dude"};
-        std::array<double,5> d{{1.2,1.2,1.2,1.2,1.2}};
-        std::cout << std::endl << "Variadic template zip_longest" << std::endl;
-        for (auto e : iter::zip_longest(i,f,s,d)) {
-            std::cout << std::get<0>(e) << ' '
-                << std::get<1>(e) << ' '
-                << std::get<2>(e) << ' '
-                << std::get<3>(e) << std::endl;
-            *std::get<1>(e)=2.2f; //modify the float array
-        }
-        std::cout<<"modified array" <<std::endl;
-        for (auto e : iter::zip_longest(i,s,f,d)) {
-            std::cout << std::get<0>(e) << ' '
-                << std::get<1>(e) << ' '
-                << std::get<2>(e) << ' '
-                << std::get<3>(e) << std::endl;
-        }
-        std::cout << std::endl << "Try some weird range differences" << std::endl;
-        std::vector<int> empty{};
-        for (auto e : iter::zip_longest(empty,f,s,d)) {
-            std::cout << std::get<0>(e) << ' '
-                << std::get<1>(e) << ' '
-                << std::get<2>(e) << ' '
-                << std::get<3>(e) << std::endl;
-        }
-        std::cout<<std::endl;
-        for (auto e : iter::zip_longest(f,empty,s,d)) {
-            std::cout << std::get<0>(e) << ' '
-                << std::get<1>(e) << ' '
-                << std::get<2>(e) << ' '
-                << std::get<3>(e) << std::endl;
-        }
-        std::cout<<std::endl;
-        for (auto e : iter::zip_longest(f,s,i,d)) { 
-            std::cout << std::get<0>(e) << ' '
-                << std::get<1>(e) << ' '
-                << std::get<2>(e) << ' '
-                << std::get<3>(e) << std::endl;
-        }
-        std::cout<<std::endl;
-        for (auto e : iter::zip_longest(std::initializer_list<int>{1,2,3,4,5,6},
-                    std::initializer_list<double>{1.1,2.2,3.3,4.4},
-                    std::initializer_list<double>{1.1,2.2,3.3,4.4},
-                    std::array<int,3>{{1,2,3}})) { 
-            std::cout << std::get<0>(e) << ' '
-                << std::get<1>(e) << ' '
-                << std::get<2>(e) << ' '
-                << std::get<3>(e) << std::endl;
-        }
-        std::cout<<std::endl;
-
-    }
-    return 0;
-}
-
diff --git a/tests/.gitignore b/tests/.gitignore
deleted file mode 100644
index a77d502e..00000000
--- a/tests/.gitignore
+++ /dev/null
@@ -1,5 +0,0 @@
-*.o
-*.swp
-test*
-!test*.cpp
-.sconsign.dblite
diff --git a/tests/SConstruct b/tests/SConstruct
deleted file mode 100644
index 74195c1e..00000000
--- a/tests/SConstruct
+++ /dev/null
@@ -1,51 +0,0 @@
-import os
-
-env = Environment(
-    ENV = {'PATH' : os.environ['PATH']},
-    CXX='c++',
-    CXXFLAGS= ['-g', '-Wall', '-Wextra',
-               '-pedantic', '-std=c++11',
-                '-fdiagnostics-color=always',
-               '-I/usr/local/include'],
-    CPPPATH='..',
-    LINKFLAGS='-L/usr/local/lib')
-
-# allows highighting to print to terminal from compiler output
-env['ENV']['TERM'] = os.environ['TERM']
-
-progs = Split('''
-              accumulate
-              cycle 
-              enumerate 
-              range 
-              zip 
-              slice 
-              reversed 
-              filter 
-              repeat 
-              takewhile 
-              dropwhile 
-              zip_longest 
-              product 
-              permutations 
-              compress 
-              combinations_with_replacement 
-              combinations 
-              powerset
-              sliding_window
-              imap
-              count
-              filterfalse
-              grouper
-              chain
-              chainfromiterable
-              groupby
-              sorted
-              unique_justseen
-              unique_everseen
-              command_chains
-              ''')
-
-
-for p in progs:
-    env.Program('test{0}.cpp'.format(p))
diff --git a/tests/samples.hpp b/tests/samples.hpp
deleted file mode 100644
index 820d2c1e..00000000
--- a/tests/samples.hpp
+++ /dev/null
@@ -1,98 +0,0 @@
-#ifndef ITERTOOLS_SAMPLE_CLASSES_HPP
-#define ITERTOOLS_SAMPLE_CLASSES_HPP
-
-#include <iostream>
-#include <utility>
-#include <cstddef>
-
-namespace itertest {
-    class MoveOnly {
-        private:
-            int i; // not an aggregate
-        public:
-            MoveOnly(int v)
-                : i{v}
-            { }
-
-            MoveOnly(const MoveOnly&) = delete;
-            MoveOnly& operator=(const MoveOnly&) = delete;
-
-            MoveOnly(MoveOnly&& other) noexcept
-                : i{other.i}
-            { }
-
-            MoveOnly& operator=(MoveOnly&& other) noexcept {
-                this->i = other.i;
-                return *this;
-            }
-
-            // for std::next_permutation compatibility
-            friend bool operator<(const MoveOnly& lhs, const MoveOnly& rhs) {
-                return lhs.i < rhs.i;
-            }
-
-            friend std::ostream& operator<<(
-                    std::ostream& out, const MoveOnly& self) {
-                return out << self.i;
-            }
-
-    };
-
-    class DerefByValue {
-        private:
-            static constexpr std::size_t N = 3;
-            int array[N] = {0, 1, 2};
-        public:
-            DerefByValue() = default;
-
-            class Iterator {
-                private:
-                    int *current;
-                public:
-                    Iterator() = default;
-                    Iterator(int *p)
-                        : current{p}
-                    { }
-
-                    bool operator!=(const Iterator& other) const {
-                        return this->current != other.current;
-                    }
-
-                    // for testing, iterator derefences to an int instead of
-                    // an int&
-                    int operator*() {
-                        return *this->current;
-                    }
-
-                    Iterator& operator++() {
-                        ++this->current;
-                        return *this;
-                    }
-            };
-
-            Iterator begin() {
-                return {this->array};
-            }
-
-            Iterator end() {
-                return {this->array + N};
-            }
-    };
-
-    class DerefByValueFancy {
-        private:
-            static constexpr std::size_t N = 3;
-            int array[N] = {0, 1, 2};
-        public:
-            DerefByValueFancy() = default;
-
-            int *begin() {
-                return this->array;
-            }
-
-            int *end() {
-                return this->array + N;
-            }
-    };
-}
-#endif // #ifndef ITERTOOLS_SAMPLE_CLASSES_HPP
diff --git a/tests/testaccumulate.cpp b/tests/testaccumulate.cpp
deleted file mode 100644
index 2321ffca..00000000
--- a/tests/testaccumulate.cpp
+++ /dev/null
@@ -1,33 +0,0 @@
-#include <accumulate.hpp>
-#include <range.hpp>
-
-#include <iostream>
-#include <vector>
-
-int main() {
-    std::vector<int> vec = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
-    for (auto v : iter::accumulate(vec, [](int a, int b){return a - b;})) {
-        std::cout << v << '\n';
-    }
-    for (auto v : iter::accumulate(iter::range(10),
-                [](int a, int b){return a - b;})) {
-        std::cout << v << '\n';
-    }
-    for (auto v : iter::accumulate({0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
-                [](int a, int b){return a - b;})) {
-        std::cout << v << '\n';
-    }
-
-    for (auto v : iter::accumulate(iter::range(10))) {
-        std::cout << v << '\n';
-    }
-    for (auto v : iter::accumulate({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})) {
-        std::cout << v << '\n';
-    }
-
-    for (auto v : iter::accumulate(std::vector<int>{1,2,3,4,5,6,7,8,9})) {
-        std::cout << v << '\n';
-    }
-
-    return 0;
-}
diff --git a/tests/testchain.cpp b/tests/testchain.cpp
deleted file mode 100644
index 19ab374d..00000000
--- a/tests/testchain.cpp
+++ /dev/null
@@ -1,61 +0,0 @@
-#include <chain.hpp>
-#include <range.hpp>
-
-#include <vector>
-#include <string>
-#include <iostream>
-#include <array>
-#include <initializer_list>
-
-using iter::chain;
-using il = std::initializer_list<int>; 
-
-int main() {
-
-    {
-        std::vector<int> ivec{1, 4, 7, 9};
-        std::vector<int> lvec{100, 200, 300, 400, 500, 600};
-
-        for (auto e : chain(ivec, lvec)) {
-            std::cout << e << std::endl;
-        }
-    }
-    {
-        std::vector<int> empty{};
-        std::vector<int> vec1{1,2,3,4,5,6};
-        std::array<int,4> arr1{{7,8,9,10}};
-        std::array<int,3> arr2{{11,12,13}};
-        std::cout << std::endl << "Chain iter test" << std::endl;
-        for (auto i : iter::chain(empty,vec1,arr1)) {
-            std::cout << i << std::endl;
-        }
-        std::cout<<std::endl;
-        for (auto i : iter::chain(vec1,empty,arr1)) {
-            std::cout << i << std::endl;
-        }
-        std::cout<<std::endl;
-        for (auto i : iter::chain(vec1,arr1,empty)) {
-            std::cout << i << std::endl;
-        }
-        std::cout<<std::endl;//modifying the range
-        for (auto & i : iter::chain(vec1,arr1,arr2)) {
-            i = 0;//0 out the whole thing
-        }
-        std::cout<<std::endl;
-        for (auto i : iter::chain(vec1,arr1,arr2)) {
-            std::cout << i << std::endl;
-        }
-        //test only works with perfect forwarding
-        std::cout<<std::endl;
-        for (auto i : chain(il{1,2,3,4,5},il{6,7,8,9},il{10,11,12})) {
-            std::cout << i << std::endl;
-        }
-
-        // test with temporaries
-        std::cout << '\n';
-        for (auto i : chain(std::vector<int>{1,2,3,4},
-                    std::array<int,4>{{5,6,7,8}})) {
-            std::cout << i << '\n';
-        }
-    }
-}
diff --git a/tests/testchainfromiterable.cpp b/tests/testchainfromiterable.cpp
deleted file mode 100644
index f4b6d599..00000000
--- a/tests/testchainfromiterable.cpp
+++ /dev/null
@@ -1,28 +0,0 @@
-#include <chain.hpp>
-
-#include <iostream>
-#include <vector>
-
-using iter::chain;
-
-int main() {
-    std::vector<std::vector<int>> matrix = {
-        {1, 2, 3},
-        {4, 5},
-        {6, 8, 9, 10, 11, 12}
-    };
-    for (auto i : chain.from_iterable(matrix)) {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "with temporary\n";
-    for (auto i : chain.from_iterable(std::vector<std::vector<int>>{
-                    {1, 2, 3},
-                    {4, 5},
-                    {6, 8, 9, 10, 11, 12}
-                })) {
-        std::cout << i << '\n';
-    }
-
-    return 0;
-}
diff --git a/tests/testcombinations.cpp b/tests/testcombinations.cpp
deleted file mode 100644
index 4dce1139..00000000
--- a/tests/testcombinations.cpp
+++ /dev/null
@@ -1,75 +0,0 @@
-#include "samples.hpp"
-#include <combinations.hpp>
-#include <range.hpp>
-
-#include <vector>
-#include <string>
-#include <iostream>
-#include <array>
-
-using iter::combinations;
-int main() {
-    itertest::DerefByValue dbv; 
-    std::vector<itertest::MoveOnly> mv;
-    for (auto i : iter::range(3)) {
-        mv.emplace_back(i);
-    }
-    std::vector<int> v = {1,2,3,4,5};
-
-    for (auto i : combinations(mv,2)) {
-        for (auto j : i ) std::cout << j << " ";
-        std::cout<<std::endl;
-    }
-
-    for (auto i : combinations(v,0)) {
-        for (auto j : i ) std::cout << j << " ";
-        std::cout<<std::endl;
-    }
-
-    for (auto i : combinations(v,3)) {
-        for (auto j : i ) std::cout << j << " ";
-        std::cout<<std::endl;
-    }
-
-    for (auto i : combinations(v,1)) {
-        for (auto j : i ) std::cout << j << " ";
-        std::cout<<std::endl;
-    }
-
-    for (auto i : combinations(v,5)) {
-        for (auto j : i ) std::cout << j << " ";
-        std::cout<<std::endl;
-    }
-
-    std::cout << "deref by value\n";
-    for (auto i : combinations(dbv, 2)) {
-        for (auto j : i) std::cout << j << " ";
-        std::cout << '\n';
-    }
-
-    std::cout << "initializer list\n";
-    for (auto i : combinations({1,2,3,4},3)) {
-        for (auto j : i ) std::cout << j << " ";
-        std::cout<<std::endl;
-
-    }
-
-    std::cout << "initializer list\n";
-    for (auto i : combinations({1,2,3,4},1)) {
-        for (auto j : i ) std::cout << j << " ";
-        std::cout<<std::endl;
-    }
-
-    std::cout << "temporary\n";
-    for (auto i : combinations(std::vector<int>{1,2,3,4,5}, 3)) {
-        for (auto j : i ) std::cout << j << " ";
-        std::cout<<std::endl;
-    }
-
-    std::cout << "static array\n";
-    int array[] = {1,2,3,4,5};
-    for (auto i : combinations(array, 3)) {
-        for (auto j : i) std::cout << j << " ";
-        std::cout << '\n';
-    }
-}
diff --git a/tests/testcombinations_with_replacement.cpp b/tests/testcombinations_with_replacement.cpp
deleted file mode 100644
index 78b8751e..00000000
--- a/tests/testcombinations_with_replacement.cpp
+++ /dev/null
@@ -1,55 +0,0 @@
-#include "samples.hpp"
-#include <combinations_with_replacement.hpp>
-#include <range.hpp>
-
-#include <vector>
-#include <string>
-#include <iostream>
-#include <array>
-
-using iter::combinations_with_replacement;
-
-int main() {
-    std::vector<itertest::MoveOnly> mv;
-    for (auto i : iter::range(3)) {
-        mv.emplace_back(i);
-    }
-
-    std::vector<int> v = {1,2,3,};
-    for (auto i : combinations_with_replacement(v,4)) {
-        for (auto j : i ) std::cout << j << " ";
-        std::cout<<std::endl;
-    }
-
-    itertest::DerefByValue dbv;
-    std::cout << "with deref by value iterator\n";
-    for (auto i : combinations_with_replacement(dbv, 2)) {
-        for (auto j : i ) std::cout << j << " ";
-        std::cout<<std::endl;
-    }
-
-    std::cout << "with container of move-only\n";
-    for (auto i : combinations_with_replacement(mv,2)) {
-        for (auto j : i ) std::cout << j << " ";
-        std::cout<<std::endl;
-    }
-
-    std::cout << "with temporary\n";
-    for (auto i : combinations_with_replacement(std::vector<int>{1,2,3},4)) {
-        for (auto j : i ) std::cout << j << " ";
-        std::cout<<std::endl;
-    }
-
-    std::cout << "with init list\n";
-    for (auto i : combinations_with_replacement({1,2,3},4)) {
-        for (auto j : i ) std::cout << j << " ";
-        std::cout<<std::endl;
-    }
-
-    std::cout << "with static array\n";
-    int arr[] = {1, 2, 3};
-    for (auto i : combinations_with_replacement(arr,4)) {
-        for (auto j : i ) std::cout << j << " ";
-        std::cout<<std::endl;
-    }
-}
diff --git a/tests/testcommand_chains.cpp b/tests/testcommand_chains.cpp
deleted file mode 100644
index e116f131..00000000
--- a/tests/testcommand_chains.cpp
+++ /dev/null
@@ -1,78 +0,0 @@
-#include <itertools.hpp>
-
-#include <vector>
-#include <tuple>
-#include <array>
-#include <iostream>
-#include <string>
-
-using namespace iter;
-
-template <typename T>
-std::ostream & operator<<(std::ostream & out, const boost::optional<T>& opt) {
-    if (opt) {
-        out << "Just " << *opt;
-    } else {
-        out << "Nothing";
-    }
-    return out;
-}
-int main() {
-    {
-        std::vector<int> vec1{1,2,3,4,5,6};
-        std::vector<int> vec2{1,2,3,4,5};
-        std::vector<std::string> strvec
-        {"his","name","was","robert","paulson","his","name","was","robert","paulson"};
-        for (auto t : zip_longest(chain(vec1,vec2),strvec)) {
-            std::cout << std::get<0>(t) << " "
-                << std::get<1>(t) << std::endl;
-        }
-    }
-
-    std::string str = "hello world";
-    std::vector<int> vec = {6, 9, 6, 9};
-    for (auto p : enumerate(enumerate(str))) { (void)p; }
-    for (auto p : enumerate(zip(str, vec))) { (void)p; }
-
-    std::cout << std::endl;
-    {
-        std::vector<int> vec1{1,2,3,4,5,6};
-        std::vector<int> vec2{7,8,9,10};
-        std::vector<std::string> strvec
-        {"We're","done","when","I","say","we're","done"};
-        for (auto t : zip(strvec,chain(slice(vec1,2,6),slice(vec2,1,4)))) {
-            std::cout << std::get<0>(t) << " "
-                << std::get<1>(t) << std::endl;
-        }
-    }
-    std::cout << std::endl;
-    {
-        std::vector<int> vec1{1,2,3,4,5,6};
-        std::vector<int> vec2{7,8,9,10};
-        for (auto s : sliding_window(chain(vec1,vec2),4)) {
-            for (auto i : s) std::cout << i << " ";
-            std::cout<<std::endl;
-        }
-    }
-    std::cout << std::endl;
-
-#if 0
-    {
-        std::vector<int> vec1{1,2,3,4,5,6};
-        std::vector<int> vec2{7,8,9,10};
-        for (auto s : grouper(chain(vec1,vec2),3)) {
-            for (auto i : s) std::cout << i << " ";
-            std::cout<<std::endl;
-        }
-    }
-#endif
-    auto prod_range = iter::product(iter::range(10), iter::range(5));
-
-    for (auto&& ij: iter::filter(
-                [](std::tuple<unsigned, unsigned> const& c)
-                {return std::get<0>(c) >= std::get<1>(c);},
-                prod_range)) {
-                    std::cout << std::get<0>(ij) << "," << std::get<1>(ij) << std::endl;
-    }
-    return 0;
-}
diff --git a/tests/testcompress.cpp b/tests/testcompress.cpp
deleted file mode 100644
index 5197f3e2..00000000
--- a/tests/testcompress.cpp
+++ /dev/null
@@ -1,67 +0,0 @@
-#include <compress.hpp>
-#include <range.hpp>
-
-#include <vector>
-#include <iostream>
-
-using iter::compress;
-using iter::range;
-
-template <typename DataType, typename SelectorType>
-void testcase(std::vector<DataType> data_vec,
-        std::vector<SelectorType> sel_vec)
-{
-
-    for (auto e : compress(data_vec, sel_vec)) {
-        std::cout << e << '\n';
-    }
-}
-
-int main(void)
-{
-    std::vector<int> ivec{1, 2, 3, 4, 5, 6};
-    std::vector<bool> bvec{true, false, true, false, true, false};
-    std::cout << "Should print 1 3 5\n";
-    testcase(ivec, bvec);
-
-    std::vector<bool> bvec2{false, true, false, false, false, true};
-    std::cout << "Should print 2 6\n";
-    testcase(ivec, bvec2);
-
-    std::vector<bool> bvec3{false, true};
-    std::cout << "Should print 2\n";
-    testcase(ivec, bvec3);
-
-    std::cout << "Should print 0 2 4\n";
-    for (auto i : compress(range(10), bvec)) {
-        std::cout << i << '\n';
-    }
-    
-    std::cout << "Should print 0 2 4\n";
-    for (auto i : compress({0,1,2,3,4,5}, bvec)) {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "Should print 0 2 4\n";
-    for (auto i : compress(range(10), {true, false, true, false, true})) {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "Should print 0 2 4\n";
-    for (auto i : compress({0, 1, 2, 3, 4, 5},
-                {true, false, true, false, true}))
-    {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "Should print 0 2 4\n";
-    for (auto i : compress(std::vector<int>{0, 1, 2, 3, 4, 5},
-                std::vector<bool>{true, false, true, false, true}))
-    {
-        std::cout << i << '\n';
-    }
-
-        
-
-    return 0;
-}
diff --git a/tests/testcount.cpp b/tests/testcount.cpp
deleted file mode 100644
index 946d6841..00000000
--- a/tests/testcount.cpp
+++ /dev/null
@@ -1,38 +0,0 @@
-#include <count.hpp>
-
-#include <iostream>
-
-using iter::count;
-
-int main() {
-    for (auto i : count()) {
-        std::cout << i << '\n';
-        if (i == 100) {
-            break;
-        }
-    }
-
-    for (auto i : count(5.0, 0.5)){
-        std::cout << i << '\n';
-        if (i > 100) {
-            break;
-        }
-    }
-
-    for (auto i : count(0, -1)) {
-        std::cout << i << '\n';
-        if (i < -100) {
-            break;
-        }
-    }
-
-    for (auto i : count()) {
-        std::cout << i << '\n';
-        if (i > 10000) {
-            break;
-        }
-    }
-
-
-    return 0;
-}
diff --git a/tests/testcycle.cpp b/tests/testcycle.cpp
deleted file mode 100644
index 138692cc..00000000
--- a/tests/testcycle.cpp
+++ /dev/null
@@ -1,70 +0,0 @@
-#include <cycle.hpp>
-#include <range.hpp>
-
-#include <vector>
-#include <iostream>
-
-using iter::cycle;
-using iter::range;
-
-int main() {
-    std::vector<int> vec = {2, 4, 6};
-
-    size_t count = 0;
-    for (auto i : cycle(vec)) {
-        std::cout << i << '\n';
-        if (count == 100) {
-            break;
-        }
-        ++count;
-    }
-
-    count = 0;
-    int array[] = {68, 69, 70};
-    for (auto i : cycle(array)) {
-        std::cout << i << '\n';
-        if (count == 20) {
-            break;
-        }
-        ++count;
-    }
-
-    count = 0;
-    for (auto i : cycle({7, 8, 9})) {
-        std::cout << i << '\n';
-        if (count == 20) {
-            break;
-        }
-        ++count;
-    }
-
-    count = 0;
-    for (auto i : cycle(range(3))) {
-        std::cout << i << '\n';
-        if (count == 20) {
-            break;
-        }
-        ++count;
-    }
-
-    count = 0;
-    const std::string s("hello");
-    for (auto c : cycle(s)) {
-        std::cout << c << '\n';
-        if (count == 20) {
-            break;
-        }
-        ++count;
-    }
-
-    count = 0;
-    for (auto i : std::vector<int>{1,2,3,4,5}) {
-        std::cout << i << '\n';
-        if (count == 20) {
-            break;
-        }
-        ++count;
-    }
-
-    return 0;
-}
diff --git a/tests/testdropwhile.cpp b/tests/testdropwhile.cpp
deleted file mode 100644
index 3140f81a..00000000
--- a/tests/testdropwhile.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-#include <dropwhile.hpp>
-#include <range.hpp>
-
-#include <vector>
-#include <iostream>
-#include <cassert>
-
-using iter::dropwhile;
-using iter::range;
-
-int main() {
-    std::vector<int> ivec{1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4};
-    for (auto& i : dropwhile([] (int i) {return i < 5;}, ivec)) {
-        std::cout << i << '\n';
-        i = 69;
-    }
-    assert(ivec.at(0) == 1);
-    assert(ivec.at(4) == 69);
-
-    for (auto i : dropwhile([] (int i) {return i < 5;}, range(10))) {
-        std::cout << i << '\n';
-    }
-
-    for (auto i : dropwhile([] (int i) {return i < 5;}, 
-                {1, 2, 3, 4, 5, 6, 7, 8, 9})) {
-        std::cout << i << '\n';
-    }
-
-    for (auto i : dropwhile([] (int i) {return i < 5;}, 
-                std::vector<int>{1, 2, 3, 4, 5, 6, 7, 8, 9})) {
-        std::cout << i << '\n';
-    }
-
-    return 0;
-}
diff --git a/tests/testenumerate.cpp b/tests/testenumerate.cpp
deleted file mode 100644
index fcc1745c..00000000
--- a/tests/testenumerate.cpp
+++ /dev/null
@@ -1,60 +0,0 @@
-#include <enumerate.hpp>
-#include <range.hpp>
-
-#include <string>
-#include <iostream>
-#include <vector>
-
-using iter::enumerate;
-using iter::range;
-
-int main() {
-    std::cout << "const std::string\n";
-    const std::string const_string("goodbye world");
-    for (auto e : enumerate(const_string)) {
-        std::cout << e.index << ": " << e.element << std::endl;
-    }
-
-
-    std::vector<int> vec;
-    for(int i = 0; i < 12; ++i) { 
-        vec.push_back(i * i);
-    }
-
-
-    std::cout << "print vector element, set it to zero, then print it again\n";
-    for (auto e : enumerate(vec)) { 
-        std::cout << e.index << ": " << e.element << std::endl;
-        e.element = 0;
-        // tests to make sure vector can be edited
-        std::cout << e.index << ": " << e.element << std::endl;
-    }
-
-    std::cout << "static array\n";
-    int array[] = {1, 9, 8, 11};
-    for (auto e : enumerate(array)) {
-        std::cout << e.index << ": " << e.element << '\n';
-    }
-
-    std::cout << "initializer list\n";
-    for (auto e : enumerate({0, 1, 4, 9, 16, 25})) {
-        std::cout << e.index << "^2 = " << e.element << '\n';
-    }
-
-    std::cout << "range(10, 20, 2)\n";
-    for (auto e : enumerate(range(10, 20, 2))) {
-        std::cout << e.index << ": " << e.element << '\n';
-    }
-
-    std::cout << "range(10, 20, 2)\n";
-    for (auto e : enumerate(enumerate(range(10, 20, 2)))) {
-        std::cout << e.index << ": " << e.element.element << '\n';
-    }
-
-    std::cout << "vector temporary\n";
-    for (auto e : enumerate(std::vector<int>(5,2))) {
-        std::cout << e.index << ": " << e.element << '\n';
-    }
-
-    return 0;
-}
diff --git a/tests/testfilter.cpp b/tests/testfilter.cpp
deleted file mode 100644
index e8af2aab..00000000
--- a/tests/testfilter.cpp
+++ /dev/null
@@ -1,83 +0,0 @@
-#include <filter.hpp>
-#include <range.hpp>
-
-#include <vector>
-#include <iostream>
-
-using iter::filter;
-
-bool greater_than_four(int i) {
-    return i > 4;
-}
-
-class LessThanValue {
-    private:
-        int compare_val;
-
-    public:
-        LessThanValue() = delete;
-        LessThanValue(int v) : compare_val(v) { }
-        
-        bool operator() (int i) {
-            return i < this->compare_val;
-        }
-};
-
-
-int main() {
-    std::vector<int> vec{1, 5, 6, 7, 2, 3, 8, 3, 2, 1};
-
-    std::cout << "Greater than 4 (function pointer)\n";
-    for (auto i : filter(greater_than_four, vec)) {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "Less than 4 (lambda)\n";
-    for (auto i : filter([] (const int i) { return i < 4; }, vec)) {
-        std::cout << i << '\n';
-    }
-
-    LessThanValue lv(4);
-    std::cout << "Less than 4 (callable object)\n";
-    for (auto i : filter(lv, vec)) {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "Nonzero ints filter(vec2)\n";
-    std::vector<int> vec2 {0, 1, 2, 0, 3, 0, 0, 0, 4, 5, 0};
-    for (auto i : filter(vec2)) {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "odd numbers in range(10) temp\n";
-    for (auto i : filter([] (const int i) {return i % 2;}, iter::range(10))) {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "range(-1, 2)\n";
-    for (auto i : filter(iter::range(-1, 2))) {
-        std::cout << i << '\n';
-    }
-
-
-    std::cout << "ever numbers in initializer_list\n";
-    for (auto i : filter([] (const int i) {return i % 2 == 0;},
-                         {1, 2, 3, 4, 5, 6, 7}))
-    {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "default in initialization_list\n";
-    for (auto i : filter({-2, -1, 0, 0, 0, 1, 2})) {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "ever numbers in vector temporary\n";
-    for (auto i : filter([] (const int i) {return i % 2 == 0;},
-                         std::vector<int>{1, 2, 3, 4, 5, 6, 7}))
-    {
-        std::cout << i << '\n';
-    }
-
-    return 0;
-}
diff --git a/tests/testfilterfalse.cpp b/tests/testfilterfalse.cpp
deleted file mode 100644
index 9063d0bf..00000000
--- a/tests/testfilterfalse.cpp
+++ /dev/null
@@ -1,93 +0,0 @@
-#include <filterfalse.hpp>
-#include <range.hpp>    
-
-#include <vector>
-#include <iostream>
-
-using iter::filterfalse;
-using iter::range;
-
-bool greater_than_four(int i) {
-    return i > 4;
-}
-
-class LessThanValue {
-    private:
-        int compare_val;
-
-    public:
-        LessThanValue() = delete;
-        LessThanValue(int v) : compare_val(v) { }
-        
-        bool operator() (int i) const {
-            return i < this->compare_val;
-        }
-};
-
-
-int main() {
-    std::vector<int> vec{1, 5, 6, 7, 2, 3, 8, 3, 2, 1};
-
-    std::cout << "Greater than 4 (function pointer)\n";
-    for (auto i : filterfalse(greater_than_four, vec)) {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "Less than 4 (lambda)\n";
-    for (auto i : filterfalse([] (const int i) { return i < 4; }, vec)) {
-        std::cout << i << '\n';
-    }
-
-    LessThanValue lv(4);
-    std::cout << "Less than 4 (callable object)\n";
-    for (auto i : filterfalse(lv, vec)) {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "zero ints filter(vec2)\n";
-    std::vector<int> vec2 {0, 1, 2, 0, 3, 0, 0, 0, 4, 5, 0};
-    for (auto i : filterfalse(vec2)) {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "Constness tests\n";
-    const std::vector<int> cvec(vec);
-    for (auto i : filterfalse(greater_than_four, cvec)) {
-        std::cout << i << '\n';
-    }
-
-    for (auto i : filterfalse([] (const int & i) { return i < 4; }, cvec)) {
-        std::cout << i << '\n';
-    }
-
-
-    std::cout << "i%2 with range(10), should print even numbers\n";
-    for (auto i : filterfalse([] (const int i) { return i % 2; }, range(10))) {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "range(-1, 2)\n";
-    for (auto i : filterfalse(range(-1, 2))) {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "initializer_list\n";
-    for (auto i : filterfalse([] (const int i) { return  i % 2; },
-                {10, 11, 12, 13, 14, 15, 16}))
-    {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "initializer_list with default\n";
-    for (auto i : filterfalse({-1, -2, 0, 0, 0, 0, 1, 2, 3})) {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "vector temporary with default\n";
-    for (auto i : filterfalse(
-                std::vector<int>{-1, -2, 0, 0, 0, 0, 1, 2, 3})) {
-        std::cout << i << '\n';
-    }
-
-    return 0;
-}
diff --git a/tests/testgroupby.cpp b/tests/testgroupby.cpp
deleted file mode 100644
index 9fc03ee3..00000000
--- a/tests/testgroupby.cpp
+++ /dev/null
@@ -1,109 +0,0 @@
-#include <groupby.hpp>
-
-#include <vector>
-#include <iostream>
-#include <string>
-
-using iter::groupby;
-
-
-int length(std::string s)
-{
-    return s.length();
-}
-
-int main()
-{
-    std::vector<std::string> vec = {
-        "hi", "ab", "ho",
-        "abc", "def",
-        "abcde", "efghi"
-    };
-
-    for (auto gb : groupby(vec, &length)) {
-        std::cout << "key: " << gb.first << '\n';
-        std::cout << "content: ";
-        for (auto s : gb.second) {
-            std::cout << s << "  ";
-        }
-        std::cout << '\n';
-    }
-
-    for (auto gb : groupby(vec, [] (const std::string &s) {return s.length(); })) {
-        std::cout << "key: " << gb.first << '\n';
-        std::cout << "content: ";
-        for (auto s : gb.second) {
-            std::cout << s << "  ";
-        }
-        std::cout << '\n';
-    }
-
-    std::cout << "skipping length of 3\n";
-    for (auto gb : groupby(vec, &length)) {
-        if (gb.first == 3) {
-            continue;
-        }
-        std::cout << "key: " << gb.first << '\n';
-        std::cout << "content: ";
-        for (auto s : gb.second) {
-            std::cout << s << "  ";
-        }
-        std::cout << '\n';
-    }
-   
-
-    std::vector<int> ivec = {5, 5, 6, 6, 19, 19, 19, 19, 69, 0, 10, 10};
-    for (auto gb : groupby(ivec)) {
-        std::cout << "key: " << gb.first << '\n';
-        std::cout << "content: ";
-        for (auto s : gb.second) {
-            std::cout << s << "  ";
-        }
-        std::cout << '\n';
-    }
-
-    for (auto gb : groupby("aabbccccdd", [] (const char c) {return c < 'c';})){
-        std::cout << "key: " << gb.first << '\n';
-        std::cout << "content: ";
-        for (auto s : gb.second) {
-            std::cout << s << "  ";
-        }
-        std::cout << '\n';
-    }
-    
-    for (auto gb : groupby({'a', 'a', 'b', 'b', 'c'})) {
-        std::cout << "key: " << gb.first << '\n';
-        std::cout << "content: ";
-        for (auto s : gb.second) {
-            std::cout << s << "  ";
-        }
-        std::cout << '\n';
-    }
-
-    for (auto gb : groupby({'a', 'a', 'b', 'b', 'c', 'c', 'd', 'd'},
-                [] (const char c) {return c < 'c'; })) {
-        std::cout << "key: " << gb.first << '\n';
-        std::cout << "content: ";
-        for (auto s : gb.second) {
-            std::cout << s << "  ";
-        }
-        std::cout << '\n';
-    }
-
-    std::cout << "with vector temporary:\n";
-    for (auto gb : groupby(
-                std::vector<char>{'a', 'a', 'b', 'b', 'c', 'c', 'd', 'd'},
-                [] (const char c) {return c < 'c'; })) {
-        std::cout << "key: " << gb.first << '\n';
-        std::cout << "content: ";
-        for (auto s : gb.second) {
-            std::cout << s << "  ";
-        }
-        std::cout << '\n';
-    }
-        
-
-    return 0;
-}
-
-    
diff --git a/tests/testgrouper.cpp b/tests/testgrouper.cpp
deleted file mode 100644
index b16ebc98..00000000
--- a/tests/testgrouper.cpp
+++ /dev/null
@@ -1,51 +0,0 @@
-#include "grouper.hpp"
-#include <iostream>
-#include <vector>
-using iter::grouper;
-int main() {
-    std::vector<int> v {1,2,3,4,5,6,7,8,9}; 
-    for (auto sec : grouper(v,4)) {
-        for (auto i : sec) {
-            std::cout << i << " ";
-            i.get() *= 2;
-        }
-        std::cout << '\n';
-    }
-
-    for (auto sec : grouper(std::vector<int>{1,2,3,4,5,6,7,8,9}, 4)) {
-        for (auto i : sec) {
-            std::cout << i << " ";
-            i.get() *= 2;
-        }
-        std::cout << '\n';
-    }
-
-    for (auto sec : grouper(v,3)) {
-        for (auto i : sec) {
-            std::cout << i << " ";
-        }
-        std::cout << '\n';
-    }
-    std::vector<int> empty {};
-    for (auto sec : grouper(empty,3)) {
-        std::cout << "Shouldn't print\n";
-        for (auto i : sec) {
-            std::cout << i << " Shouldn't print\n";
-        }
-    }
-
-    int arr[] = {1,2,3,4,5,6,7};
-    for (auto sec : grouper(arr, 2)) {
-        for (auto i : sec) {
-            std::cout << i << ' ';
-        }
-        std::cout << '\n';
-    }
-
-    for (auto sec : grouper({1,2,3,4,5,6,7}, 2)) {
-        for (auto i : sec) {
-            std::cout << i << ' ';
-        }
-        std::cout << '\n';
-    }
-}
diff --git a/tests/testimap.cpp b/tests/testimap.cpp
deleted file mode 100644
index 3d6f38ca..00000000
--- a/tests/testimap.cpp
+++ /dev/null
@@ -1,45 +0,0 @@
-#include <imap.hpp>
-#include <range.hpp>
-
-#include <vector>
-#include <iostream>
-
-using iter::imap;
-
-int main() {
-    std::vector<int> vec1 = {1, 2, 3, 4, 5, 6};
-    std::vector<int> vec2 = {10, 20, 30, 40, 50, 60};
-    for (auto i : imap([] (int x, int y) { return x + y; }, vec1, vec2)) {
-        std::cout << i << '\n';
-    }
-
-    std::vector<int> vec3 = {100, 200, 300, 400, 500, 600};
-    for (auto i : imap([] (int a, int b, int c) { return a + b + c; }, 
-                vec1, vec2, vec3)) {
-        std::cout << i << '\n';
-    }
-
-    for (auto i : imap([] (int i) {return i * i; }, vec1)) {
-        std::cout << i << '\n';
-    }
-
-    std::vector<int> vec{1, 2, 3, 4, 5};
-    for (auto i : imap([] (int x) {return x * x;}, vec)) {
-        std::cout << i << '\n';
-    }
-
-    std::vector<int> vec4{1, 2, 3};
-    for (auto i : imap([] (int a, int b) { return a + b; }, vec, vec4)) {
-        std::cout << i << '\n';
-    }
-
-    for (auto i : imap([] (const int x) { return x*x; }, iter::range(10))) {
-        std::cout << i << '\n';
-    }
-
-    for (auto i : imap([] (const int x) { return x*x; },
-                       std::vector<int>{1,2,3,4,5})){
-        std::cout << i << '\n';
-    }
-    return 0;
-}
diff --git a/tests/testpermutations.cpp b/tests/testpermutations.cpp
deleted file mode 100644
index a73a2a3b..00000000
--- a/tests/testpermutations.cpp
+++ /dev/null
@@ -1,60 +0,0 @@
-#include "samples.hpp"
-
-#include <permutations.hpp>
-#include <range.hpp>
-
-#include <iostream>
-#include <vector>
-#include <string>
-
-int main() {
-    using iter::permutations;
-    std::vector<int> v = {1,2,3};
-    for (auto vec : permutations(v)) {
-        for (auto i : vec) {
-            std::cout << i << " ";
-        }
-        std::cout << std::endl;
-    }
-    //try with string
-    std::string s = "aba";
-    for (auto vec : permutations(s)) {
-        for (auto c : vec) {
-            std::cout << c << " ";
-        }
-        std::cout << std::endl;
-    }
-    s = "abc";
-    for (auto vec : permutations(s)) {
-        for (auto c : vec) {
-            std::cout << c << " ";
-        }
-        std::cout << std::endl;
-    }
-
-    std::cout << "init list\n";
-    //std::next_permutation doesn't work on initializer_lists
-    for (auto vec : permutations({1,2,3,4})) {
-        for (auto c : vec) {
-            std::cout << c << " ";
-        }
-        std::cout << std::endl;
-    }
-
-    std::cout << "with container of move-only objects\n";
-    std::vector<itertest::MoveOnly> mv;
-    for (auto i : iter::range(3)) {
-        mv.emplace_back(i);
-    }
-    for (auto v : permutations(mv)) {
-        for (auto i : v) std::cout << i << " ";
-        std::cout << std::endl;
-    }
-
-    std::cout << "with deref-by-value iterator\n";
-    itertest::DerefByValue dbv;
-    for (auto v : permutations(dbv)) {
-        for (auto i : v) std::cout << i << " ";
-        std::cout << std::endl;
-    }
-}
diff --git a/tests/testpowerset.cpp b/tests/testpowerset.cpp
deleted file mode 100644
index 20ca0098..00000000
--- a/tests/testpowerset.cpp
+++ /dev/null
@@ -1,44 +0,0 @@
-#include "samples.hpp"
-#include <powerset.hpp>
-#include <range.hpp>
-#include <vector>
-#include <iostream>
-
-using iter::powerset;
-
-int main() {
-    std::vector<int> vec {1,2,3,4,5,6,7,8,9};
-    for (auto v : powerset(vec)) {
-        for (auto i : v) std::cout << i << " ";
-        std::cout << std::endl;
-    }
-    std::cout << "with temporary\n";
-    for (auto v : powerset(std::vector<int>{1,2,3})) {
-        for (auto i : v) std::cout << i << " ";
-        std::cout << std::endl;
-    }
-    std::cout << "with initializer_list\n";
-    for (auto v : powerset({1,2,3})) {
-        for (auto i : v) std::cout << i << " ";
-        std::cout << std::endl;
-    }
-
-    std::cout << "with container of move-only objects\n";
-    std::vector<itertest::MoveOnly> mv;
-    for (auto i : iter::range(3)) {
-        mv.emplace_back(i);
-    }
-    for (auto v : powerset(mv)) {
-        for (auto i : v) std::cout << i << " ";
-        std::cout << std::endl;
-    }
-
-    std::cout << "with deref-by-value iterator\n";
-    itertest::DerefByValue dbv;
-    for (auto v : powerset(dbv)) {
-        for (auto i : v) std::cout << i << " ";
-        std::cout << std::endl;
-    }
-
-    return 0;
-}
diff --git a/tests/testproduct.cpp b/tests/testproduct.cpp
deleted file mode 100644
index 22d132ec..00000000
--- a/tests/testproduct.cpp
+++ /dev/null
@@ -1,77 +0,0 @@
-#include "samples.hpp"
-
-#include <product.hpp>
-#include <range.hpp>
-
-#include <vector>
-#include <iostream>
-#include <string>
-
-using iter::product;
-int main() {
-
-    std::vector<itertest::MoveOnly> mv;
-    for (auto i : iter::range(10)) {
-        mv.emplace_back(i);
-    }
-    std::vector<int> empty{};
-    std::vector<int> v1{1,2,3};
-    std::vector<int> v2{7,8};
-    std::vector<std::string> v3{"the","cat"};
-    std::vector<std::string> v4{"hi","what","up","dude"};
-
-    for (auto t : product(v1, mv)) {
-        std::cout << std::get<0>(t) << ", "
-            << std::get<1>(t) << std::endl;
-    }
-    for (auto t : product(empty,v1)) {
-        std::cout << std::get<0>(t) << ", "
-            << std::get<1>(t) << std::endl;
-    }
-    for (auto t : product(v1,empty)) {
-        std::cout << std::get<0>(t) << ", "
-            << std::get<1>(t) << std::endl;
-    }
-    std::cout<<std::endl;
-    for (auto t : product(v1,v2)) {
-        std::cout << std::get<0>(t) << ", "
-            << std::get<1>(t) << std::endl;
-    }
-    std::cout<<std::endl;
-    for (auto t : product(v1,v2,v3,v4)) {
-        std::cout << std::get<0>(t) << ", "
-            << std::get<1>(t) << ", "
-            << std::get<2>(t) << ", " 
-            << std::get<3>(t) << std::endl;
-    }
-    std::cout<<std::endl;
-    for (auto t : product(v1)) {
-        std::cout << std::get<0>(t)  << std::endl;
-    }
-    std::cout<<std::endl;
-    for (auto t : product(v1,v4)) {
-        std::cout << std::get<0>(t) << ", "
-          << std::get<1>(t)  << std::endl;
-    }
-    std::cout << '\n';
-
-    for (auto t : product()) { t=t; }
-
-    for (auto t : product(std::string{"hi"}, v1)) {
-        std::cout << std::get<0>(t) << ", "
-            << std::get<1>(t) << std::endl;
-    }
-    std::cout << '\n';
-
-    int arr[] = {1,2};
-    for (auto t : product(std::string{"hi"}, arr)) {
-        std::cout << std::get<0>(t) << ", "
-            << std::get<1>(t) << std::endl;
-    }
-    std::cout << '\n';
-    for (auto&& ij: iter::product(iter::range(10), iter::range(5))) {
-        std::cout << std::get<0>(ij) << "," << std::get<1>(ij) << std::endl;
-    }
-
-    return 0;
-}
diff --git a/tests/testrange.cpp b/tests/testrange.cpp
deleted file mode 100644
index 9404ae57..00000000
--- a/tests/testrange.cpp
+++ /dev/null
@@ -1,83 +0,0 @@
-#include <range.hpp>
-
-#include <iostream>
-
-using iter::range;
-
-int main()
-{
-    for (auto i : range(10)) {
-        std::cout << i << std::endl;
-    }
-    for (auto i : range(20, 30)) {
-        std::cout << i << std::endl;
-    }
-    for (auto i : range(50, 60, 2)) {
-        std::cout << i << std::endl;
-    }
-
-    std::cout << "Negative Tests\n";
-    for (auto i: range(-10, 0)) {
-        std::cout << i << std::endl;
-    }
-
-    for (auto i : range(-10, 10, 2)) {
-        std::cout << i << std::endl;
-    }
-
-    std::cout << "Tests where (stop - start)%step != 0" << std::endl;
-    for (auto i : range(1, 10, 2)) {
-        std::cout << i << std::endl;
-    }
-
-    for (auto i : range(-1, -10, -2)) {
-        std::cout << i << std::endl;
-    }
-    
-    std::cout << "Tests with different types" << std::endl;
-    for(auto i : range(5.0, 10.0, 0.5)) {
-        std::cout << i << std::endl;
-    }
-	std::cout << "test unsigned" << std::endl;
-	std::cout << "empty range: " << std::endl;
-	size_t len = 0;
-	for(auto i : range(len)){
-	  std::cout << i << std::endl;
-	}
-	std::cout << "stop only" << std::endl;
-	len = 3;
-	for(auto i : range(len)){
-	  std::cout << i << std::endl;
-	}
-	std::cout << "start stop" << std::endl;
-	size_t start = 1;
-	for(auto i : range(start, len)){
-	  std::cout << i << std::endl;
-	}
-
-	std::cout << "start stop skip" << std::endl;
-	len = 10;
-	size_t skip = 3;
-	for(auto i : range(start, len, skip)){
-	  std::cout << i << std::endl;
-	}
-	
-
-
-    // invalid ranges:
-    std::cout << "Should not print anything after this line until exception\n";
-    for (auto i : range(-10, 0, -1)) {
-        std::cout << i << std::endl;
-    }
-
-    for (auto i : range(0, 1, -1)) {
-        std::cout << i << std::endl;
-    }
-
-    std::cout << "Should see exception now\n";
-    for (auto i : range(0, 10, 0) ) {
-        std::cout << i << std::endl;
-    }
-
-    return 0;
-}
diff --git a/tests/testrepeat.cpp b/tests/testrepeat.cpp
deleted file mode 100644
index b91fba03..00000000
--- a/tests/testrepeat.cpp
+++ /dev/null
@@ -1,31 +0,0 @@
-#include "repeat.hpp"
-#include <iostream>
-#include <vector>
-#include <array>
-#include <string>
-#include <memory>
-
-int main () {
-    int a = 10;
-    int i = 0;
-    for (auto num : iter::repeat(a)) {//goes infintely
-        std::cout << num << std::endl;
-        ++i;
-        if (i > 20) break;
-    }
-    std::cout<<std::endl;
-    for (auto num : iter::repeat(a,10)) {//goes ten times
-        std::cout << num << std::endl;
-    }
-    
-    std::cout << "with temporary\n";
-    for (auto s : iter::repeat(std::string{"hey"}, 2)) {
-        std::cout <<  s << '\n';
-    }
-
-    std::cout << "with uptr temporary\n";
-    for (auto& p : iter::repeat(std::unique_ptr<int>{new int{2}}, 2)) {
-        std::cout << *p << '\n';
-    }
-
-}
diff --git a/tests/testreversed.cpp b/tests/testreversed.cpp
deleted file mode 100644
index c6d0ab46..00000000
--- a/tests/testreversed.cpp
+++ /dev/null
@@ -1,43 +0,0 @@
-#include <reversed.hpp>
-
-#include <iostream>
-#include <vector>
-#include <array>
-#include <string>
-
-int main () {
-    std::vector<int> a{1,2,3,4,5,6,7};
-    std::vector<std::string> b{"hey","how","are","you","doing"};
-    std::cout << std::endl << "reversed range test" << std::endl << std::endl;
-    for (auto i : iter::reversed(a)) {
-        std::cout << i << std::endl;
-    }
-    std::cout<<std::endl;
-    //modify a
-    for (auto & i : iter::reversed(a)) {
-        std::cout << i << std::endl;
-        i = 9;
-    }
-    std::cout<<std::endl;
-    for (auto i : iter::reversed(a)) {
-        std::cout << i << std::endl;
-    }
-    std::cout<<std::endl;
-    //try strings
-    for (auto s : iter::reversed(b)) {
-        std::cout << s << std::endl;
-    }
-
-    std::cout << "with temporary\n";
-    for (auto i : iter::reversed(std::vector<int>{1, 2, 3, 4, 5, 6, 7})) {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "statically sized array\n";
-    int arr[] = {1, 2, 3, 4, 5, 6, 7};
-    for (auto i : iter::reversed(arr)) {
-        std::cout << i << '\n';
-    }
-
-
-}
diff --git a/tests/testslice.cpp b/tests/testslice.cpp
deleted file mode 100644
index eaf8e1ce..00000000
--- a/tests/testslice.cpp
+++ /dev/null
@@ -1,81 +0,0 @@
-#include <iostream>
-
-#include <slice.hpp>
-#include <range.hpp>
-
-#include <vector>
-#include <array>
-
-int main() {
-    std::cout << std::endl << "Slice range test" << std::endl << std::endl;
-    std::vector<int> a{0,1,2,3,4,5,6,7,8,9,10,11,12,13};
-    std::vector<std::string> b{"hey","how","are","you","doing"};
-
-    std::cout << "step out of slice\n";
-    for (auto i : iter::slice(a, 1, 4, 5)) {
-        std::cout << i << '\n';
-    }
-    std::cout << "end step out\n";
-
-    for (auto i : iter::slice(a,2)) {
-        std::cout << i << std::endl;
-    }
-    std::cout<<std::endl;
-    for (auto & s : iter::slice(b,3,4)) {
-        std::cout << s << std::endl;
-        s = "test";
-    }
-    std::cout<<std::endl;
-    for (auto s : b) {
-        std::cout << s << std::endl;
-    }
-    std::cout<<std::endl;
-    for (auto i : iter::slice(a,0,15,3)) {
-        std::cout << i << std::endl;
-    }
-
-    std::cout<< "\n13 down to 0\n";
-    for (auto i : iter::slice(a,13,-1,-1)) {
-        std::cout << i << std::endl;
-    }
-
-    std::cout<< "\nunevent step [0:5:3]\n";
-    for (auto i : iter::slice(a, 0, 5, 3)) {
-        std::cout << i << '\n';
-    }
-
-    std::cout<< "\nInvalid range [1:10:-1]\n";
-    for (auto i : iter::slice(a,1,10,-1)) {
-        //invalid range returns two begin iters
-        std::cout << i << std::endl;
-    }
-    std::cout<< "\nOversize range [1:100:1]\n";
-    for (auto i : iter::slice(a,1,100,1)) {
-        //invalid range returns two begin iters
-        std::cout << i << std::endl;
-    }
-    std::cout<< "\nOversize range and undersize[1:100:1]\n";
-    for (auto i : iter::slice(a,-100,100,1)) {
-        //invalid range returns two begin iters
-        std::cout << i << std::endl;
-    }
-
-    std::cout<< "\nstatic array[1:8:2]\n";
-    int arr[10] = {0,1,2,3,4,5,6,7,8,9};
-    for (auto i : iter::slice(arr,1,8,2)) {
-        //invalid range returns two begin iters
-        std::cout << i << std::endl;
-    }
-
-    std::cout << "\ninitializer list\n";
-    for (auto i : iter::slice({1, 2, 4, 8, 16, 32, 64, 128}, 2, 6)) {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "\nvector temporary\n";
-    for (auto i : iter::slice(
-                std::vector<int>{1, 2, 4, 8, 16, 32, 64, 128}, 2, 6)) {
-        std::cout << i << '\n';
-    }
-
-}
diff --git a/tests/testsliding_window.cpp b/tests/testsliding_window.cpp
deleted file mode 100644
index 16708db7..00000000
--- a/tests/testsliding_window.cpp
+++ /dev/null
@@ -1,53 +0,0 @@
-#include "sliding_window.hpp"
-
-#include <iostream>
-#include <vector>
-
-using iter::sliding_window;
-
-int main() {
-    std::vector<int> v = {1,2,3,4,5,6,7,8,9}; 
-    for (auto sec : sliding_window(v,4)) {
-        for (auto i : sec) {
-            std::cout << i << " ";
-            i.get() = 90;
-        }
-        std::cout << std::endl;
-    }
-
-    std::cout << "with temporary\n";
-    for (auto sec : sliding_window(std::vector<int>{1,2,3,4,5,6,7,8,9}, 4)) {
-        for (auto i : sec) {
-            std::cout << i << " ";
-            i.get() = 90;
-        }
-        std::cout << std::endl;
-    }
-
-    std::cout << "with init list\n";
-    for (auto sec : sliding_window({1,2,3,4,5,6,7,8,9}, 4)) {
-        for (auto i : sec) {
-            std::cout << i << " ";
-        }
-        std::cout << std::endl;
-    }
-
-    std::cout << "with window_size > length\n";
-    for (auto sec : sliding_window({1,2,3}, 10)) {
-        for (auto i : sec) {
-            std::cout << i << " ";
-        }
-        std::cout << std::endl;
-    }
-
-    std::cout << "with static array\n";
-    int arr[] = {1,2,3,4,5,6,7,8,9};
-    for (auto sec : sliding_window(arr, 4)) {
-        for (auto i : sec) {
-            std::cout << i << " ";
-        }
-        std::cout << std::endl;
-    }
-
-    return 0;
-}
diff --git a/tests/testsorted.cpp b/tests/testsorted.cpp
deleted file mode 100644
index aed57d32..00000000
--- a/tests/testsorted.cpp
+++ /dev/null
@@ -1,36 +0,0 @@
-#include <sorted.hpp>
-
-#include <iostream>
-#include <vector>
-#include <string>
-
-using iter::sorted;
-
-int main()
-{
-    std::vector<int> vec = {19, 45, 32, 10, 0, 90, 15, 1, 7, 5, 6, 69};
-    for (auto i : sorted(vec)) {
-        std::cout << i << '\n';
-    }
-
-    const std::vector<int> cvec(vec);
-    for (auto i : sorted(cvec)) {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "Sort by first character only\n";
-    std::vector<std::string> svec = {"hello", "everyone", "thanks", "for",
-                                     "having", "me", "here", "today"};
-    for (auto s : sorted(svec,
-                [] (const std::string & s1, const std::string & s2) {
-                    return s1[0] < s2[0]; })) {
-        std::cout << s << '\n';
-    }
-        
-
-    for (auto i : sorted(
-                std::vector<int>{19, 45, 32, 10, 0, 90, 15, 1, 7, 5, 6, 69})) {
-        std::cout << i << '\n';
-    }
-    return 0;
-}
diff --git a/tests/testtakewhile.cpp b/tests/testtakewhile.cpp
deleted file mode 100644
index bec3aeae..00000000
--- a/tests/testtakewhile.cpp
+++ /dev/null
@@ -1,32 +0,0 @@
-#include <takewhile.hpp>
-#include <range.hpp>
-
-#include <vector>
-#include <iostream>
-
-using iter::takewhile;
-using iter::range;
-
-int main() {
-    std::vector<int> ivec{1, 2, 3, 4, 5, 6, 7, 6, 5, 4, 3, 2, 1};
-    for (auto i : takewhile([] (int i) {return i < 5;}, ivec)) {
-        std::cout << i << '\n';
-    }
-
-    for (auto i : takewhile([] (int i) {return i < 5;}, range(10))) {
-        std::cout << i << '\n';
-    }
-
-    for (auto i : takewhile([] (int i) {return i < 5;}, 
-                {1, 2, 3, 4, 5, 6, 7, 8, 9})) {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "with temporary\n";
-    for (auto i : takewhile([] (int i) {return i < 5;}, 
-                std::vector<int>{1, 2, 3, 4, 5, 6, 7, 8, 9})) {
-        std::cout << i << '\n';
-    }
-
-    return 0;
-}
diff --git a/tests/testunique_everseen.cpp b/tests/testunique_everseen.cpp
deleted file mode 100644
index 015adb7d..00000000
--- a/tests/testunique_everseen.cpp
+++ /dev/null
@@ -1,41 +0,0 @@
-
-#include <vector>
-#include <iostream>
-
-#include <unique_everseen.hpp>
-using iter::unique_everseen;
-
-int main() {
-    {
-        //should work same as justseen here
-        std::vector<int> v {1,1,1,2,2,3,4,4,5,6,7,8,8,8,8,9,9};
-        for (auto i : unique_everseen(v)) {
-            std::cout << i << " ";
-        }std::cout << std::endl;
-    }
-    {
-        std::vector<int> v {1,2,3,4,3,2,1,5,6,7,7,8,9,8,9,6};
-        for (auto i : unique_everseen(v)) {
-            std::cout << i << " ";
-        }std::cout << std::endl;
-    }
-
-    for (auto i : unique_everseen(
-                std::vector<int>{1,2,1,3,4,3,2,1,5,6,7,7,8,9,8,9,6})) {
-        std::cout << i << " ";
-    }
-    std::cout << std::endl;
-
-    int arr[] = {1,2,1,3,4,3,2,1,5,6,7,7,8,9,8,9,6};
-    for (auto i : unique_everseen(arr)) {
-        std::cout << i << ' ';
-    }
-    std::cout << '\n';
-
-    for (auto i : unique_everseen({1,2,1,3,4,3,2,1,5,6,7,7,8,9,8,9,6})) {
-        std::cout << i << ' ';
-    }
-    std::cout << '\n';
-
-    return 0;
-}
diff --git a/tests/testunique_justseen.cpp b/tests/testunique_justseen.cpp
deleted file mode 100644
index 8f454b6d..00000000
--- a/tests/testunique_justseen.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-
-#include <vector>
-#include <iostream>
-
-#include <unique_justseen.hpp>
-using iter::unique_justseen;
-
-int main() {
-    std::vector<int> v {1,1,1,2,2,4,4,5,6,7,8,8,8,8,9,9};
-    for (auto i : unique_justseen(v)) {
-        std::cout << i << " ";
-    }
-    std::cout << '\n';
-
-    std::cout << "with temporary\n";
-    for (auto i : unique_justseen(std::vector<int>{1,1,1,2,3,3})) {
-        std::cout << i << " ";
-    }
-    std::cout << '\n';
-
-    std::cout << "with init list\n";
-    for (auto i : unique_justseen({1,1,1,2,3,3})) {
-        std::cout << i << " ";
-    }
-    std::cout << '\n';
-
-    std::cout << "with static array\n";
-    int arr[] = {1, 1, 2, 3, 3, 3, 4};
-    for (auto i : unique_justseen(arr)) {
-        std::cout << i << " ";
-    }
-    std::cout << '\n';
-
-    return 0;
-}
diff --git a/tests/testzip.cpp b/tests/testzip.cpp
deleted file mode 100644
index 76a95fd7..00000000
--- a/tests/testzip.cpp
+++ /dev/null
@@ -1,118 +0,0 @@
-#include <zip.hpp>
-#include <chain.hpp>
-#include <range.hpp>
-
-#include <vector>
-#include <string>
-#include <iostream>
-#include <array>
-#include <cassert>
-
-using iter::zip;
-
-int main() {
-    //Ryan's test
-    {
-        for (auto t : zip()) { t=t; }
-
-        std::vector<int> ivec{1, 4, 9, 16, 25, 36};
-        std::vector<std::string> svec{"hello", "good day", "goodbye"};
-
-        constexpr int magic_value = 69;
-        for (auto e : zip(ivec, svec)) {
-            auto &i = std::get<0>(e);
-            std::cout << i << std::endl;
-            i = magic_value;
-            std::cout << std::get<1>(e) << std::endl;
-        }
-        assert(ivec.at(0) == magic_value);
-        for (auto e : zip(ivec, svec)) {
-            std::cout << std::get<0>(e) << std::endl;
-            std::cout << std::get<1>(e) << std::endl;
-        }
-
-        for (auto e : zip(std::vector<int>{5,6,7})) {
-            std::cout << std::get<0>(e) << std::endl;
-        }
-        for (auto e : zip(std::vector<int>{5,6,7}, std::array<int,2>{{1,2}})){
-            std::cout << std::get<0>(e) << std::endl;
-            std::cout << std::get<1>(e) << std::endl;
-        }
-
-        for (auto e : zip(iter::range(10), iter::range(10, 20))) {
-            std::cout << std::get<0>(e) << '\n';
-            std::cout << std::get<1>(e) << '\n';
-        }
-
-        int arr[] = {1,2,3,3,4};
-        for (auto e : zip(iter::range(10), arr)) {
-            std::cout << std::get<0>(e) << '\n';
-            std::cout << std::get<1>(e) << '\n';
-        }
-            
-    }
-    //Aaron's test
-    {
-        std::array<int,4> i{{1,2,3,4}};
-        std::vector<float> f{1.2,1.4,12.3,4.5,9.9};
-        std::vector<std::string> s{"i","like","apples","alot","dude"};
-        std::array<double,5> d{{1.2,1.2,1.2,1.2,1.2}};
-        std::cout << std::endl << "Variadic template zip iterator" << std::endl;
-        for (auto e : iter::zip(i,f,s,d)) {
-            std::cout << std::get<0>(e) << " " 
-                << std::get<1>(e) << " " 
-                << std::get<2>(e) << " "
-                << std::get<3>(e) << std::endl;
-            std::get<1>(e)=2.2f; //modify the float array
-        }
-        std::cout<<std::endl;
-        for (auto e : iter::zip(i,s,f,d)) {
-            std::cout << std::get<0>(e) << " " 
-                << std::get<1>(e) << " "
-                << std::get<2>(e) << " " 
-                << std::get<3>(e) << std::endl;
-        }
-        std::cout << std::endl << "Try some weird range differences" << std::endl;
-        std::vector<int> empty{};
-        for (auto e : iter::zip(empty,f,s,d)) {
-            std::cout << std::get<0>(e) << " " 
-                << std::get<1>(e) << " " 
-                << std::get<2>(e) << " "
-                << std::get<3>(e) << std::endl;
-        }
-        std::cout<<std::endl;
-        for (auto e : iter::zip(f,s,empty,d)) {
-            std::cout << std::get<0>(e) << " " 
-                << std::get<1>(e) << " " 
-                << std::get<2>(e) << " "
-                << std::get<3>(e) << std::endl;
-        }//both should print nothing
-        std::cout<<std::endl;
-        for (auto e : iter::zip(f,s,i,d)) { //i should be the limiter now
-            std::cout << std::get<0>(e) << " " 
-                << std::get<1>(e) << " " 
-                << std::get<2>(e) << " "
-                << std::get<3>(e) << std::endl;
-        }
-        std::cout<<std::endl;
-        const std::vector<double> constvector{1.1,2.2,3.3,4.4};
-        for (auto e : zip(
-                    iter::chain(std::vector<int>{5,6},
-                               std::array<int,2>{{1,2}}),
-                    std::initializer_list<const char *>{
-                         "asdfas","aaron","ryan","apple","juice"},
-                    std::initializer_list<int>{1, 2, 3, 4},
-                    constvector)) 
-        { 
-
-            std::cout << std::get<0>(e) << " " 
-                << std::get<1>(e) << " "
-                << std::get<2>(e)
-                << '\n';
-        }
-    }
-
-
-    return 0;
-}
-
diff --git a/tests/testzip_longest.cpp b/tests/testzip_longest.cpp
deleted file mode 100644
index 63dc8fd0..00000000
--- a/tests/testzip_longest.cpp
+++ /dev/null
@@ -1,96 +0,0 @@
-#include <zip_longest.hpp>
-
-#include <vector>
-#include <string>
-#include <iostream>
-#include <array>
-#include <boost/optional.hpp>
-
-using iter::zip_longest;
-
-template <typename T>
-std::ostream & operator<<(std::ostream & out, const boost::optional<T>& opt) {
-    if (opt) {
-        out << "Just " << *opt;
-    } else {
-        out << "Nothing";
-    }
-    return out;
-}
-
-int main() {
-    //Ryan's test
-    {
-        std::vector<int> ivec{1, 4, 9, 16, 25, 36};
-        std::vector<std::string> svec{"hello", "good day", "goodbye"};
-
-        for (auto e : zip_longest(ivec, svec)) {
-            std::cout << std::get<0>(e) << std::endl; 
-            std::cout << std::get<1>(e) << std::endl; 
-        }
-
-        for (auto e : zip_longest("helloworld",
-                    std::vector<int>{1,2,3})) {
-            std::cout << std::get<0>(e) << std::endl; 
-            std::cout << std::get<1>(e) << std::endl; 
-        }
-    }
-    //Aaron's test
-    {
-        std::array<int,4> i{{1,2,3,4}};
-        std::vector<float> f{1.2,1.4,12.3,4.5,9.9};
-        std::vector<std::string> s{"i","like","apples","alot","dude"};
-        std::array<double,5> d{{1.2,1.2,1.2,1.2,1.2}};
-        std::cout << std::endl << "Variadic template zip_longest" << std::endl;
-        for (auto e : iter::zip_longest(i,f,s,d)) {
-            std::cout << std::get<0>(e) << ' '
-                << std::get<1>(e) << ' '
-                << std::get<2>(e) << ' '
-                << std::get<3>(e) << std::endl;
-            *std::get<1>(e)=2.2f; //modify the float array
-        }
-        std::cout<<"modified array" <<std::endl;
-        for (auto e : iter::zip_longest(i,s,f,d)) {
-            std::cout << std::get<0>(e) << ' '
-                << std::get<1>(e) << ' '
-                << std::get<2>(e) << ' '
-                << std::get<3>(e) << std::endl;
-        }
-        std::cout << std::endl << "Try some weird range differences" << std::endl;
-        std::vector<int> empty{};
-        for (auto e : iter::zip_longest(empty,f,s,d)) {
-            std::cout << std::get<0>(e) << ' '
-                << std::get<1>(e) << ' '
-                << std::get<2>(e) << ' '
-                << std::get<3>(e) << std::endl;
-        }
-        std::cout<<std::endl;
-        for (auto e : iter::zip_longest(f,empty,s,d)) {
-            std::cout << std::get<0>(e) << ' '
-                << std::get<1>(e) << ' '
-                << std::get<2>(e) << ' '
-                << std::get<3>(e) << std::endl;
-        }
-        std::cout<<std::endl;
-        for (auto e : iter::zip_longest(f,s,i,d)) { 
-            std::cout << std::get<0>(e) << ' '
-                << std::get<1>(e) << ' '
-                << std::get<2>(e) << ' '
-                << std::get<3>(e) << std::endl;
-        }
-        std::cout<<std::endl;
-        for (auto e : iter::zip_longest(std::initializer_list<int>{1,2,3,4,5,6},
-                    std::initializer_list<double>{1.1,2.2,3.3,4.4},
-                    std::initializer_list<double>{1.1,2.2,3.3,4.4},
-                    std::array<int,3>{{1,2,3}})) { 
-            std::cout << std::get<0>(e) << ' '
-                << std::get<1>(e) << ' '
-                << std::get<2>(e) << ' '
-                << std::get<3>(e) << std::endl;
-        }
-        std::cout<<std::endl;
-
-    }
-    return 0;
-}
-

From 4bb2d134ee3b47b45b995b6677859697741557be Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 2 May 2015 10:30:49 -0700
Subject: [PATCH 1109/1866] replaces everseen test with examples

---
 examples/unique_everseen_examples.cpp | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 examples/unique_everseen_examples.cpp

diff --git a/examples/unique_everseen_examples.cpp b/examples/unique_everseen_examples.cpp
new file mode 100644
index 00000000..a670f0b1
--- /dev/null
+++ b/examples/unique_everseen_examples.cpp
@@ -0,0 +1,13 @@
+#include <unique_everseen.hpp>
+
+#include <vector>
+#include <iostream>
+
+int main() {
+    std::vector<int> v {1,2,3,4,3,2,1,5,6,7,7,8,9,8,9,6};
+    std::cout << "omits all duplicates: ";
+    for (auto&& i : iter::unique_everseen(v)) {
+        std::cout << i << ' ';
+    }
+    std::cout << '\n';
+}

From efdd82da8ed5d1ce271ede8d17c097bce273ae24 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 2 May 2015 10:32:05 -0700
Subject: [PATCH 1110/1866] cuts down range examples

---
 examples/range_examples.cpp | 105 +++++++++++++++---------------------
 1 file changed, 42 insertions(+), 63 deletions(-)

diff --git a/examples/range_examples.cpp b/examples/range_examples.cpp
index 9404ae57..1dd03199 100644
--- a/examples/range_examples.cpp
+++ b/examples/range_examples.cpp
@@ -2,82 +2,61 @@
 
 #include <iostream>
 
-using iter::range;
-
-int main()
-{
-    for (auto i : range(10)) {
-        std::cout << i << std::endl;
-    }
-    for (auto i : range(20, 30)) {
-        std::cout << i << std::endl;
-    }
-    for (auto i : range(50, 60, 2)) {
-        std::cout << i << std::endl;
+int main() {
+    // print [0, 10)
+    std::cout << "range(10): { ";
+    for (auto i : iter::range(10)) {
+        std::cout << i << ' ';
     }
+    std::cout << "}\n";
 
-    std::cout << "Negative Tests\n";
-    for (auto i: range(-10, 0)) {
-        std::cout << i << std::endl;
+    // print [20, 30)
+    std::cout << "range(20, 30): { ";
+    for (auto i : iter::range(20, 30)) {
+        std::cout << i << ' ';
     }
+    std::cout << "}\n";
 
-    for (auto i : range(-10, 10, 2)) {
-        std::cout << i << std::endl;
+    // prints every second number in the range [50, 60)
+    std::cout << "range(50, 60, 2): { ";
+    for (auto i : iter::range(50, 60, 2)) {
+        std::cout << i << ' ';
     }
+    std::cout << "}\n";
 
-    std::cout << "Tests where (stop - start)%step != 0" << std::endl;
-    for (auto i : range(1, 10, 2)) {
-        std::cout << i << std::endl;
+    // prints every second number in the range [-10, 10)
+    std::cout << "range(-10, 10, 2): { ";
+    for (auto i : iter::range(-10, 10, 2)) {
+        std::cout << i << ' ';
     }
+    std::cout << "}\n";
 
-    for (auto i : range(-1, -10, -2)) {
-        std::cout << i << std::endl;
-    }
-    
-    std::cout << "Tests with different types" << std::endl;
-    for(auto i : range(5.0, 10.0, 0.5)) {
-        std::cout << i << std::endl;
+    // the step doesn't need to cause i to equal stop eventually
+    std::cout << "range(0, 5, 4): { ";
+    for (auto i : iter::range(0, 5, 4)) {
+        std::cout << i << ' ';
     }
-	std::cout << "test unsigned" << std::endl;
-	std::cout << "empty range: " << std::endl;
-	size_t len = 0;
-	for(auto i : range(len)){
-	  std::cout << i << std::endl;
-	}
-	std::cout << "stop only" << std::endl;
-	len = 3;
-	for(auto i : range(len)){
-	  std::cout << i << std::endl;
-	}
-	std::cout << "start stop" << std::endl;
-	size_t start = 1;
-	for(auto i : range(start, len)){
-	  std::cout << i << std::endl;
-	}
+    std::cout << "}\n";
 
-	std::cout << "start stop skip" << std::endl;
-	len = 10;
-	size_t skip = 3;
-	for(auto i : range(start, len, skip)){
-	  std::cout << i << std::endl;
-	}
-	
-
-
-    // invalid ranges:
-    std::cout << "Should not print anything after this line until exception\n";
-    for (auto i : range(-10, 0, -1)) {
-        std::cout << i << std::endl;
+    // ranges can count down as well as up
+    std::cout << "range(-1, -10, -2): { ";
+    for (auto i : iter::range(-1, -10, -2)) {
+        std::cout << i << ' ';
     }
+    std::cout << "}\n";
 
-    for (auto i : range(0, 1, -1)) {
-        std::cout << i << std::endl;
+    // range works with floats and other types as well
+    // the usual concerns with float comparison come into play here
+    std::cout << "range(5.0, 9.9, 0.5): { ";
+    for(auto i : iter::range(5.0, 9.9, 0.5)) {
+        std::cout << i << ' ';
     }
+    std::cout << "}\n";
 
-    std::cout << "Should see exception now\n";
-    for (auto i : range(0, 10, 0) ) {
-        std::cout << i << std::endl;
+    // range also works with unsigned values
+    std::cout << "range(10u): { ";
+    for(auto i : iter::range(10u)){
+        std::cout << i << ' ';
     }
-
-    return 0;
+    std::cout << "}\n";
 }

From ae71f8da81653e83f5d9c95f99f73af1a6ddf5a1 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 2 May 2015 10:33:30 -0700
Subject: [PATCH 1111/1866] moves a line

---
 examples/cycle_examples.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/examples/cycle_examples.cpp b/examples/cycle_examples.cpp
index 51eecafb..7f973d66 100644
--- a/examples/cycle_examples.cpp
+++ b/examples/cycle_examples.cpp
@@ -5,9 +5,10 @@
 #include <iostream>
 
 int main() {
+    size_t count = 0;
+
     std::cout << "cycle({2, 4, 6}) run 20 times:\n";
     std::vector<int> vec = {2, 4, 6};
-    size_t count = 0;
     for (auto&& i : iter::cycle(vec)) {
         std::cout << i << '\n';
         if (count == 20) {

From 7da524261a710fa6a07a7eeb353c93f87ce5bdfa Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 2 May 2015 10:33:46 -0700
Subject: [PATCH 1112/1866] makes sample operator* const

---
 examples/samples.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/samples.hpp b/examples/samples.hpp
index 9faba373..690fb71f 100644
--- a/examples/samples.hpp
+++ b/examples/samples.hpp
@@ -60,7 +60,7 @@ namespace itertest {
 
                     // for testing, iterator derefences to an int instead of
                     // an int&
-                    int operator*() /*const*/ {
+                    int operator*() const {
                         return *this->current;
                     }
 

From 1aa86424b0b81dfc1ad71d1243da2a597ee7683f Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 2 May 2015 10:33:58 -0700
Subject: [PATCH 1113/1866] ignores examples executables

---
 examples/.gitignore | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/examples/.gitignore b/examples/.gitignore
index a77d502e..61b23b0e 100644
--- a/examples/.gitignore
+++ b/examples/.gitignore
@@ -1,5 +1,4 @@
 *.o
 *.swp
-test*
-!test*.cpp
+*_examples
 .sconsign.dblite

From c17104c136679454e5cc56adbc19acae28df2122 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 2 May 2015 10:34:27 -0700
Subject: [PATCH 1114/1866] builds examples

---
 examples/SConstruct | 62 +++++++++++++++++++++------------------------
 1 file changed, 29 insertions(+), 33 deletions(-)

diff --git a/examples/SConstruct b/examples/SConstruct
index 74195c1e..41acb956 100644
--- a/examples/SConstruct
+++ b/examples/SConstruct
@@ -13,39 +13,35 @@ env = Environment(
 # allows highighting to print to terminal from compiler output
 env['ENV']['TERM'] = os.environ['TERM']
 
-progs = Split('''
-              accumulate
-              cycle 
-              enumerate 
-              range 
-              zip 
-              slice 
-              reversed 
-              filter 
-              repeat 
-              takewhile 
-              dropwhile 
-              zip_longest 
-              product 
-              permutations 
-              compress 
-              combinations_with_replacement 
-              combinations 
-              powerset
-              sliding_window
-              imap
-              count
-              filterfalse
-              grouper
-              chain
-              chainfromiterable
-              groupby
-              sorted
-              unique_justseen
-              unique_everseen
-              command_chains
-              ''')
+progs = Split(
+    '''
+    accumulate
+    chain
+    combinatoric
+    compress
+    count
+    cycle
+    dropwhile
+    enumerate
+    filter
+    filterfalse
+    groupby
+    grouper
+    imap
+    range
+    repeat
+    reversed
+    slice
+    sliding_window
+    sorted
+    takewhile
+    unique_justseen
+    unique_everseen
+    zip
+    zip_longest
+    mixed
+    ''')
 
 
 for p in progs:
-    env.Program('test{0}.cpp'.format(p))
+    env.Program('{0}_examples.cpp'.format(p))

From 3109230f96acbdd93f61753856ff89c3050910de Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Wed, 20 May 2015 00:00:04 -0700
Subject: [PATCH 1115/1866] renamed catchtest as test

---
 {catchtest => test}/.gitignore                             | 0
 {catchtest => test}/SConstruct                             | 0
 {catchtest => test}/catch.hpp                              | 0
 {catchtest => test}/helpers.hpp                            | 0
 {catchtest => test}/test_accumulate.cpp                    | 0
 {catchtest => test}/test_chain.cpp                         | 0
 {catchtest => test}/test_combinations.cpp                  | 0
 {catchtest => test}/test_combinations_with_replacement.cpp | 0
 {catchtest => test}/test_compress.cpp                      | 0
 {catchtest => test}/test_count.cpp                         | 0
 {catchtest => test}/test_cycle.cpp                         | 0
 {catchtest => test}/test_dropwhile.cpp                     | 0
 {catchtest => test}/test_enumerate.cpp                     | 0
 {catchtest => test}/test_filter.cpp                        | 0
 {catchtest => test}/test_filterfalse.cpp                   | 0
 {catchtest => test}/test_groupby.cpp                       | 0
 {catchtest => test}/test_grouper.cpp                       | 0
 {catchtest => test}/test_helpers.cpp                       | 0
 {catchtest => test}/test_imap.cpp                          | 0
 {catchtest => test}/test_iteratoriterator.cpp              | 0
 {catchtest => test}/test_main.cpp                          | 0
 {catchtest => test}/test_mixed.cpp                         | 0
 {catchtest => test}/test_permutations.cpp                  | 0
 {catchtest => test}/test_powerset.cpp                      | 0
 {catchtest => test}/test_product.cpp                       | 0
 {catchtest => test}/test_range.cpp                         | 0
 {catchtest => test}/test_repeat.cpp                        | 0
 {catchtest => test}/test_reversed.cpp                      | 0
 {catchtest => test}/test_slice.cpp                         | 0
 {catchtest => test}/test_sliding_window.cpp                | 0
 {catchtest => test}/test_sorted.cpp                        | 0
 {catchtest => test}/test_takewhile.cpp                     | 0
 {catchtest => test}/test_unique_everseen.cpp               | 0
 {catchtest => test}/test_unique_justseen.cpp               | 0
 {catchtest => test}/test_zip.cpp                           | 0
 {catchtest => test}/test_zip_longest.cpp                   | 0
 36 files changed, 0 insertions(+), 0 deletions(-)
 rename {catchtest => test}/.gitignore (100%)
 rename {catchtest => test}/SConstruct (100%)
 rename {catchtest => test}/catch.hpp (100%)
 rename {catchtest => test}/helpers.hpp (100%)
 rename {catchtest => test}/test_accumulate.cpp (100%)
 rename {catchtest => test}/test_chain.cpp (100%)
 rename {catchtest => test}/test_combinations.cpp (100%)
 rename {catchtest => test}/test_combinations_with_replacement.cpp (100%)
 rename {catchtest => test}/test_compress.cpp (100%)
 rename {catchtest => test}/test_count.cpp (100%)
 rename {catchtest => test}/test_cycle.cpp (100%)
 rename {catchtest => test}/test_dropwhile.cpp (100%)
 rename {catchtest => test}/test_enumerate.cpp (100%)
 rename {catchtest => test}/test_filter.cpp (100%)
 rename {catchtest => test}/test_filterfalse.cpp (100%)
 rename {catchtest => test}/test_groupby.cpp (100%)
 rename {catchtest => test}/test_grouper.cpp (100%)
 rename {catchtest => test}/test_helpers.cpp (100%)
 rename {catchtest => test}/test_imap.cpp (100%)
 rename {catchtest => test}/test_iteratoriterator.cpp (100%)
 rename {catchtest => test}/test_main.cpp (100%)
 rename {catchtest => test}/test_mixed.cpp (100%)
 rename {catchtest => test}/test_permutations.cpp (100%)
 rename {catchtest => test}/test_powerset.cpp (100%)
 rename {catchtest => test}/test_product.cpp (100%)
 rename {catchtest => test}/test_range.cpp (100%)
 rename {catchtest => test}/test_repeat.cpp (100%)
 rename {catchtest => test}/test_reversed.cpp (100%)
 rename {catchtest => test}/test_slice.cpp (100%)
 rename {catchtest => test}/test_sliding_window.cpp (100%)
 rename {catchtest => test}/test_sorted.cpp (100%)
 rename {catchtest => test}/test_takewhile.cpp (100%)
 rename {catchtest => test}/test_unique_everseen.cpp (100%)
 rename {catchtest => test}/test_unique_justseen.cpp (100%)
 rename {catchtest => test}/test_zip.cpp (100%)
 rename {catchtest => test}/test_zip_longest.cpp (100%)

diff --git a/catchtest/.gitignore b/test/.gitignore
similarity index 100%
rename from catchtest/.gitignore
rename to test/.gitignore
diff --git a/catchtest/SConstruct b/test/SConstruct
similarity index 100%
rename from catchtest/SConstruct
rename to test/SConstruct
diff --git a/catchtest/catch.hpp b/test/catch.hpp
similarity index 100%
rename from catchtest/catch.hpp
rename to test/catch.hpp
diff --git a/catchtest/helpers.hpp b/test/helpers.hpp
similarity index 100%
rename from catchtest/helpers.hpp
rename to test/helpers.hpp
diff --git a/catchtest/test_accumulate.cpp b/test/test_accumulate.cpp
similarity index 100%
rename from catchtest/test_accumulate.cpp
rename to test/test_accumulate.cpp
diff --git a/catchtest/test_chain.cpp b/test/test_chain.cpp
similarity index 100%
rename from catchtest/test_chain.cpp
rename to test/test_chain.cpp
diff --git a/catchtest/test_combinations.cpp b/test/test_combinations.cpp
similarity index 100%
rename from catchtest/test_combinations.cpp
rename to test/test_combinations.cpp
diff --git a/catchtest/test_combinations_with_replacement.cpp b/test/test_combinations_with_replacement.cpp
similarity index 100%
rename from catchtest/test_combinations_with_replacement.cpp
rename to test/test_combinations_with_replacement.cpp
diff --git a/catchtest/test_compress.cpp b/test/test_compress.cpp
similarity index 100%
rename from catchtest/test_compress.cpp
rename to test/test_compress.cpp
diff --git a/catchtest/test_count.cpp b/test/test_count.cpp
similarity index 100%
rename from catchtest/test_count.cpp
rename to test/test_count.cpp
diff --git a/catchtest/test_cycle.cpp b/test/test_cycle.cpp
similarity index 100%
rename from catchtest/test_cycle.cpp
rename to test/test_cycle.cpp
diff --git a/catchtest/test_dropwhile.cpp b/test/test_dropwhile.cpp
similarity index 100%
rename from catchtest/test_dropwhile.cpp
rename to test/test_dropwhile.cpp
diff --git a/catchtest/test_enumerate.cpp b/test/test_enumerate.cpp
similarity index 100%
rename from catchtest/test_enumerate.cpp
rename to test/test_enumerate.cpp
diff --git a/catchtest/test_filter.cpp b/test/test_filter.cpp
similarity index 100%
rename from catchtest/test_filter.cpp
rename to test/test_filter.cpp
diff --git a/catchtest/test_filterfalse.cpp b/test/test_filterfalse.cpp
similarity index 100%
rename from catchtest/test_filterfalse.cpp
rename to test/test_filterfalse.cpp
diff --git a/catchtest/test_groupby.cpp b/test/test_groupby.cpp
similarity index 100%
rename from catchtest/test_groupby.cpp
rename to test/test_groupby.cpp
diff --git a/catchtest/test_grouper.cpp b/test/test_grouper.cpp
similarity index 100%
rename from catchtest/test_grouper.cpp
rename to test/test_grouper.cpp
diff --git a/catchtest/test_helpers.cpp b/test/test_helpers.cpp
similarity index 100%
rename from catchtest/test_helpers.cpp
rename to test/test_helpers.cpp
diff --git a/catchtest/test_imap.cpp b/test/test_imap.cpp
similarity index 100%
rename from catchtest/test_imap.cpp
rename to test/test_imap.cpp
diff --git a/catchtest/test_iteratoriterator.cpp b/test/test_iteratoriterator.cpp
similarity index 100%
rename from catchtest/test_iteratoriterator.cpp
rename to test/test_iteratoriterator.cpp
diff --git a/catchtest/test_main.cpp b/test/test_main.cpp
similarity index 100%
rename from catchtest/test_main.cpp
rename to test/test_main.cpp
diff --git a/catchtest/test_mixed.cpp b/test/test_mixed.cpp
similarity index 100%
rename from catchtest/test_mixed.cpp
rename to test/test_mixed.cpp
diff --git a/catchtest/test_permutations.cpp b/test/test_permutations.cpp
similarity index 100%
rename from catchtest/test_permutations.cpp
rename to test/test_permutations.cpp
diff --git a/catchtest/test_powerset.cpp b/test/test_powerset.cpp
similarity index 100%
rename from catchtest/test_powerset.cpp
rename to test/test_powerset.cpp
diff --git a/catchtest/test_product.cpp b/test/test_product.cpp
similarity index 100%
rename from catchtest/test_product.cpp
rename to test/test_product.cpp
diff --git a/catchtest/test_range.cpp b/test/test_range.cpp
similarity index 100%
rename from catchtest/test_range.cpp
rename to test/test_range.cpp
diff --git a/catchtest/test_repeat.cpp b/test/test_repeat.cpp
similarity index 100%
rename from catchtest/test_repeat.cpp
rename to test/test_repeat.cpp
diff --git a/catchtest/test_reversed.cpp b/test/test_reversed.cpp
similarity index 100%
rename from catchtest/test_reversed.cpp
rename to test/test_reversed.cpp
diff --git a/catchtest/test_slice.cpp b/test/test_slice.cpp
similarity index 100%
rename from catchtest/test_slice.cpp
rename to test/test_slice.cpp
diff --git a/catchtest/test_sliding_window.cpp b/test/test_sliding_window.cpp
similarity index 100%
rename from catchtest/test_sliding_window.cpp
rename to test/test_sliding_window.cpp
diff --git a/catchtest/test_sorted.cpp b/test/test_sorted.cpp
similarity index 100%
rename from catchtest/test_sorted.cpp
rename to test/test_sorted.cpp
diff --git a/catchtest/test_takewhile.cpp b/test/test_takewhile.cpp
similarity index 100%
rename from catchtest/test_takewhile.cpp
rename to test/test_takewhile.cpp
diff --git a/catchtest/test_unique_everseen.cpp b/test/test_unique_everseen.cpp
similarity index 100%
rename from catchtest/test_unique_everseen.cpp
rename to test/test_unique_everseen.cpp
diff --git a/catchtest/test_unique_justseen.cpp b/test/test_unique_justseen.cpp
similarity index 100%
rename from catchtest/test_unique_justseen.cpp
rename to test/test_unique_justseen.cpp
diff --git a/catchtest/test_zip.cpp b/test/test_zip.cpp
similarity index 100%
rename from catchtest/test_zip.cpp
rename to test/test_zip.cpp
diff --git a/catchtest/test_zip_longest.cpp b/test/test_zip_longest.cpp
similarity index 100%
rename from catchtest/test_zip_longest.cpp
rename to test/test_zip_longest.cpp

From 8b58b1d86762729126e5b2cc7c7a27c172e1475c Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Wed, 20 May 2015 00:06:49 -0700
Subject: [PATCH 1116/1866] removes old tests

---
 tests/.gitignore                            |   5 -
 tests/SConstruct                            |  52 ---------
 tests/samples.hpp                           |  98 ----------------
 tests/testaccumulate.cpp                    |  33 ------
 tests/testchain.cpp                         |  67 -----------
 tests/testchainfromiterable.cpp             |  28 -----
 tests/testcombinations.cpp                  |  75 -------------
 tests/testcombinations_with_replacement.cpp |  55 ---------
 tests/testcommand_chains.cpp                |  78 -------------
 tests/testcompress.cpp                      |  67 -----------
 tests/testcount.cpp                         |  38 -------
 tests/testcycle.cpp                         |  70 ------------
 tests/testdropwhile.cpp                     |  35 ------
 tests/testenumerate.cpp                     |  60 ----------
 tests/testfilter.cpp                        |  83 --------------
 tests/testfilterfalse.cpp                   |  93 ---------------
 tests/testgroupby.cpp                       | 109 ------------------
 tests/testgrouper.cpp                       |  51 ---------
 tests/testimap.cpp                          |  45 --------
 tests/testpermutations.cpp                  |  60 ----------
 tests/testpowerset.cpp                      |  44 --------
 tests/testproduct.cpp                       |  77 -------------
 tests/testrange.cpp                         |  83 --------------
 tests/testrepeat.cpp                        |  31 -----
 tests/testreversed.cpp                      |  43 -------
 tests/testslice.cpp                         |  81 --------------
 tests/testsliding_window.cpp                |  53 ---------
 tests/testsorted.cpp                        |  36 ------
 tests/teststarmap.cpp                       |  83 --------------
 tests/testtakewhile.cpp                     |  32 ------
 tests/testunique_everseen.cpp               |  41 -------
 tests/testunique_justseen.cpp               |  35 ------
 tests/testzip.cpp                           | 118 --------------------
 tests/testzip_longest.cpp                   |  96 ----------------
 34 files changed, 2055 deletions(-)
 delete mode 100644 tests/.gitignore
 delete mode 100644 tests/SConstruct
 delete mode 100644 tests/samples.hpp
 delete mode 100644 tests/testaccumulate.cpp
 delete mode 100644 tests/testchain.cpp
 delete mode 100644 tests/testchainfromiterable.cpp
 delete mode 100644 tests/testcombinations.cpp
 delete mode 100644 tests/testcombinations_with_replacement.cpp
 delete mode 100644 tests/testcommand_chains.cpp
 delete mode 100644 tests/testcompress.cpp
 delete mode 100644 tests/testcount.cpp
 delete mode 100644 tests/testcycle.cpp
 delete mode 100644 tests/testdropwhile.cpp
 delete mode 100644 tests/testenumerate.cpp
 delete mode 100644 tests/testfilter.cpp
 delete mode 100644 tests/testfilterfalse.cpp
 delete mode 100644 tests/testgroupby.cpp
 delete mode 100644 tests/testgrouper.cpp
 delete mode 100644 tests/testimap.cpp
 delete mode 100644 tests/testpermutations.cpp
 delete mode 100644 tests/testpowerset.cpp
 delete mode 100644 tests/testproduct.cpp
 delete mode 100644 tests/testrange.cpp
 delete mode 100644 tests/testrepeat.cpp
 delete mode 100644 tests/testreversed.cpp
 delete mode 100644 tests/testslice.cpp
 delete mode 100644 tests/testsliding_window.cpp
 delete mode 100644 tests/testsorted.cpp
 delete mode 100644 tests/teststarmap.cpp
 delete mode 100644 tests/testtakewhile.cpp
 delete mode 100644 tests/testunique_everseen.cpp
 delete mode 100644 tests/testunique_justseen.cpp
 delete mode 100644 tests/testzip.cpp
 delete mode 100644 tests/testzip_longest.cpp

diff --git a/tests/.gitignore b/tests/.gitignore
deleted file mode 100644
index a77d502e..00000000
--- a/tests/.gitignore
+++ /dev/null
@@ -1,5 +0,0 @@
-*.o
-*.swp
-test*
-!test*.cpp
-.sconsign.dblite
diff --git a/tests/SConstruct b/tests/SConstruct
deleted file mode 100644
index 8e344b2b..00000000
--- a/tests/SConstruct
+++ /dev/null
@@ -1,52 +0,0 @@
-import os
-
-env = Environment(
-    ENV = {'PATH' : os.environ['PATH']},
-    CXX='c++',
-    CXXFLAGS= ['-g', '-Wall', '-Wextra',
-               '-pedantic', '-std=c++14',
-                '-fdiagnostics-color=always',
-               '-I/usr/local/include'],
-    CPPPATH='..',
-    LINKFLAGS='-L/usr/local/lib')
-
-# allows highighting to print to terminal from compiler output
-env['ENV']['TERM'] = os.environ['TERM']
-
-progs = Split('''
-              accumulate
-              cycle 
-              enumerate 
-              range 
-              zip 
-              slice 
-              reversed 
-              filter 
-              repeat 
-              takewhile 
-              dropwhile 
-              zip_longest 
-              product 
-              permutations 
-              compress 
-              combinations_with_replacement 
-              combinations 
-              powerset
-              sliding_window
-              imap
-              starmap
-              count
-              filterfalse
-              grouper
-              chain
-              chainfromiterable
-              groupby
-              sorted
-              unique_justseen
-              unique_everseen
-              command_chains
-              ''')
-
-
-for p in progs:
-    env.Program('test{0}.cpp'.format(p))
diff --git a/tests/samples.hpp b/tests/samples.hpp
deleted file mode 100644
index 820d2c1e..00000000
--- a/tests/samples.hpp
+++ /dev/null
@@ -1,98 +0,0 @@
-#ifndef ITERTOOLS_SAMPLE_CLASSES_HPP
-#define ITERTOOLS_SAMPLE_CLASSES_HPP
-
-#include <iostream>
-#include <utility>
-#include <cstddef>
-
-namespace itertest {
-    class MoveOnly {
-        private:
-            int i; // not an aggregate
-        public:
-            MoveOnly(int v)
-                : i{v}
-            { }
-
-            MoveOnly(const MoveOnly&) = delete;
-            MoveOnly& operator=(const MoveOnly&) = delete;
-
-            MoveOnly(MoveOnly&& other) noexcept
-                : i{other.i}
-            { }
-
-            MoveOnly& operator=(MoveOnly&& other) noexcept {
-                this->i = other.i;
-                return *this;
-            }
-
-            // for std::next_permutation compatibility
-            friend bool operator<(const MoveOnly& lhs, const MoveOnly& rhs) {
-                return lhs.i < rhs.i;
-            }
-
-            friend std::ostream& operator<<(
-                    std::ostream& out, const MoveOnly& self) {
-                return out << self.i;
-            }
-
-    };
-
-    class DerefByValue {
-        private:
-            static constexpr std::size_t N = 3;
-            int array[N] = {0, 1, 2};
-        public:
-            DerefByValue() = default;
-
-            class Iterator {
-                private:
-                    int *current;
-                public:
-                    Iterator() = default;
-                    Iterator(int *p)
-                        : current{p}
-                    { }
-
-                    bool operator!=(const Iterator& other) const {
-                        return this->current != other.current;
-                    }
-
-                    // for testing, iterator derefences to an int instead of
-                    // an int&
-                    int operator*() {
-                        return *this->current;
-                    }
-
-                    Iterator& operator++() {
-                        ++this->current;
-                        return *this;
-                    }
-            };
-
-            Iterator begin() {
-                return {this->array};
-            }
-
-            Iterator end() {
-                return {this->array + N};
-            }
-    };
-
-    class DerefByValueFancy {
-        private:
-            static constexpr std::size_t N = 3;
-            int array[N] = {0, 1, 2};
-        public:
-            DerefByValueFancy() = default;
-
-            int *begin() {
-                return this->array;
-            }
-
-            int *end() {
-                return this->array + N;
-            }
-    };
-}
-#endif // #ifndef ITERTOOLS_SAMPLE_CLASSES_HPP
diff --git a/tests/testaccumulate.cpp b/tests/testaccumulate.cpp
deleted file mode 100644
index 2321ffca..00000000
--- a/tests/testaccumulate.cpp
+++ /dev/null
@@ -1,33 +0,0 @@
-#include <accumulate.hpp>
-#include <range.hpp>
-
-#include <iostream>
-#include <vector>
-
-int main() {
-    std::vector<int> vec = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
-    for (auto v : iter::accumulate(vec, [](int a, int b){return a - b;})) {
-        std::cout << v << '\n';
-    }
-    for (auto v : iter::accumulate(iter::range(10),
-                [](int a, int b){return a - b;})) {
-        std::cout << v << '\n';
-    }
-    for (auto v : iter::accumulate({0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
-                [](int a, int b){return a - b;})) {
-        std::cout << v << '\n';
-    }
-
-    for (auto v : iter::accumulate(iter::range(10))) {
-        std::cout << v << '\n';
-    }
-    for (auto v : iter::accumulate({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})) {
-        std::cout << v << '\n';
-    }
-
-    for (auto v : iter::accumulate(std::vector<int>{1,2,3,4,5,6,7,8,9})) {
-        std::cout << v << '\n';
-    }
-
-    return 0;
-}
diff --git a/tests/testchain.cpp b/tests/testchain.cpp
deleted file mode 100644
index 3dfde3d1..00000000
--- a/tests/testchain.cpp
+++ /dev/null
@@ -1,67 +0,0 @@
-#include <chain.hpp>
-#include <range.hpp>
-
-#include <vector>
-#include <string>
-#include <iostream>
-#include <array>
-#include <initializer_list>
-
-using iter::chain;
-using il = std::initializer_list<int>; 
-
-int main() {
-
-    {
-        std::vector<int> ivec{1, 4, 7, 9};
-        std::vector<int> lvec{100, 200, 300, 400, 500, 600};
-
-        for (auto e : chain(ivec, lvec)) {
-            std::cout << e << std::endl;
-        }
-
-        auto c = chain(ivec, lvec);
-        auto it = std::begin(c);
-        auto it2 = std::begin(c);
-        it = it2;
-    }
-    {
-        std::vector<int> empty{};
-        std::vector<int> vec1{1,2,3,4,5,6};
-        std::array<int,4> arr1{{7,8,9,10}};
-        std::array<int,3> arr2{{11,12,13}};
-        std::cout << std::endl << "Chain iter test" << std::endl;
-        for (auto i : iter::chain(empty,vec1,arr1)) {
-            std::cout << i << std::endl;
-        }
-        std::cout<<std::endl;
-        for (auto i : iter::chain(vec1,empty,arr1)) {
-            std::cout << i << std::endl;
-        }
-        std::cout<<std::endl;
-        for (auto i : iter::chain(vec1,arr1,empty)) {
-            std::cout << i << std::endl;
-        }
-        std::cout<<std::endl;//modifying the range
-        for (auto & i : iter::chain(vec1,arr1,arr2)) {
-            i = 0;//0 out the whole thing
-        }
-        std::cout<<std::endl;
-        for (auto i : iter::chain(vec1,arr1,arr2)) {
-            std::cout << i << std::endl;
-        }
-        //test only works with perfect forwarding
-        std::cout<<std::endl;
-        for (auto i : chain(il{1,2,3,4,5},il{6,7,8,9},il{10,11,12})) {
-            std::cout << i << std::endl;
-        }
-
-        // test with temporaries
-        std::cout << '\n';
-        for (auto i : chain(std::vector<int>{1,2,3,4},
-                    std::array<int,4>{{5,6,7,8}})) {
-            std::cout << i << '\n';
-        }
-    }
-
-}
diff --git a/tests/testchainfromiterable.cpp b/tests/testchainfromiterable.cpp
deleted file mode 100644
index f4b6d599..00000000
--- a/tests/testchainfromiterable.cpp
+++ /dev/null
@@ -1,28 +0,0 @@
-#include <chain.hpp>
-
-#include <iostream>
-#include <vector>
-
-using iter::chain;
-
-int main() {
-    std::vector<std::vector<int>> matrix = {
-        {1, 2, 3},
-        {4, 5},
-        {6, 8, 9, 10, 11, 12}
-    };
-    for (auto i : chain.from_iterable(matrix)) {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "with temporary\n";
-    for (auto i : chain.from_iterable(std::vector<std::vector<int>>{
-                    {1, 2, 3},
-                    {4, 5},
-                    {6, 8, 9, 10, 11, 12}
-                })) {
-        std::cout << i << '\n';
-    }
-
-    return 0;
-}
diff --git a/tests/testcombinations.cpp b/tests/testcombinations.cpp
deleted file mode 100644
index 4dce1139..00000000
--- a/tests/testcombinations.cpp
+++ /dev/null
@@ -1,75 +0,0 @@
-#include "samples.hpp"
-#include <combinations.hpp>
-#include <range.hpp>
-
-#include <vector>
-#include <string>
-#include <iostream>
-#include <array>
-
-using iter::combinations;
-int main() {
-    itertest::DerefByValue dbv; 
-    std::vector<itertest::MoveOnly> mv;
-    for (auto i : iter::range(3)) {
-        mv.emplace_back(i);
-    }
-    std::vector<int> v = {1,2,3,4,5};
-
-    for (auto i : combinations(mv,2)) {
-        for (auto j : i ) std::cout << j << " ";
-        std::cout<<std::endl;
-    }
-
-    for (auto i : combinations(v,0)) {
-        for (auto j : i ) std::cout << j << " ";
-        std::cout<<std::endl;
-    }
-
-    for (auto i : combinations(v,3)) {
-        for (auto j : i ) std::cout << j << " ";
-        std::cout<<std::endl;
-    }
-
-    for (auto i : combinations(v,1)) {
-        for (auto j : i ) std::cout << j << " ";
-        std::cout<<std::endl;
-    }
-
-    for (auto i : combinations(v,5)) {
-        for (auto j : i ) std::cout << j << " ";
-        std::cout<<std::endl;
-    }
-
-    std::cout << "deref by value\n";
-    for (auto i : combinations(dbv, 2)) {
-        for (auto j : i) std::cout << j << " ";
-        std::cout << '\n';
-    }
-
-    std::cout << "initializer list\n";
-    for (auto i : combinations({1,2,3,4},3)) {
-        for (auto j : i ) std::cout << j << " ";
-        std::cout<<std::endl;
-
-    }
-
-    std::cout << "initializer list\n";
-    for (auto i : combinations({1,2,3,4},1)) {
-        for (auto j : i ) std::cout << j << " ";
-        std::cout<<std::endl;
-    }
-
-    std::cout << "temporary\n";
-    for (auto i : combinations(std::vector<int>{1,2,3,4,5}, 3)) {
-        for (auto j : i ) std::cout << j << " ";
-        std::cout<<std::endl;
-    }
-
-    std::cout << "static array\n";
-    int array[] = {1,2,3,4,5};
-    for (auto i : combinations(array, 3)) {
-        for (auto j : i) std::cout << j << " ";
-        std::cout << '\n';
-    }
-}
diff --git a/tests/testcombinations_with_replacement.cpp b/tests/testcombinations_with_replacement.cpp
deleted file mode 100644
index 78b8751e..00000000
--- a/tests/testcombinations_with_replacement.cpp
+++ /dev/null
@@ -1,55 +0,0 @@
-#include "samples.hpp"
-#include <combinations_with_replacement.hpp>
-#include <range.hpp>
-
-#include <vector>
-#include <string>
-#include <iostream>
-#include <array>
-
-using iter::combinations_with_replacement;
-
-int main() {
-    std::vector<itertest::MoveOnly> mv;
-    for (auto i : iter::range(3)) {
-        mv.emplace_back(i);
-    }
-
-    std::vector<int> v = {1,2,3,};
-    for (auto i : combinations_with_replacement(v,4)) {
-        for (auto j : i ) std::cout << j << " ";
-        std::cout<<std::endl;
-    }
-
-    itertest::DerefByValue dbv;
-    std::cout << "with deref by value iterator\n";
-    for (auto i : combinations_with_replacement(dbv, 2)) {
-        for (auto j : i ) std::cout << j << " ";
-        std::cout<<std::endl;
-    }
-
-    std::cout << "with container of move-only\n";
-    for (auto i : combinations_with_replacement(mv,2)) {
-        for (auto j : i ) std::cout << j << " ";
-        std::cout<<std::endl;
-    }
-
-    std::cout << "with temporary\n";
-    for (auto i : combinations_with_replacement(std::vector<int>{1,2,3},4)) {
-        for (auto j : i ) std::cout << j << " ";
-        std::cout<<std::endl;
-    }
-
-    std::cout << "with init list\n";
-    for (auto i : combinations_with_replacement({1,2,3},4)) {
-        for (auto j : i ) std::cout << j << " ";
-        std::cout<<std::endl;
-    }
-
-    std::cout << "with static array\n";
-    int arr[] = {1, 2, 3};
-    for (auto i : combinations_with_replacement(arr,4)) {
-        for (auto j : i ) std::cout << j << " ";
-        std::cout<<std::endl;
-    }
-}
diff --git a/tests/testcommand_chains.cpp b/tests/testcommand_chains.cpp
deleted file mode 100644
index e116f131..00000000
--- a/tests/testcommand_chains.cpp
+++ /dev/null
@@ -1,78 +0,0 @@
-#include <itertools.hpp>
-
-#include <vector>
-#include <tuple>
-#include <array>
-#include <iostream>
-#include <string>
-
-using namespace iter;
-
-template <typename T>
-std::ostream & operator<<(std::ostream & out, const boost::optional<T>& opt) {
-    if (opt) {
-        out << "Just " << *opt;
-    } else {
-        out << "Nothing";
-    }
-    return out;
-}
-int main() {
-    {
-        std::vector<int> vec1{1,2,3,4,5,6};
-        std::vector<int> vec2{1,2,3,4,5};
-        std::vector<std::string> strvec
-        {"his","name","was","robert","paulson","his","name","was","robert","paulson"};
-        for (auto t : zip_longest(chain(vec1,vec2),strvec)) {
-            std::cout << std::get<0>(t) << " "
-                << std::get<1>(t) << std::endl;
-        }
-    }
-
-    std::string str = "hello world";
-    std::vector<int> vec = {6, 9, 6, 9};
-    for (auto p : enumerate(enumerate(str))) { (void)p; }
-    for (auto p : enumerate(zip(str, vec))) { (void)p; }
-
-    std::cout << std::endl;
-    {
-        std::vector<int> vec1{1,2,3,4,5,6};
-        std::vector<int> vec2{7,8,9,10};
-        std::vector<std::string> strvec
-        {"We're","done","when","I","say","we're","done"};
-        for (auto t : zip(strvec,chain(slice(vec1,2,6),slice(vec2,1,4)))) {
-            std::cout << std::get<0>(t) << " "
-                << std::get<1>(t) << std::endl;
-        }
-    }
-    std::cout << std::endl;
-    {
-        std::vector<int> vec1{1,2,3,4,5,6};
-        std::vector<int> vec2{7,8,9,10};
-        for (auto s : sliding_window(chain(vec1,vec2),4)) {
-            for (auto i : s) std::cout << i << " ";
-            std::cout<<std::endl;
-        }
-    }
-    std::cout << std::endl;
-
-#if 0
-    {
-        std::vector<int> vec1{1,2,3,4,5,6};
-        std::vector<int> vec2{7,8,9,10};
-        for (auto s : grouper(chain(vec1,vec2),3)) {
-            for (auto i : s) std::cout << i << " ";
-            std::cout<<std::endl;
-        }
-    }
-#endif
-    auto prod_range = iter::product(iter::range(10), iter::range(5));
-
-    for (auto&& ij: iter::filter(
-                [](std::tuple<unsigned, unsigned> const& c)
-                {return std::get<0>(c) >= std::get<1>(c);},
-                prod_range)) {
-                    std::cout << std::get<0>(ij) << "," << std::get<1>(ij) << std::endl;
-    }
-    return 0;
-}
diff --git a/tests/testcompress.cpp b/tests/testcompress.cpp
deleted file mode 100644
index 5197f3e2..00000000
--- a/tests/testcompress.cpp
+++ /dev/null
@@ -1,67 +0,0 @@
-#include <compress.hpp>
-#include <range.hpp>
-
-#include <vector>
-#include <iostream>
-
-using iter::compress;
-using iter::range;
-
-template <typename DataType, typename SelectorType>
-void testcase(std::vector<DataType> data_vec,
-        std::vector<SelectorType> sel_vec)
-{
-
-    for (auto e : compress(data_vec, sel_vec)) {
-        std::cout << e << '\n';
-    }
-}
-
-int main(void)
-{
-    std::vector<int> ivec{1, 2, 3, 4, 5, 6};
-    std::vector<bool> bvec{true, false, true, false, true, false};
-    std::cout << "Should print 1 3 5\n";
-    testcase(ivec, bvec);
-
-    std::vector<bool> bvec2{false, true, false, false, false, true};
-    std::cout << "Should print 2 6\n";
-    testcase(ivec, bvec2);
-
-    std::vector<bool> bvec3{false, true};
-    std::cout << "Should print 2\n";
-    testcase(ivec, bvec3);
-
-    std::cout << "Should print 0 2 4\n";
-    for (auto i : compress(range(10), bvec)) {
-        std::cout << i << '\n';
-    }
-    
-    std::cout << "Should print 0 2 4\n";
-    for (auto i : compress({0,1,2,3,4,5}, bvec)) {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "Should print 0 2 4\n";
-    for (auto i : compress(range(10), {true, false, true, false, true})) {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "Should print 0 2 4\n";
-    for (auto i : compress({0, 1, 2, 3, 4, 5},
-                {true, false, true, false, true}))
-    {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "Should print 0 2 4\n";
-    for (auto i : compress(std::vector<int>{0, 1, 2, 3, 4, 5},
-                std::vector<bool>{true, false, true, false, true}))
-    {
-        std::cout << i << '\n';
-    }
-
-        
-
-    return 0;
-}
diff --git a/tests/testcount.cpp b/tests/testcount.cpp
deleted file mode 100644
index 946d6841..00000000
--- a/tests/testcount.cpp
+++ /dev/null
@@ -1,38 +0,0 @@
-#include <count.hpp>
-
-#include <iostream>
-
-using iter::count;
-
-int main() {
-    for (auto i : count()) {
-        std::cout << i << '\n';
-        if (i == 100) {
-            break;
-        }
-    }
-
-    for (auto i : count(5.0, 0.5)){
-        std::cout << i << '\n';
-        if (i > 100) {
-            break;
-        }
-    }
-
-    for (auto i : count(0, -1)) {
-        std::cout << i << '\n';
-        if (i < -100) {
-            break;
-        }
-    }
-
-    for (auto i : count()) {
-        std::cout << i << '\n';
-        if (i > 10000) {
-            break;
-        }
-    }
-
-
-    return 0;
-}
diff --git a/tests/testcycle.cpp b/tests/testcycle.cpp
deleted file mode 100644
index 138692cc..00000000
--- a/tests/testcycle.cpp
+++ /dev/null
@@ -1,70 +0,0 @@
-#include <cycle.hpp>
-#include <range.hpp>
-
-#include <vector>
-#include <iostream>
-
-using iter::cycle;
-using iter::range;
-
-int main() {
-    std::vector<int> vec = {2, 4, 6};
-
-    size_t count = 0;
-    for (auto i : cycle(vec)) {
-        std::cout << i << '\n';
-        if (count == 100) {
-            break;
-        }
-        ++count;
-    }
-
-    count = 0;
-    int array[] = {68, 69, 70};
-    for (auto i : cycle(array)) {
-        std::cout << i << '\n';
-        if (count == 20) {
-            break;
-        }
-        ++count;
-    }
-
-    count = 0;
-    for (auto i : cycle({7, 8, 9})) {
-        std::cout << i << '\n';
-        if (count == 20) {
-            break;
-        }
-        ++count;
-    }
-
-    count = 0;
-    for (auto i : cycle(range(3))) {
-        std::cout << i << '\n';
-        if (count == 20) {
-            break;
-        }
-        ++count;
-    }
-
-    count = 0;
-    const std::string s("hello");
-    for (auto c : cycle(s)) {
-        std::cout << c << '\n';
-        if (count == 20) {
-            break;
-        }
-        ++count;
-    }
-
-    count = 0;
-    for (auto i : std::vector<int>{1,2,3,4,5}) {
-        std::cout << i << '\n';
-        if (count == 20) {
-            break;
-        }
-        ++count;
-    }
-
-    return 0;
-}
diff --git a/tests/testdropwhile.cpp b/tests/testdropwhile.cpp
deleted file mode 100644
index 3140f81a..00000000
--- a/tests/testdropwhile.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-#include <dropwhile.hpp>
-#include <range.hpp>
-
-#include <vector>
-#include <iostream>
-#include <cassert>
-
-using iter::dropwhile;
-using iter::range;
-
-int main() {
-    std::vector<int> ivec{1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4};
-    for (auto& i : dropwhile([] (int i) {return i < 5;}, ivec)) {
-        std::cout << i << '\n';
-        i = 69;
-    }
-    assert(ivec.at(0) == 1);
-    assert(ivec.at(4) == 69);
-
-    for (auto i : dropwhile([] (int i) {return i < 5;}, range(10))) {
-        std::cout << i << '\n';
-    }
-
-    for (auto i : dropwhile([] (int i) {return i < 5;}, 
-                {1, 2, 3, 4, 5, 6, 7, 8, 9})) {
-        std::cout << i << '\n';
-    }
-
-    for (auto i : dropwhile([] (int i) {return i < 5;}, 
-                std::vector<int>{1, 2, 3, 4, 5, 6, 7, 8, 9})) {
-        std::cout << i << '\n';
-    }
-
-    return 0;
-}
diff --git a/tests/testenumerate.cpp b/tests/testenumerate.cpp
deleted file mode 100644
index fcc1745c..00000000
--- a/tests/testenumerate.cpp
+++ /dev/null
@@ -1,60 +0,0 @@
-#include <enumerate.hpp>
-#include <range.hpp>
-
-#include <string>
-#include <iostream>
-#include <vector>
-
-using iter::enumerate;
-using iter::range;
-
-int main() {
-    std::cout << "const std::string\n";
-    const std::string const_string("goodbye world");
-    for (auto e : enumerate(const_string)) {
-        std::cout << e.index << ": " << e.element << std::endl;
-    }
-
-
-    std::vector<int> vec;
-    for(int i = 0; i < 12; ++i) { 
-        vec.push_back(i * i);
-    }
-
-
-    std::cout << "print vector element, set it to zero, then print it again\n";
-    for (auto e : enumerate(vec)) { 
-        std::cout << e.index << ": " << e.element << std::endl;
-        e.element = 0;
-        // tests to make sure vector can be edited
-        std::cout << e.index << ": " << e.element << std::endl;
-    }
-
-    std::cout << "static array\n";
-    int array[] = {1, 9, 8, 11};
-    for (auto e : enumerate(array)) {
-        std::cout << e.index << ": " << e.element << '\n';
-    }
-
-    std::cout << "initializer list\n";
-    for (auto e : enumerate({0, 1, 4, 9, 16, 25})) {
-        std::cout << e.index << "^2 = " << e.element << '\n';
-    }
-
-    std::cout << "range(10, 20, 2)\n";
-    for (auto e : enumerate(range(10, 20, 2))) {
-        std::cout << e.index << ": " << e.element << '\n';
-    }
-
-    std::cout << "range(10, 20, 2)\n";
-    for (auto e : enumerate(enumerate(range(10, 20, 2)))) {
-        std::cout << e.index << ": " << e.element.element << '\n';
-    }
-
-    std::cout << "vector temporary\n";
-    for (auto e : enumerate(std::vector<int>(5,2))) {
-        std::cout << e.index << ": " << e.element << '\n';
-    }
-
-    return 0;
-}
diff --git a/tests/testfilter.cpp b/tests/testfilter.cpp
deleted file mode 100644
index e8af2aab..00000000
--- a/tests/testfilter.cpp
+++ /dev/null
@@ -1,83 +0,0 @@
-#include <filter.hpp>
-#include <range.hpp>
-
-#include <vector>
-#include <iostream>
-
-using iter::filter;
-
-bool greater_than_four(int i) {
-    return i > 4;
-}
-
-class LessThanValue {
-    private:
-        int compare_val;
-
-    public:
-        LessThanValue() = delete;
-        LessThanValue(int v) : compare_val(v) { }
-        
-        bool operator() (int i) {
-            return i < this->compare_val;
-        }
-};
-
-
-int main() {
-    std::vector<int> vec{1, 5, 6, 7, 2, 3, 8, 3, 2, 1};
-
-    std::cout << "Greater than 4 (function pointer)\n";
-    for (auto i : filter(greater_than_four, vec)) {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "Less than 4 (lambda)\n";
-    for (auto i : filter([] (const int i) { return i < 4; }, vec)) {
-        std::cout << i << '\n';
-    }
-
-    LessThanValue lv(4);
-    std::cout << "Less than 4 (callable object)\n";
-    for (auto i : filter(lv, vec)) {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "Nonzero ints filter(vec2)\n";
-    std::vector<int> vec2 {0, 1, 2, 0, 3, 0, 0, 0, 4, 5, 0};
-    for (auto i : filter(vec2)) {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "odd numbers in range(10) temp\n";
-    for (auto i : filter([] (const int i) {return i % 2;}, iter::range(10))) {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "range(-1, 2)\n";
-    for (auto i : filter(iter::range(-1, 2))) {
-        std::cout << i << '\n';
-    }
-
-
-    std::cout << "ever numbers in initializer_list\n";
-    for (auto i : filter([] (const int i) {return i % 2 == 0;},
-                         {1, 2, 3, 4, 5, 6, 7}))
-    {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "default in initialization_list\n";
-    for (auto i : filter({-2, -1, 0, 0, 0, 1, 2})) {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "ever numbers in vector temporary\n";
-    for (auto i : filter([] (const int i) {return i % 2 == 0;},
-                         std::vector<int>{1, 2, 3, 4, 5, 6, 7}))
-    {
-        std::cout << i << '\n';
-    }
-
-    return 0;
-}
diff --git a/tests/testfilterfalse.cpp b/tests/testfilterfalse.cpp
deleted file mode 100644
index 9063d0bf..00000000
--- a/tests/testfilterfalse.cpp
+++ /dev/null
@@ -1,93 +0,0 @@
-#include <filterfalse.hpp>
-#include <range.hpp>    
-
-#include <vector>
-#include <iostream>
-
-using iter::filterfalse;
-using iter::range;
-
-bool greater_than_four(int i) {
-    return i > 4;
-}
-
-class LessThanValue {
-    private:
-        int compare_val;
-
-    public:
-        LessThanValue() = delete;
-        LessThanValue(int v) : compare_val(v) { }
-        
-        bool operator() (int i) const {
-            return i < this->compare_val;
-        }
-};
-
-
-int main() {
-    std::vector<int> vec{1, 5, 6, 7, 2, 3, 8, 3, 2, 1};
-
-    std::cout << "Greater than 4 (function pointer)\n";
-    for (auto i : filterfalse(greater_than_four, vec)) {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "Less than 4 (lambda)\n";
-    for (auto i : filterfalse([] (const int i) { return i < 4; }, vec)) {
-        std::cout << i << '\n';
-    }
-
-    LessThanValue lv(4);
-    std::cout << "Less than 4 (callable object)\n";
-    for (auto i : filterfalse(lv, vec)) {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "zero ints filter(vec2)\n";
-    std::vector<int> vec2 {0, 1, 2, 0, 3, 0, 0, 0, 4, 5, 0};
-    for (auto i : filterfalse(vec2)) {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "Constness tests\n";
-    const std::vector<int> cvec(vec);
-    for (auto i : filterfalse(greater_than_four, cvec)) {
-        std::cout << i << '\n';
-    }
-
-    for (auto i : filterfalse([] (const int & i) { return i < 4; }, cvec)) {
-        std::cout << i << '\n';
-    }
-
-
-    std::cout << "i%2 with range(10), should print even numbers\n";
-    for (auto i : filterfalse([] (const int i) { return i % 2; }, range(10))) {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "range(-1, 2)\n";
-    for (auto i : filterfalse(range(-1, 2))) {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "initializer_list\n";
-    for (auto i : filterfalse([] (const int i) { return  i % 2; },
-                {10, 11, 12, 13, 14, 15, 16}))
-    {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "initializer_list with default\n";
-    for (auto i : filterfalse({-1, -2, 0, 0, 0, 0, 1, 2, 3})) {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "vector temporary with default\n";
-    for (auto i : filterfalse(
-                std::vector<int>{-1, -2, 0, 0, 0, 0, 1, 2, 3})) {
-        std::cout << i << '\n';
-    }
-
-    return 0;
-}
diff --git a/tests/testgroupby.cpp b/tests/testgroupby.cpp
deleted file mode 100644
index 9fc03ee3..00000000
--- a/tests/testgroupby.cpp
+++ /dev/null
@@ -1,109 +0,0 @@
-#include <groupby.hpp>
-
-#include <vector>
-#include <iostream>
-#include <string>
-
-using iter::groupby;
-
-
-int length(std::string s)
-{
-    return s.length();
-}
-
-int main()
-{
-    std::vector<std::string> vec = {
-        "hi", "ab", "ho",
-        "abc", "def",
-        "abcde", "efghi"
-    };
-
-    for (auto gb : groupby(vec, &length)) {
-        std::cout << "key: " << gb.first << '\n';
-        std::cout << "content: ";
-        for (auto s : gb.second) {
-            std::cout << s << "  ";
-        }
-        std::cout << '\n';
-    }
-
-    for (auto gb : groupby(vec, [] (const std::string &s) {return s.length(); })) {
-        std::cout << "key: " << gb.first << '\n';
-        std::cout << "content: ";
-        for (auto s : gb.second) {
-            std::cout << s << "  ";
-        }
-        std::cout << '\n';
-    }
-
-    std::cout << "skipping length of 3\n";
-    for (auto gb : groupby(vec, &length)) {
-        if (gb.first == 3) {
-            continue;
-        }
-        std::cout << "key: " << gb.first << '\n';
-        std::cout << "content: ";
-        for (auto s : gb.second) {
-            std::cout << s << "  ";
-        }
-        std::cout << '\n';
-    }
-   
-
-    std::vector<int> ivec = {5, 5, 6, 6, 19, 19, 19, 19, 69, 0, 10, 10};
-    for (auto gb : groupby(ivec)) {
-        std::cout << "key: " << gb.first << '\n';
-        std::cout << "content: ";
-        for (auto s : gb.second) {
-            std::cout << s << "  ";
-        }
-        std::cout << '\n';
-    }
-
-    for (auto gb : groupby("aabbccccdd", [] (const char c) {return c < 'c';})){
-        std::cout << "key: " << gb.first << '\n';
-        std::cout << "content: ";
-        for (auto s : gb.second) {
-            std::cout << s << "  ";
-        }
-        std::cout << '\n';
-    }
-    
-    for (auto gb : groupby({'a', 'a', 'b', 'b', 'c'})) {
-        std::cout << "key: " << gb.first << '\n';
-        std::cout << "content: ";
-        for (auto s : gb.second) {
-            std::cout << s << "  ";
-        }
-        std::cout << '\n';
-    }
-
-    for (auto gb : groupby({'a', 'a', 'b', 'b', 'c', 'c', 'd', 'd'},
-                [] (const char c) {return c < 'c'; })) {
-        std::cout << "key: " << gb.first << '\n';
-        std::cout << "content: ";
-        for (auto s : gb.second) {
-            std::cout << s << "  ";
-        }
-        std::cout << '\n';
-    }
-
-    std::cout << "with vector temporary:\n";
-    for (auto gb : groupby(
-                std::vector<char>{'a', 'a', 'b', 'b', 'c', 'c', 'd', 'd'},
-                [] (const char c) {return c < 'c'; })) {
-        std::cout << "key: " << gb.first << '\n';
-        std::cout << "content: ";
-        for (auto s : gb.second) {
-            std::cout << s << "  ";
-        }
-        std::cout << '\n';
-    }
-        
-
-    return 0;
-}
-
-    
diff --git a/tests/testgrouper.cpp b/tests/testgrouper.cpp
deleted file mode 100644
index b16ebc98..00000000
--- a/tests/testgrouper.cpp
+++ /dev/null
@@ -1,51 +0,0 @@
-#include "grouper.hpp"
-#include <iostream>
-#include <vector>
-using iter::grouper;
-int main() {
-    std::vector<int> v {1,2,3,4,5,6,7,8,9}; 
-    for (auto sec : grouper(v,4)) {
-        for (auto i : sec) {
-            std::cout << i << " ";
-            i.get() *= 2;
-        }
-        std::cout << '\n';
-    }
-
-    for (auto sec : grouper(std::vector<int>{1,2,3,4,5,6,7,8,9}, 4)) {
-        for (auto i : sec) {
-            std::cout << i << " ";
-            i.get() *= 2;
-        }
-        std::cout << '\n';
-    }
-
-    for (auto sec : grouper(v,3)) {
-        for (auto i : sec) {
-            std::cout << i << " ";
-        }
-        std::cout << '\n';
-    }
-    std::vector<int> empty {};
-    for (auto sec : grouper(empty,3)) {
-        std::cout << "Shouldn't print\n";
-        for (auto i : sec) {
-            std::cout << i << " Shouldn't print\n";
-        }
-    }
-
-    int arr[] = {1,2,3,4,5,6,7};
-    for (auto sec : grouper(arr, 2)) {
-        for (auto i : sec) {
-            std::cout << i << ' ';
-        }
-        std::cout << '\n';
-    }
-
-    for (auto sec : grouper({1,2,3,4,5,6,7}, 2)) {
-        for (auto i : sec) {
-            std::cout << i << ' ';
-        }
-        std::cout << '\n';
-    }
-}
diff --git a/tests/testimap.cpp b/tests/testimap.cpp
deleted file mode 100644
index 3d6f38ca..00000000
--- a/tests/testimap.cpp
+++ /dev/null
@@ -1,45 +0,0 @@
-#include <imap.hpp>
-#include <range.hpp>
-
-#include <vector>
-#include <iostream>
-
-using iter::imap;
-
-int main() {
-    std::vector<int> vec1 = {1, 2, 3, 4, 5, 6};
-    std::vector<int> vec2 = {10, 20, 30, 40, 50, 60};
-    for (auto i : imap([] (int x, int y) { return x + y; }, vec1, vec2)) {
-        std::cout << i << '\n';
-    }
-
-    std::vector<int> vec3 = {100, 200, 300, 400, 500, 600};
-    for (auto i : imap([] (int a, int b, int c) { return a + b + c; }, 
-                vec1, vec2, vec3)) {
-        std::cout << i << '\n';
-    }
-
-    for (auto i : imap([] (int i) {return i * i; }, vec1)) {
-        std::cout << i << '\n';
-    }
-
-    std::vector<int> vec{1, 2, 3, 4, 5};
-    for (auto i : imap([] (int x) {return x * x;}, vec)) {
-        std::cout << i << '\n';
-    }
-
-    std::vector<int> vec4{1, 2, 3};
-    for (auto i : imap([] (int a, int b) { return a + b; }, vec, vec4)) {
-        std::cout << i << '\n';
-    }
-
-    for (auto i : imap([] (const int x) { return x*x; }, iter::range(10))) {
-        std::cout << i << '\n';
-    }
-
-    for (auto i : imap([] (const int x) { return x*x; },
-                       std::vector<int>{1,2,3,4,5})){
-        std::cout << i << '\n';
-    }
-    return 0;
-}
diff --git a/tests/testpermutations.cpp b/tests/testpermutations.cpp
deleted file mode 100644
index a73a2a3b..00000000
--- a/tests/testpermutations.cpp
+++ /dev/null
@@ -1,60 +0,0 @@
-#include "samples.hpp"
-
-#include <permutations.hpp>
-#include <range.hpp>
-
-#include <iostream>
-#include <vector>
-#include <string>
-
-int main() {
-    using iter::permutations;
-    std::vector<int> v = {1,2,3};
-    for (auto vec : permutations(v)) {
-        for (auto i : vec) {
-            std::cout << i << " ";
-        }
-        std::cout << std::endl;
-    }
-    //try with string
-    std::string s = "aba";
-    for (auto vec : permutations(s)) {
-        for (auto c : vec) {
-            std::cout << c << " ";
-        }
-        std::cout << std::endl;
-    }
-    s = "abc";
-    for (auto vec : permutations(s)) {
-        for (auto c : vec) {
-            std::cout << c << " ";
-        }
-        std::cout << std::endl;
-    }
-
-    std::cout << "init list\n";
-    //std::next_permutation doesn't work on initializer_lists
-    for (auto vec : permutations({1,2,3,4})) {
-        for (auto c : vec) {
-            std::cout << c << " ";
-        }
-        std::cout << std::endl;
-    }
-
-    std::cout << "with container of move-only objects\n";
-    std::vector<itertest::MoveOnly> mv;
-    for (auto i : iter::range(3)) {
-        mv.emplace_back(i);
-    }
-    for (auto v : permutations(mv)) {
-        for (auto i : v) std::cout << i << " ";
-        std::cout << std::endl;
-    }
-
-    std::cout << "with deref-by-value iterator\n";
-    itertest::DerefByValue dbv;
-    for (auto v : permutations(dbv)) {
-        for (auto i : v) std::cout << i << " ";
-        std::cout << std::endl;
-    }
-}
diff --git a/tests/testpowerset.cpp b/tests/testpowerset.cpp
deleted file mode 100644
index 20ca0098..00000000
--- a/tests/testpowerset.cpp
+++ /dev/null
@@ -1,44 +0,0 @@
-#include "samples.hpp"
-#include <powerset.hpp>
-#include <range.hpp>
-#include <vector>
-#include <iostream>
-
-using iter::powerset;
-
-int main() {
-    std::vector<int> vec {1,2,3,4,5,6,7,8,9};
-    for (auto v : powerset(vec)) {
-        for (auto i : v) std::cout << i << " ";
-        std::cout << std::endl;
-    }
-    std::cout << "with temporary\n";
-    for (auto v : powerset(std::vector<int>{1,2,3})) {
-        for (auto i : v) std::cout << i << " ";
-        std::cout << std::endl;
-    }
-    std::cout << "with initializer_list\n";
-    for (auto v : powerset({1,2,3})) {
-        for (auto i : v) std::cout << i << " ";
-        std::cout << std::endl;
-    }
-
-    std::cout << "with container of move-only objects\n";
-    std::vector<itertest::MoveOnly> mv;
-    for (auto i : iter::range(3)) {
-        mv.emplace_back(i);
-    }
-    for (auto v : powerset(mv)) {
-        for (auto i : v) std::cout << i << " ";
-        std::cout << std::endl;
-    }
-
-    std::cout << "with deref-by-value iterator\n";
-    itertest::DerefByValue dbv;
-    for (auto v : powerset(dbv)) {
-        for (auto i : v) std::cout << i << " ";
-        std::cout << std::endl;
-    }
-
-    return 0;
-}
diff --git a/tests/testproduct.cpp b/tests/testproduct.cpp
deleted file mode 100644
index 22d132ec..00000000
--- a/tests/testproduct.cpp
+++ /dev/null
@@ -1,77 +0,0 @@
-#include "samples.hpp"
-
-#include <product.hpp>
-#include <range.hpp>
-
-#include <vector>
-#include <iostream>
-#include <string>
-
-using iter::product;
-int main() {
-
-    std::vector<itertest::MoveOnly> mv;
-    for (auto i : iter::range(10)) {
-        mv.emplace_back(i);
-    }
-    std::vector<int> empty{};
-    std::vector<int> v1{1,2,3};
-    std::vector<int> v2{7,8};
-    std::vector<std::string> v3{"the","cat"};
-    std::vector<std::string> v4{"hi","what","up","dude"};
-
-    for (auto t : product(v1, mv)) {
-        std::cout << std::get<0>(t) << ", "
-            << std::get<1>(t) << std::endl;
-    }
-    for (auto t : product(empty,v1)) {
-        std::cout << std::get<0>(t) << ", "
-            << std::get<1>(t) << std::endl;
-    }
-    for (auto t : product(v1,empty)) {
-        std::cout << std::get<0>(t) << ", "
-            << std::get<1>(t) << std::endl;
-    }
-    std::cout<<std::endl;
-    for (auto t : product(v1,v2)) {
-        std::cout << std::get<0>(t) << ", "
-            << std::get<1>(t) << std::endl;
-    }
-    std::cout<<std::endl;
-    for (auto t : product(v1,v2,v3,v4)) {
-        std::cout << std::get<0>(t) << ", "
-            << std::get<1>(t) << ", "
-            << std::get<2>(t) << ", " 
-            << std::get<3>(t) << std::endl;
-    }
-    std::cout<<std::endl;
-    for (auto t : product(v1)) {
-        std::cout << std::get<0>(t)  << std::endl;
-    }
-    std::cout<<std::endl;
-    for (auto t : product(v1,v4)) {
-        std::cout << std::get<0>(t) << ", "
-          << std::get<1>(t)  << std::endl;
-    }
-    std::cout << '\n';
-
-    for (auto t : product()) { t=t; }
-
-    for (auto t : product(std::string{"hi"}, v1)) {
-        std::cout << std::get<0>(t) << ", "
-            << std::get<1>(t) << std::endl;
-    }
-    std::cout << '\n';
-
-    int arr[] = {1,2};
-    for (auto t : product(std::string{"hi"}, arr)) {
-        std::cout << std::get<0>(t) << ", "
-            << std::get<1>(t) << std::endl;
-    }
-    std::cout << '\n';
-    for (auto&& ij: iter::product(iter::range(10), iter::range(5))) {
-        std::cout << std::get<0>(ij) << "," << std::get<1>(ij) << std::endl;
-    }
-
-    return 0;
-}
diff --git a/tests/testrange.cpp b/tests/testrange.cpp
deleted file mode 100644
index 9404ae57..00000000
--- a/tests/testrange.cpp
+++ /dev/null
@@ -1,83 +0,0 @@
-#include <range.hpp>
-
-#include <iostream>
-
-using iter::range;
-
-int main()
-{
-    for (auto i : range(10)) {
-        std::cout << i << std::endl;
-    }
-    for (auto i : range(20, 30)) {
-        std::cout << i << std::endl;
-    }
-    for (auto i : range(50, 60, 2)) {
-        std::cout << i << std::endl;
-    }
-
-    std::cout << "Negative Tests\n";
-    for (auto i: range(-10, 0)) {
-        std::cout << i << std::endl;
-    }
-
-    for (auto i : range(-10, 10, 2)) {
-        std::cout << i << std::endl;
-    }
-
-    std::cout << "Tests where (stop - start)%step != 0" << std::endl;
-    for (auto i : range(1, 10, 2)) {
-        std::cout << i << std::endl;
-    }
-
-    for (auto i : range(-1, -10, -2)) {
-        std::cout << i << std::endl;
-    }
-    
-    std::cout << "Tests with different types" << std::endl;
-    for(auto i : range(5.0, 10.0, 0.5)) {
-        std::cout << i << std::endl;
-    }
-	std::cout << "test unsigned" << std::endl;
-	std::cout << "empty range: " << std::endl;
-	size_t len = 0;
-	for(auto i : range(len)){
-	  std::cout << i << std::endl;
-	}
-	std::cout << "stop only" << std::endl;
-	len = 3;
-	for(auto i : range(len)){
-	  std::cout << i << std::endl;
-	}
-	std::cout << "start stop" << std::endl;
-	size_t start = 1;
-	for(auto i : range(start, len)){
-	  std::cout << i << std::endl;
-	}
-
-	std::cout << "start stop skip" << std::endl;
-	len = 10;
-	size_t skip = 3;
-	for(auto i : range(start, len, skip)){
-	  std::cout << i << std::endl;
-	}
-	
-
-
-    // invalid ranges:
-    std::cout << "Should not print anything after this line until exception\n";
-    for (auto i : range(-10, 0, -1)) {
-        std::cout << i << std::endl;
-    }
-
-    for (auto i : range(0, 1, -1)) {
-        std::cout << i << std::endl;
-    }
-
-    std::cout << "Should see exception now\n";
-    for (auto i : range(0, 10, 0) ) {
-        std::cout << i << std::endl;
-    }
-
-    return 0;
-}
diff --git a/tests/testrepeat.cpp b/tests/testrepeat.cpp
deleted file mode 100644
index b91fba03..00000000
--- a/tests/testrepeat.cpp
+++ /dev/null
@@ -1,31 +0,0 @@
-#include "repeat.hpp"
-#include <iostream>
-#include <vector>
-#include <array>
-#include <string>
-#include <memory>
-
-int main () {
-    int a = 10;
-    int i = 0;
-    for (auto num : iter::repeat(a)) {//goes infintely
-        std::cout << num << std::endl;
-        ++i;
-        if (i > 20) break;
-    }
-    std::cout<<std::endl;
-    for (auto num : iter::repeat(a,10)) {//goes ten times
-        std::cout << num << std::endl;
-    }
-    
-    std::cout << "with temporary\n";
-    for (auto s : iter::repeat(std::string{"hey"}, 2)) {
-        std::cout <<  s << '\n';
-    }
-
-    std::cout << "with uptr temporary\n";
-    for (auto& p : iter::repeat(std::unique_ptr<int>{new int{2}}, 2)) {
-        std::cout << *p << '\n';
-    }
-
-}
diff --git a/tests/testreversed.cpp b/tests/testreversed.cpp
deleted file mode 100644
index c6d0ab46..00000000
--- a/tests/testreversed.cpp
+++ /dev/null
@@ -1,43 +0,0 @@
-#include <reversed.hpp>
-
-#include <iostream>
-#include <vector>
-#include <array>
-#include <string>
-
-int main () {
-    std::vector<int> a{1,2,3,4,5,6,7};
-    std::vector<std::string> b{"hey","how","are","you","doing"};
-    std::cout << std::endl << "reversed range test" << std::endl << std::endl;
-    for (auto i : iter::reversed(a)) {
-        std::cout << i << std::endl;
-    }
-    std::cout<<std::endl;
-    //modify a
-    for (auto & i : iter::reversed(a)) {
-        std::cout << i << std::endl;
-        i = 9;
-    }
-    std::cout<<std::endl;
-    for (auto i : iter::reversed(a)) {
-        std::cout << i << std::endl;
-    }
-    std::cout<<std::endl;
-    //try strings
-    for (auto s : iter::reversed(b)) {
-        std::cout << s << std::endl;
-    }
-
-    std::cout << "with temporary\n";
-    for (auto i : iter::reversed(std::vector<int>{1, 2, 3, 4, 5, 6, 7})) {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "statically sized array\n";
-    int arr[] = {1, 2, 3, 4, 5, 6, 7};
-    for (auto i : iter::reversed(arr)) {
-        std::cout << i << '\n';
-    }
-
-
-}
diff --git a/tests/testslice.cpp b/tests/testslice.cpp
deleted file mode 100644
index eaf8e1ce..00000000
--- a/tests/testslice.cpp
+++ /dev/null
@@ -1,81 +0,0 @@
-#include <iostream>
-
-#include <slice.hpp>
-#include <range.hpp>
-
-#include <vector>
-#include <array>
-
-int main() {
-    std::cout << std::endl << "Slice range test" << std::endl << std::endl;
-    std::vector<int> a{0,1,2,3,4,5,6,7,8,9,10,11,12,13};
-    std::vector<std::string> b{"hey","how","are","you","doing"};
-
-    std::cout << "step out of slice\n";
-    for (auto i : iter::slice(a, 1, 4, 5)) {
-        std::cout << i << '\n';
-    }
-    std::cout << "end step out\n";
-
-    for (auto i : iter::slice(a,2)) {
-        std::cout << i << std::endl;
-    }
-    std::cout<<std::endl;
-    for (auto & s : iter::slice(b,3,4)) {
-        std::cout << s << std::endl;
-        s = "test";
-    }
-    std::cout<<std::endl;
-    for (auto s : b) {
-        std::cout << s << std::endl;
-    }
-    std::cout<<std::endl;
-    for (auto i : iter::slice(a,0,15,3)) {
-        std::cout << i << std::endl;
-    }
-
-    std::cout<< "\n13 down to 0\n";
-    for (auto i : iter::slice(a,13,-1,-1)) {
-        std::cout << i << std::endl;
-    }
-
-    std::cout<< "\nunevent step [0:5:3]\n";
-    for (auto i : iter::slice(a, 0, 5, 3)) {
-        std::cout << i << '\n';
-    }
-
-    std::cout<< "\nInvalid range [1:10:-1]\n";
-    for (auto i : iter::slice(a,1,10,-1)) {
-        //invalid range returns two begin iters
-        std::cout << i << std::endl;
-    }
-    std::cout<< "\nOversize range [1:100:1]\n";
-    for (auto i : iter::slice(a,1,100,1)) {
-        //invalid range returns two begin iters
-        std::cout << i << std::endl;
-    }
-    std::cout<< "\nOversize range and undersize[1:100:1]\n";
-    for (auto i : iter::slice(a,-100,100,1)) {
-        //invalid range returns two begin iters
-        std::cout << i << std::endl;
-    }
-
-    std::cout<< "\nstatic array[1:8:2]\n";
-    int arr[10] = {0,1,2,3,4,5,6,7,8,9};
-    for (auto i : iter::slice(arr,1,8,2)) {
-        //invalid range returns two begin iters
-        std::cout << i << std::endl;
-    }
-
-    std::cout << "\ninitializer list\n";
-    for (auto i : iter::slice({1, 2, 4, 8, 16, 32, 64, 128}, 2, 6)) {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "\nvector temporary\n";
-    for (auto i : iter::slice(
-                std::vector<int>{1, 2, 4, 8, 16, 32, 64, 128}, 2, 6)) {
-        std::cout << i << '\n';
-    }
-
-}
diff --git a/tests/testsliding_window.cpp b/tests/testsliding_window.cpp
deleted file mode 100644
index 16708db7..00000000
--- a/tests/testsliding_window.cpp
+++ /dev/null
@@ -1,53 +0,0 @@
-#include "sliding_window.hpp"
-
-#include <iostream>
-#include <vector>
-
-using iter::sliding_window;
-
-int main() {
-    std::vector<int> v = {1,2,3,4,5,6,7,8,9}; 
-    for (auto sec : sliding_window(v,4)) {
-        for (auto i : sec) {
-            std::cout << i << " ";
-            i.get() = 90;
-        }
-        std::cout << std::endl;
-    }
-
-    std::cout << "with temporary\n";
-    for (auto sec : sliding_window(std::vector<int>{1,2,3,4,5,6,7,8,9}, 4)) {
-        for (auto i : sec) {
-            std::cout << i << " ";
-            i.get() = 90;
-        }
-        std::cout << std::endl;
-    }
-
-    std::cout << "with init list\n";
-    for (auto sec : sliding_window({1,2,3,4,5,6,7,8,9}, 4)) {
-        for (auto i : sec) {
-            std::cout << i << " ";
-        }
-        std::cout << std::endl;
-    }
-
-    std::cout << "with window_size > length\n";
-    for (auto sec : sliding_window({1,2,3}, 10)) {
-        for (auto i : sec) {
-            std::cout << i << " ";
-        }
-        std::cout << std::endl;
-    }
-
-    std::cout << "with static array\n";
-    int arr[] = {1,2,3,4,5,6,7,8,9};
-    for (auto sec : sliding_window(arr, 4)) {
-        for (auto i : sec) {
-            std::cout << i << " ";
-        }
-        std::cout << std::endl;
-    }
-
-    return 0;
-}
diff --git a/tests/testsorted.cpp b/tests/testsorted.cpp
deleted file mode 100644
index aed57d32..00000000
--- a/tests/testsorted.cpp
+++ /dev/null
@@ -1,36 +0,0 @@
-#include <sorted.hpp>
-
-#include <iostream>
-#include <vector>
-#include <string>
-
-using iter::sorted;
-
-int main()
-{
-    std::vector<int> vec = {19, 45, 32, 10, 0, 90, 15, 1, 7, 5, 6, 69};
-    for (auto i : sorted(vec)) {
-        std::cout << i << '\n';
-    }
-
-    const std::vector<int> cvec(vec);
-    for (auto i : sorted(cvec)) {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "Sort by first character only\n";
-    std::vector<std::string> svec = {"hello", "everyone", "thanks", "for",
-                                     "having", "me", "here", "today"};
-    for (auto s : sorted(svec,
-                [] (const std::string & s1, const std::string & s2) {
-                    return s1[0] < s2[0]; })) {
-        std::cout << s << '\n';
-    }
-        
-
-    for (auto i : sorted(
-                std::vector<int>{19, 45, 32, 10, 0, 90, 15, 1, 7, 5, 6, 69})) {
-        std::cout << i << '\n';
-    }
-    return 0;
-}
diff --git a/tests/teststarmap.cpp b/tests/teststarmap.cpp
deleted file mode 100644
index f85bd40d..00000000
--- a/tests/teststarmap.cpp
+++ /dev/null
@@ -1,83 +0,0 @@
-#include <starmap.hpp>
-
-#include <iostream>
-#include <sstream>
-#include <string>
-#include <utility>
-#include <tuple>
-#include <list>
-#include <vector>
-#include <array>
-
-using iter::starmap;
-
-double f(double d, int i) {
-    return d * i;
-}
-
-std::string g(const std::string& s, int i, double d) {
-    std::stringstream ss;
-    ss << s << ' ' << i << ' ' << d;
-    return ss.str();
-}
-
-void test_normal() {
-    std::cout << "vector<pair<double, int>>\n";
-    std::vector<std::pair<double, int>> v1 = {{1.0, 2}, {3.2, 42}, {6.9, 7}};
-    for (auto&& i : starmap(f, v1)) {
-        std::cout << i << '\n';
-    }
-    std::cout << '\n';
-
-    std::cout << "list<type<string, int, double>\n";
-    {
-        using T = std::tuple<std::string, int, double>;
-        std::list<T> li =
-            {T{"hey", 42, 6.9}, T{"there", 3, 4.0}, T{"yall", 5, 3.1}};
-        for (auto&& s : starmap(g, li)) {
-            std::cout << s << '\n';
-        }
-    }
-    std::cout << '\n';
-}
-
-struct Callable {
-    int operator()(int a, int b, int c) {
-        return a + b + c;
-    }
-
-    int operator()(int a) {
-        return a;
-    }
-};
-
-void test_tuple_of_tuples() {
-    auto tup = std::make_tuple(std::make_tuple(10, 19, 60),std::make_tuple(7));
-    Callable c;
-    std::cout << "tuple<tuple<int, int, int>, tuple<int>>\n";
-    for (auto&& i : starmap(c, tup)) {
-        std::cout << i << '\n';
-    }
-
-    auto tup2 = std::make_tuple(std::array<int, 3>{{15, 100, 2000}},
-                               std::make_tuple(16));
-    std::cout << "tuple<array<int>, tuple<int>>\n";
-    for (auto&& i : starmap(c, tup2)) {
-        std::cout << i << '\n';
-    }
-    std::cout << '\n';
-
-    std::cout << "pair<array<int>, tuple<int>>\n";
-    auto p = std::make_pair(std::array<int, 3>{{15, 100, 2000}},
-                            std::make_tuple(16));
-    for (auto&& i : starmap(c, p)) {
-        std::cout << i << '\n';
-    }
-    std::cout << '\n';
-}
-
-int main() {
-    test_normal();
-    test_tuple_of_tuples();
-
-}
diff --git a/tests/testtakewhile.cpp b/tests/testtakewhile.cpp
deleted file mode 100644
index bec3aeae..00000000
--- a/tests/testtakewhile.cpp
+++ /dev/null
@@ -1,32 +0,0 @@
-#include <takewhile.hpp>
-#include <range.hpp>
-
-#include <vector>
-#include <iostream>
-
-using iter::takewhile;
-using iter::range;
-
-int main() {
-    std::vector<int> ivec{1, 2, 3, 4, 5, 6, 7, 6, 5, 4, 3, 2, 1};
-    for (auto i : takewhile([] (int i) {return i < 5;}, ivec)) {
-        std::cout << i << '\n';
-    }
-
-    for (auto i : takewhile([] (int i) {return i < 5;}, range(10))) {
-        std::cout << i << '\n';
-    }
-
-    for (auto i : takewhile([] (int i) {return i < 5;}, 
-                {1, 2, 3, 4, 5, 6, 7, 8, 9})) {
-        std::cout << i << '\n';
-    }
-
-    std::cout << "with temporary\n";
-    for (auto i : takewhile([] (int i) {return i < 5;}, 
-                std::vector<int>{1, 2, 3, 4, 5, 6, 7, 8, 9})) {
-        std::cout << i << '\n';
-    }
-
-    return 0;
-}
diff --git a/tests/testunique_everseen.cpp b/tests/testunique_everseen.cpp
deleted file mode 100644
index 015adb7d..00000000
--- a/tests/testunique_everseen.cpp
+++ /dev/null
@@ -1,41 +0,0 @@
-
-#include <vector>
-#include <iostream>
-
-#include <unique_everseen.hpp>
-using iter::unique_everseen;
-
-int main() {
-    {
-        //should work same as justseen here
-        std::vector<int> v {1,1,1,2,2,3,4,4,5,6,7,8,8,8,8,9,9};
-        for (auto i : unique_everseen(v)) {
-            std::cout << i << " ";
-        }std::cout << std::endl;
-    }
-    {
-        std::vector<int> v {1,2,3,4,3,2,1,5,6,7,7,8,9,8,9,6};
-        for (auto i : unique_everseen(v)) {
-            std::cout << i << " ";
-        }std::cout << std::endl;
-    }
-
-    for (auto i : unique_everseen(
-                std::vector<int>{1,2,1,3,4,3,2,1,5,6,7,7,8,9,8,9,6})) {
-        std::cout << i << " ";
-    }
-    std::cout << std::endl;
-
-    int arr[] = {1,2,1,3,4,3,2,1,5,6,7,7,8,9,8,9,6};
-    for (auto i : unique_everseen(arr)) {
-        std::cout << i << ' ';
-    }
-    std::cout << '\n';
-
-    for (auto i : unique_everseen({1,2,1,3,4,3,2,1,5,6,7,7,8,9,8,9,6})) {
-        std::cout << i << ' ';
-    }
-    std::cout << '\n';
-
-    return 0;
-}
diff --git a/tests/testunique_justseen.cpp b/tests/testunique_justseen.cpp
deleted file mode 100644
index 8f454b6d..00000000
--- a/tests/testunique_justseen.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-
-#include <vector>
-#include <iostream>
-
-#include <unique_justseen.hpp>
-using iter::unique_justseen;
-
-int main() {
-    std::vector<int> v {1,1,1,2,2,4,4,5,6,7,8,8,8,8,9,9};
-    for (auto i : unique_justseen(v)) {
-        std::cout << i << " ";
-    }
-    std::cout << '\n';
-
-    std::cout << "with temporary\n";
-    for (auto i : unique_justseen(std::vector<int>{1,1,1,2,3,3})) {
-        std::cout << i << " ";
-    }
-    std::cout << '\n';
-
-    std::cout << "with init list\n";
-    for (auto i : unique_justseen({1,1,1,2,3,3})) {
-        std::cout << i << " ";
-    }
-    std::cout << '\n';
-
-    std::cout << "with static array\n";
-    int arr[] = {1, 1, 2, 3, 3, 3, 4};
-    for (auto i : unique_justseen(arr)) {
-        std::cout << i << " ";
-    }
-    std::cout << '\n';
-
-    return 0;
-}
diff --git a/tests/testzip.cpp b/tests/testzip.cpp
deleted file mode 100644
index 76a95fd7..00000000
--- a/tests/testzip.cpp
+++ /dev/null
@@ -1,118 +0,0 @@
-#include <zip.hpp>
-#include <chain.hpp>
-#include <range.hpp>
-
-#include <vector>
-#include <string>
-#include <iostream>
-#include <array>
-#include <cassert>
-
-using iter::zip;
-
-int main() {
-    //Ryan's test
-    {
-        for (auto t : zip()) { t=t; }
-
-        std::vector<int> ivec{1, 4, 9, 16, 25, 36};
-        std::vector<std::string> svec{"hello", "good day", "goodbye"};
-
-        constexpr int magic_value = 69;
-        for (auto e : zip(ivec, svec)) {
-            auto &i = std::get<0>(e);
-            std::cout << i << std::endl;
-            i = magic_value;
-            std::cout << std::get<1>(e) << std::endl;
-        }
-        assert(ivec.at(0) == magic_value);
-        for (auto e : zip(ivec, svec)) {
-            std::cout << std::get<0>(e) << std::endl;
-            std::cout << std::get<1>(e) << std::endl;
-        }
-
-        for (auto e : zip(std::vector<int>{5,6,7})) {
-            std::cout << std::get<0>(e) << std::endl;
-        }
-        for (auto e : zip(std::vector<int>{5,6,7}, std::array<int,2>{{1,2}})){
-            std::cout << std::get<0>(e) << std::endl;
-            std::cout << std::get<1>(e) << std::endl;
-        }
-
-        for (auto e : zip(iter::range(10), iter::range(10, 20))) {
-            std::cout << std::get<0>(e) << '\n';
-            std::cout << std::get<1>(e) << '\n';
-        }
-
-        int arr[] = {1,2,3,3,4};
-        for (auto e : zip(iter::range(10), arr)) {
-            std::cout << std::get<0>(e) << '\n';
-            std::cout << std::get<1>(e) << '\n';
-        }
-            
-    }
-    //Aaron's test
-    {
-        std::array<int,4> i{{1,2,3,4}};
-        std::vector<float> f{1.2,1.4,12.3,4.5,9.9};
-        std::vector<std::string> s{"i","like","apples","alot","dude"};
-        std::array<double,5> d{{1.2,1.2,1.2,1.2,1.2}};
-        std::cout << std::endl << "Variadic template zip iterator" << std::endl;
-        for (auto e : iter::zip(i,f,s,d)) {
-            std::cout << std::get<0>(e) << " " 
-                << std::get<1>(e) << " " 
-                << std::get<2>(e) << " "
-                << std::get<3>(e) << std::endl;
-            std::get<1>(e)=2.2f; //modify the float array
-        }
-        std::cout<<std::endl;
-        for (auto e : iter::zip(i,s,f,d)) {
-            std::cout << std::get<0>(e) << " " 
-                << std::get<1>(e) << " "
-                << std::get<2>(e) << " " 
-                << std::get<3>(e) << std::endl;
-        }
-        std::cout << std::endl << "Try some weird range differences" << std::endl;
-        std::vector<int> empty{};
-        for (auto e : iter::zip(empty,f,s,d)) {
-            std::cout << std::get<0>(e) << " " 
-                << std::get<1>(e) << " " 
-                << std::get<2>(e) << " "
-                << std::get<3>(e) << std::endl;
-        }
-        std::cout<<std::endl;
-        for (auto e : iter::zip(f,s,empty,d)) {
-            std::cout << std::get<0>(e) << " " 
-                << std::get<1>(e) << " " 
-                << std::get<2>(e) << " "
-                << std::get<3>(e) << std::endl;
-        }//both should print nothing
-        std::cout<<std::endl;
-        for (auto e : iter::zip(f,s,i,d)) { //i should be the limiter now
-            std::cout << std::get<0>(e) << " " 
-                << std::get<1>(e) << " " 
-                << std::get<2>(e) << " "
-                << std::get<3>(e) << std::endl;
-        }
-        std::cout<<std::endl;
-        const std::vector<double> constvector{1.1,2.2,3.3,4.4};
-        for (auto e : zip(
-                    iter::chain(std::vector<int>{5,6},
-                               std::array<int,2>{{1,2}}),
-                    std::initializer_list<const char *>{
-                         "asdfas","aaron","ryan","apple","juice"},
-                    std::initializer_list<int>{1, 2, 3, 4},
-                    constvector)) 
-        { 
-
-            std::cout << std::get<0>(e) << " " 
-                << std::get<1>(e) << " "
-                << std::get<2>(e)
-                << '\n';
-        }
-    }
-
-
-    return 0;
-}
-
diff --git a/tests/testzip_longest.cpp b/tests/testzip_longest.cpp
deleted file mode 100644
index 63dc8fd0..00000000
--- a/tests/testzip_longest.cpp
+++ /dev/null
@@ -1,96 +0,0 @@
-#include <zip_longest.hpp>
-
-#include <vector>
-#include <string>
-#include <iostream>
-#include <array>
-#include <boost/optional.hpp>
-
-using iter::zip_longest;
-
-template <typename T>
-std::ostream & operator<<(std::ostream & out, const boost::optional<T>& opt) {
-    if (opt) {
-        out << "Just " << *opt;
-    } else {
-        out << "Nothing";
-    }
-    return out;
-}
-
-int main() {
-    //Ryan's test
-    {
-        std::vector<int> ivec{1, 4, 9, 16, 25, 36};
-        std::vector<std::string> svec{"hello", "good day", "goodbye"};
-
-        for (auto e : zip_longest(ivec, svec)) {
-            std::cout << std::get<0>(e) << std::endl; 
-            std::cout << std::get<1>(e) << std::endl; 
-        }
-
-        for (auto e : zip_longest("helloworld",
-                    std::vector<int>{1,2,3})) {
-            std::cout << std::get<0>(e) << std::endl; 
-            std::cout << std::get<1>(e) << std::endl; 
-        }
-    }
-    //Aaron's test
-    {
-        std::array<int,4> i{{1,2,3,4}};
-        std::vector<float> f{1.2,1.4,12.3,4.5,9.9};
-        std::vector<std::string> s{"i","like","apples","alot","dude"};
-        std::array<double,5> d{{1.2,1.2,1.2,1.2,1.2}};
-        std::cout << std::endl << "Variadic template zip_longest" << std::endl;
-        for (auto e : iter::zip_longest(i,f,s,d)) {
-            std::cout << std::get<0>(e) << ' '
-                << std::get<1>(e) << ' '
-                << std::get<2>(e) << ' '
-                << std::get<3>(e) << std::endl;
-            *std::get<1>(e)=2.2f; //modify the float array
-        }
-        std::cout<<"modified array" <<std::endl;
-        for (auto e : iter::zip_longest(i,s,f,d)) {
-            std::cout << std::get<0>(e) << ' '
-                << std::get<1>(e) << ' '
-                << std::get<2>(e) << ' '
-                << std::get<3>(e) << std::endl;
-        }
-        std::cout << std::endl << "Try some weird range differences" << std::endl;
-        std::vector<int> empty{};
-        for (auto e : iter::zip_longest(empty,f,s,d)) {
-            std::cout << std::get<0>(e) << ' '
-                << std::get<1>(e) << ' '
-                << std::get<2>(e) << ' '
-                << std::get<3>(e) << std::endl;
-        }
-        std::cout<<std::endl;
-        for (auto e : iter::zip_longest(f,empty,s,d)) {
-            std::cout << std::get<0>(e) << ' '
-                << std::get<1>(e) << ' '
-                << std::get<2>(e) << ' '
-                << std::get<3>(e) << std::endl;
-        }
-        std::cout<<std::endl;
-        for (auto e : iter::zip_longest(f,s,i,d)) { 
-            std::cout << std::get<0>(e) << ' '
-                << std::get<1>(e) << ' '
-                << std::get<2>(e) << ' '
-                << std::get<3>(e) << std::endl;
-        }
-        std::cout<<std::endl;
-        for (auto e : iter::zip_longest(std::initializer_list<int>{1,2,3,4,5,6},
-                    std::initializer_list<double>{1.1,2.2,3.3,4.4},
-                    std::initializer_list<double>{1.1,2.2,3.3,4.4},
-                    std::array<int,3>{{1,2,3}})) { 
-            std::cout << std::get<0>(e) << ' '
-                << std::get<1>(e) << ' '
-                << std::get<2>(e) << ' '
-                << std::get<3>(e) << std::endl;
-        }
-        std::cout<<std::endl;
-
-    }
-    return 0;
-}
-

From 2386532de4fd245dc7b1912e4a583e7c20be547b Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Wed, 20 May 2015 00:52:44 -0700
Subject: [PATCH 1117/1866] moves test_starmap into test/

---
 {catchtest => test}/test_starmap.cpp | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename {catchtest => test}/test_starmap.cpp (100%)

diff --git a/catchtest/test_starmap.cpp b/test/test_starmap.cpp
similarity index 100%
rename from catchtest/test_starmap.cpp
rename to test/test_starmap.cpp

From d6a0b4911987db540942ee79fbf7daf15c211907 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Wed, 20 May 2015 01:17:06 -0700
Subject: [PATCH 1118/1866] adds starmap_examples.cpp file

---
 examples/starmap_examples.cpp | 40 +++++++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 examples/starmap_examples.cpp

diff --git a/examples/starmap_examples.cpp b/examples/starmap_examples.cpp
new file mode 100644
index 00000000..9797756c
--- /dev/null
+++ b/examples/starmap_examples.cpp
@@ -0,0 +1,40 @@
+#include <starmap.hpp>
+
+#include <array>
+#include <tuple>
+#include <vector>
+#include <iostream>
+
+// Since this is an example file I'm dumping a bunch of using declarations
+// here, in real code I use using declarations very sparingly
+using std::pair;
+using std::tuple;
+using std::vector;
+using std::make_pair;
+using std::make_tuple;
+
+struct Callable {
+    int operator()(int i) const { return i; }
+    int operator()(int i, char c) const { return i + c; }
+    int operator()(unsigned int u, int i, char c) const { return i + c + u; }
+};
+
+int main() {
+    // the function will be called with the tuple-like object unpacked
+    // using std::get.  This means an iterable of tuples, arrays, pairs, or
+    // whatever works with std::get
+    vector<pair<int, int>> v = {{2, 3}, {5, 2}, {3, 4}}; // {base, exponent}
+    for (auto&& i : iter::starmap([](int b, int e){ return b * e; }, v)) {
+        std::cout << i << '\n';
+    }
+
+    // Alternatively if an object has multiple call operators, a tuple-like
+    // object of tuple-like objects 
+    auto t = make_tuple(
+            make_tuple(5), // first form
+            make_pair(3, 'c'), // second form
+            make_tuple(1u, 1, '1')); // third form
+    for (auto&& i : iter::starmap(Callable{}, t)) {
+        std::cout << i << '\n';
+    }
+}

From e4e2d21bcad1d561d602af5612f6228ed89161f8 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Wed, 20 May 2015 01:17:58 -0700
Subject: [PATCH 1119/1866] builds starmap_examples

---
 examples/SConstruct | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/examples/SConstruct b/examples/SConstruct
index 41acb956..3a9bfbb4 100644
--- a/examples/SConstruct
+++ b/examples/SConstruct
@@ -4,7 +4,7 @@ env = Environment(
     ENV = {'PATH' : os.environ['PATH']},
     CXX='c++',
     CXXFLAGS= ['-g', '-Wall', '-Wextra',
-               '-pedantic', '-std=c++11',
+               '-pedantic', '-std=c++14',
                 '-fdiagnostics-color=always',
                '-I/usr/local/include'],
     CPPPATH='..',
@@ -34,6 +34,7 @@ progs = Split(
     slice
     sliding_window
     sorted
+    starmap
     takewhile
     unique_justseen
     unique_everseen

From 20058e13e34eb03afed590aab51b4bac54c57876 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining@google.com>
Date: Wed, 20 May 2015 10:21:15 -0700
Subject: [PATCH 1120/1866] only builds zip_longest and mixed when possible

when boost/optional is available
---
 examples/SConstruct | 5 +++--
 test/SConstruct     | 3 ++-
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/examples/SConstruct b/examples/SConstruct
index 41acb956..9710069b 100644
--- a/examples/SConstruct
+++ b/examples/SConstruct
@@ -38,10 +38,11 @@ progs = Split(
     unique_justseen
     unique_everseen
     zip
-    zip_longest
-    mixed
     ''')
 
+if Configure(env).CheckCXXHeader('boost/optional.hpp'):
+    progs.append('zip_longest')
+    progs.append('mixed')
 
 for p in progs:
     env.Program('{0}_examples.cpp'.format(p))
diff --git a/test/SConstruct b/test/SConstruct
index 615fb6d5..a9a54bce 100644
--- a/test/SConstruct
+++ b/test/SConstruct
@@ -42,13 +42,14 @@ progs = Split(
     unique_everseen
     unique_justseen
     zip
-    zip_longest
 
     iteratoriterator
     mixed
     helpers
     '''
 )
+if Configure(env).CheckCXXHeader('boost/optional.hpp'):
+    progs.append('zip_longest')
 
 test_sources = ['test_{}.cpp'.format(p) for p in progs]
 

From 99c9c40bcc8a89387b4834bffc6fae3940526192 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining@google.com>
Date: Wed, 20 May 2015 10:22:35 -0700
Subject: [PATCH 1121/1866] ignores scons temp and config files

---
 examples/.gitignore | 2 ++
 test/.gitignore     | 2 ++
 2 files changed, 4 insertions(+)

diff --git a/examples/.gitignore b/examples/.gitignore
index 61b23b0e..319fe583 100644
--- a/examples/.gitignore
+++ b/examples/.gitignore
@@ -2,3 +2,5 @@
 *.swp
 *_examples
 .sconsign.dblite
+config.log
+.sconf_temp/
diff --git a/test/.gitignore b/test/.gitignore
index c686c757..68c1db22 100644
--- a/test/.gitignore
+++ b/test/.gitignore
@@ -3,3 +3,5 @@
 test_*
 !test_*.cpp
 .sconsign.dblite
+config.log
+.sconf_temp/

From 8fa94f7452cd28adc0007886630b3eae8174dec4 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining@google.com>
Date: Wed, 20 May 2015 10:55:54 -0700
Subject: [PATCH 1122/1866] adds reverse iter aliases

---
 iterbase.hpp | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/iterbase.hpp b/iterbase.hpp
index 9f6177e4..5e66cd7f 100644
--- a/iterbase.hpp
+++ b/iterbase.hpp
@@ -44,7 +44,7 @@ namespace iter {
     // iterator_type<C> is the type of C's iterator
     template <typename Container>
     using reverse_iterator_type =
-        decltype(std::declval<Container&>().rbegin());
+        decltype(std::rbegin(std::declval<Container&>()));
 
     // iterator_deref<C> is the type obtained by dereferencing an iterator
     // to an object of type C
@@ -52,6 +52,10 @@ namespace iter {
     using reverse_iterator_deref =
         decltype(*std::declval<reverse_iterator_type<Container>&>());
 
+    template <typename Container>
+    using reverse_iterator_traits_deref =
+        std::remove_reference_t<reverse_iterator_deref<Container>>;
+
     template <typename, typename =void>
     struct is_random_access_iter : std::false_type { };
 

From 128806ee5a5d26ca94a5f0538afbaaded59bee65 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining@google.com>
Date: Wed, 20 May 2015 10:56:06 -0700
Subject: [PATCH 1123/1866] uses std::rbegin and rend, removes specialization

Instead of using .rbegin() and .rend(), uses non-member std::rbegin() and
std::rend() to get the iterators.  This also means (like replacing
.begin() with std::begin() forever ago) that Reverser can handle arrays.
This commit removes the array specialization.
---
 reversed.hpp | 83 +++++-----------------------------------------------
 1 file changed, 7 insertions(+), 76 deletions(-)

diff --git a/reversed.hpp b/reversed.hpp
index 0e03b6c1..8fdaa96e 100644
--- a/reversed.hpp
+++ b/reversed.hpp
@@ -13,13 +13,12 @@ namespace iter {
     template <typename Container>
     Reverser<Container> reversed(Container&&);
 
-
     template <typename Container>
     class Reverser {
         private:
             Container container;
             friend Reverser reversed<Container>(Container&&);
-            
+
             Reverser(Container&& in_container)
                 : container(std::forward<Container>(in_container))
             { }
@@ -27,20 +26,20 @@ namespace iter {
         public:
             class Iterator : public std::iterator<
                          std::input_iterator_tag,
-                         iterator_traits_deref<Container>>
+                         reverse_iterator_traits_deref<Container>>
             {
                 private:
                     reverse_iterator_type<Container> sub_iter;
                 public:
-                    Iterator (reverse_iterator_type<Container>&& iter)
+                    Iterator(reverse_iterator_type<Container>&& iter)
                         : sub_iter{std::move(iter)}
-                    { } 
+                    { }
 
                     reverse_iterator_deref<Container> operator*() {
                         return *this->sub_iter;
                     }
 
-                    Iterator& operator++() { 
+                    Iterator& operator++() {
                         ++this->sub_iter;
                         return *this;
                     }
@@ -61,11 +60,11 @@ namespace iter {
             };
 
             Iterator begin() {
-                return {this->container.rbegin()};
+                return {std::rbegin(this->container)};
             }
 
             Iterator end() {
-                return {this->container.rend()};
+                return {std::rend(this->container)};
             }
 
     };
@@ -74,74 +73,6 @@ namespace iter {
     Reverser<Container> reversed(Container&& container) {
         return {std::forward<Container>(container)};
     }
-
-    //
-    // specialization for statically allocated arrays
-    //
-    template <typename T, std::size_t N>
-    Reverser<T[N]> reversed(T (&)[N]);
-
-    template <typename T, std::size_t N>
-    class Reverser<T[N]> {
-        private:
-            T *array;
-            friend Reverser reversed<T, N>(T (&)[N]);
-            
-            // Value constructor for use only in the reversed function
-            Reverser(T *in_array)
-                : array{in_array}
-            { }
-
-        public:
-            Reverser(const Reverser&) = default;
-            class Iterator : public std::iterator<std::input_iterator_tag, T>
-            {
-                private:
-                    T *sub_iter;
-                public:
-                    Iterator (T *iter)
-                        : sub_iter{iter}
-                    { } 
-
-                    iterator_deref<T[N]> operator*() {
-                        return *(this->sub_iter - 1);
-                    }
-
-                    Iterator& operator++() { 
-                        --this->sub_iter;
-                        return *this;
-                    }
-
-                    Iterator operator++(int) {
-                        auto ret = *this;
-                        ++*this;
-                        return ret;
-                    }
-
-                    bool operator!=(const Iterator& other) const {
-                        return this->sub_iter != other.sub_iter;
-                    }
-
-                    bool operator==(const Iterator& other) const {
-                        return !(*this != other);
-                    }
-            };
-
-            Iterator begin() {
-                return {this->array + N};
-            }
-
-            Iterator end() {
-            return {this->array};
-            }
-
-    };
-
-    template <typename T, std::size_t N>
-    Reverser<T[N]> reversed(T (&array)[N]) {
-        return {array};
-    }
-
 }
 
 #endif

From 684dcf6c4c5fe9e3f8ab4ea7b626c256693f07c9 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining@google.com>
Date: Wed, 20 May 2015 11:10:42 -0700
Subject: [PATCH 1124/1866] moves reverse_iterator aliases into reversed.hpp

They're only used in reversed, they don't need to be in iterbase
---
 iterbase.hpp | 16 ----------------
 reversed.hpp | 17 +++++++++++++----
 2 files changed, 13 insertions(+), 20 deletions(-)

diff --git a/iterbase.hpp b/iterbase.hpp
index 5e66cd7f..7bf65d69 100644
--- a/iterbase.hpp
+++ b/iterbase.hpp
@@ -36,26 +36,10 @@ namespace iter {
     using const_iterator_deref =
         decltype(*std::declval<const iterator_type<Container>&>());
 
-
     template <typename Container>
     using iterator_traits_deref =
         std::remove_reference_t<iterator_deref<Container>>;
 
-    // iterator_type<C> is the type of C's iterator
-    template <typename Container>
-    using reverse_iterator_type =
-        decltype(std::rbegin(std::declval<Container&>()));
-
-    // iterator_deref<C> is the type obtained by dereferencing an iterator
-    // to an object of type C
-    template <typename Container>
-    using reverse_iterator_deref =
-        decltype(*std::declval<reverse_iterator_type<Container>&>());
-
-    template <typename Container>
-    using reverse_iterator_traits_deref =
-        std::remove_reference_t<reverse_iterator_deref<Container>>;
-
     template <typename, typename =void>
     struct is_random_access_iter : std::false_type { };
 
diff --git a/reversed.hpp b/reversed.hpp
index 8fdaa96e..e270c971 100644
--- a/reversed.hpp
+++ b/reversed.hpp
@@ -23,19 +23,28 @@ namespace iter {
                 : container(std::forward<Container>(in_container))
             { }
 
+            using reverse_iterator_type =
+                decltype(std::rbegin(std::declval<Container&>()));
+
+            using reverse_iterator_deref =
+                decltype(*std::declval<reverse_iterator_type&>());
+
+            using reverse_iterator_traits_deref =
+                std::remove_reference_t<reverse_iterator_deref>;
+
         public:
             class Iterator : public std::iterator<
                          std::input_iterator_tag,
-                         reverse_iterator_traits_deref<Container>>
+                         reverse_iterator_traits_deref>
             {
                 private:
-                    reverse_iterator_type<Container> sub_iter;
+                    reverse_iterator_type sub_iter;
                 public:
-                    Iterator(reverse_iterator_type<Container>&& iter)
+                    Iterator(reverse_iterator_type&& iter)
                         : sub_iter{std::move(iter)}
                     { }
 
-                    reverse_iterator_deref<Container> operator*() {
+                    reverse_iterator_deref operator*() {
                         return *this->sub_iter;
                     }
 

From b4cec8441bb74fe6aaad93db8d2a68a8a87244e3 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining@google.com>
Date: Wed, 20 May 2015 11:19:06 -0700
Subject: [PATCH 1125/1866] conditionally declares BasicIterable::rbegin

---
 test/helpers.hpp       | 18 +++++-------------
 test/test_reversed.cpp |  5 ++++-
 2 files changed, 9 insertions(+), 14 deletions(-)

diff --git a/test/helpers.hpp b/test/helpers.hpp
index 7c36ca89..c0db7fe7 100644
--- a/test/helpers.hpp
+++ b/test/helpers.hpp
@@ -110,19 +110,6 @@ class BasicIterable {
         BasicIterable& operator=(const BasicIterable&) = delete;
 
         BasicIterable(const BasicIterable&) = delete;
-#if 0
-        BasicIterable(const BasicIterable& other)
-            : data{new T[other.size()]},
-            size{other.size}
-        { 
-            for (auto it = this->begin(), o_it = other.begin();
-                    o_it != other.end();
-                    ++it, ++o_it) {
-                *it = *o_it;
-            }
-        }
-#endif
-
 
         BasicIterable(BasicIterable&& other)
             : data{other.data},
@@ -170,6 +157,11 @@ class BasicIterable {
         Iterator end() {
             return {this->data + this->size};
         }
+
+#ifdef DECLARE_REVERSE_ITERATOR
+        Iterator rbegin();
+        Iterator rend();
+#endif // ifdef DECLARE_REVERSE_ITERATOR
 };
 
 using iter::void_t;
diff --git a/test/test_reversed.cpp b/test/test_reversed.cpp
index 389badd0..6736b1a7 100644
--- a/test/test_reversed.cpp
+++ b/test/test_reversed.cpp
@@ -5,9 +5,12 @@
 #include <string>
 #include <utility>
 
-#include "helpers.hpp"
 #include "catch.hpp"
 
+#define DECLARE_REVERSE_ITERATOR
+#include "helpers.hpp"
+#undef DECLARE_REVERSE_ITERATOR
+
 using iter::reversed;
 using Vec = const std::vector<int>;
 

From d3eca914a1d41e2fcd9fdd3f90bdb389361fc80b Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining@google.com>
Date: Thu, 21 May 2015 15:23:52 -0700
Subject: [PATCH 1126/1866] general readme cleanup

---
 README.md | 218 ++++++++++++++++++++++++++----------------------------
 1 file changed, 106 insertions(+), 112 deletions(-)

diff --git a/README.md b/README.md
index 72e751bb..e8895623 100644
--- a/README.md
+++ b/README.md
@@ -101,7 +101,7 @@ appears as:
 
 ```c++
 vector<int> vec{2, 4, 6, 8};
-for (auto&& e : enumerate(vec)) { 
+for (auto&& e : enumerate(vec)) {
     cout << e.index
          << ": "
          << e.element
@@ -152,33 +152,32 @@ Prints only zero values.
 for(auto&& i : filterfalse(vec)) {
     cout << i << '\n';
 }
+
 ```
 unique_everseen
 ---------------
-This is a filter adaptor that only generates values that have never been seen 
-before. For this algo to work your object must be specialized for `std::hash`
-otherwise it will not be very efficient
+This is a filter adaptor that only generates values that have never been seen
+before. For this to work your object must be specialized for `std::hash`.
 
-Example Usage:
+Prints `1 2 3 4 5 6 7 8 9`
 ```c++
-std::vector<int> v {1,2,3,4,3,2,1,5,6,7,7,8,9,8,9,6};                      
-for (auto&& i : unique_everseen(v)) {                                        
-    std::cout << i << " ";                                                 
-}std::cout << std::endl; 
+vector<int> v {1,2,3,4,3,2,1,5,6,7,7,8,9,8,9,6};
+for (auto&& i : unique_everseen(v)) {
+    cout << i << ' ';
+}
 ```
 
 unique_justseen
 --------------
-Another filter adaptor that only prevents duplicates that are in a row, if the 
-sequence is sorted it will work exactly the same as `unique_justseen`, in that 
-case it will be better and more efficient to use.
+Another filter adaptor that only omits consecutive duplicates.
 
+Prints `1 2 3 4 3 2 1`
 Example Usage:
 ```c++
-std::vector<int> v {1,1,1,2,2,4,4,5,6,7,8,8,8,8,9,9};                          
-for (auto&& i : unique_justseen(v)) {                                            
-    std::cout << i << " ";                                                     
-}std::cout << std::endl; 
+vector<int> v {1,1,1,2,2,3,3,3,4,3,2,1,1,1};
+for (auto&& i : unique_justseen(v)) {
+    cout << i << ' ';
+}
 ```
 
 takewhile
@@ -196,7 +195,7 @@ for (auto&& i : takewhile([] (int i) {return i < 5;}, ivec)) {
 
 dropwhile
 ---------
-Yields all elements after and including the first element that is false under
+Yields all elements after and including the first element that is true under
 the predicate.
 
 Prints `5 6 7 1 2`
@@ -210,8 +209,8 @@ for (auto&& i : dropwhile([] (int i) {return i < 5;}, ivec)) {
 cycle
 -----
 
-Repeatedly produce all values of an iterable.  The loop will be infinite, so a
-`break` is necessary to exit.
+Repeatedly produces all values of an iterable.  The loop will be infinite, so a
+`break` or other control flow structure is necessary to exit.
 
 Prints `1 2 3` repeatedly until `some_condition` is true
 ```c++
@@ -236,6 +235,7 @@ for (auto&& e : repeat(1, 5)) {
     cout << e << '\n';
 }
 ```
+
 The below prints `2` forever
 ```c++
 for (auto&& e : repeat(2)) {
@@ -246,13 +246,13 @@ for (auto&& e : repeat(2)) {
 count
 -----
 Effectively a `range` without a stopping point.<br />
-`count()` with no arguments will start counting from 0 with a positive 
+`count()` with no arguments will start counting from 0 with a positive
 step of 1.<br />
 `count(i)` will start counting from `i` with a positive step of 1.<br />
 `count(i, st)` will start counting from `i` with a step of `st`.
 
 *Technical limitations*: Unlike Python which can use its long integer
-types when needed, count() will eventually exceed the 
+types when needed, count() will eventually exceed the
 maximum possible value for its type (or minimum with a negative step).
 When using a signed type it is up to the API user to ensure this does
 not happen.  If the limit is exceeded for signed types, the result is
@@ -287,12 +287,12 @@ for (auto&& gb : groupby(vec, [] (const string &s) {return s.length(); })) {
 ```
 *Note*: Just like Python's `itertools.groupby`, this doesn't do any sorting.
 It just iterates through, making a new group each time there is a key change.
-Thus, if the the group is unsorted, the same key may appear multiple times.
+Thus, if the group is unsorted, the same key may appear multiple times.
 
 accumulate
 -------
-Differs from `std::accumulate` (which in my humble opinion should be named 
-`std::reduce` or `std::foldl`).  It is similar to a functional reduce where one 
+Differs from `std::accumulate` (which in my humble opinion should be named
+`std::reduce` or `std::foldl`).  It is similar to a functional reduce where one
 can see all of the intermediate results.  By default, it keeps a running sum.
 Prints: `1 3 6 10 15`
 ```c++
@@ -300,7 +300,7 @@ for (auto&& i : accumulate(range(1, 6))) {
     cout << i << '\n';
 }
 ```
-A second, optional argument may provide an alternative binary function 
+A second, optional argument may provide an alternative binary function
 to compute results.  The following example multiplies the numbers, rather
 than adding them.
 Prints: `1 2 6 24 120`
@@ -316,32 +316,31 @@ and assignment.
 
 zip
 ---
-
-Takes an arbitrary number of ranges of different types and efficiently iterates over 
-them in parallel (so an iterator to each container is incremented simultaneously). 
-When you dereference an iterator to "zipped" range you get a tuple of whatever elements 
-the iterators were holding.
+Takes an arbitrary number of ranges of different types and efficiently iterates
+over them in parallel (so an iterator to each container is incremented
+simultaneously).  When you dereference an iterator to "zipped" range you get a
+tuple of the elements the iterators were holding. 
 
 Example usage:
 ```c++
-array<int,4> i{{1,2,3,4}};                                            
-vector<float> f{1.2,1.4,12.3,4.5,9.9};                                
-vector<string> s{"i","like","apples","alot","dude"};             
-array<double,5> d{{1.2,1.2,1.2,1.2,1.2}};                             
+array<int,4> i{{1,2,3,4}};
+vector<float> f{1.2,1.4,12.3,4.5,9.9};
+vector<string> s{"i","like","apples","alot","dude"};
+array<double,5> d{{1.2,1.2,1.2,1.2,1.2}};
 
-for (auto&& e : zip(i,f,s,d)) {                                        
-    cout << std::get<0>(e) << ' '                                
-         << std::get<1>(e) << ' '                                      
-         << std::get<2>(e) << ' '                                      
-         << std::get<3>(e) << '\n';                               
-    std::get<1>(e)=2.2f; // modify the float array                     
+for (auto&& e : zip(i,f,s,d)) {
+    cout << std::get<0>(e) << ' '
+         << std::get<1>(e) << ' '
+         << std::get<2>(e) << ' '
+         << std::get<3>(e) << '\n';
+    std::get<1>(e)=2.2f; // modifies the underlying 'f' array
 }
 ```
 
 zip_longest
 -----------
 Terminates on the longest sequence instead of the shortest.
-Repeatedly yields a tuple of `boost::optional<T>`s where `T` is the type 
+Repeatedly yields a tuple of `boost::optional<T>`s where `T` is the type
 yielded by the sequences' respective iterators.  Because of its boost
 dependency, `zip_longest` is not in `itertools.hpp` and must be included
 separately.
@@ -402,7 +401,7 @@ for (auto&& i : imap([] (int x, int y) { return x + y; }, vec1, vec2)) {
 }
 ```
 
-*Note*: The name `imap` is chosen to prevent confusion/collision with 
+*Note*: The name `imap` is chosen to prevent confusion/collision with
 `std::map`, and because it is more related to `itertools.imap` than
 the python builtin `map`.
 
@@ -427,7 +426,7 @@ sorted
 Allows iteration over a sequence in sorted order. `sorted` does
 **not** produce a new sequence, copy elements, or modify the original
 sequence.  It only provides a way to iterate over existing elements.
-`sorted` also takes an optional second 
+`sorted` also takes an optional second
 [comparator](http://en.cppreference.com/w/cpp/concept/Compare)
 argument.  If not provided, defaults to `std::less`. <br />
 Iterables passed to sorted are required to have an iterator with
@@ -449,12 +448,12 @@ This can chain any set of ranges together as long as their iterators
 dereference to the same type.
 
 ```c++
-vector<int> empty{};                                                 
-vector<int> vec1{1,2,3,4,5,6};                                       
-array<int,4> arr1{{7,8,9,10}};                                       
+vector<int> empty{};
+vector<int> vec1{1,2,3,4,5,6};
+array<int,4> arr1{{7,8,9,10}};
 
-for (auto&& i : chain(empty,vec1,arr1)) {                             
-    cout << i << '\n';                                          
+for (auto&& i : chain(empty,vec1,arr1)) {
+    cout << i << '\n';
 }
 ```
 
@@ -483,8 +482,8 @@ reversed
 Iterates over elements of a sequence in reverse order.
 
 ```c++
-for (auto&& i : reversed(a)) {                                          
-    cout << i << '\n';                                           
+for (auto&& i : reversed(a)) {
+    cout << i << '\n';
 }
 ```
 
@@ -504,74 +503,70 @@ for (auto&& i : slice(a,0,15,3)) {
 
 sliding_window
 -------------
-
-Takes a section from a range and increments the whole section.  
+Takes a section from a range and increments the whole section.
 
 Example:
-`[1, 2, 3, 4, 5, 6, 7, 8, 9]`  
+`[1, 2, 3, 4, 5, 6, 7, 8, 9]`
 
 take a section of size 4, output is:
 ```
-1 2 3 4 
-2 3 4 5 
-3 4 5 6 
-4 5 6 7 
-5 6 7 8 
-6 7 8 9 
+1 2 3 4
+2 3 4 5
+3 4 5 6
+4 5 6 7
+5 6 7 8
+6 7 8 9
 ```
 
 Example Usage:
 ```c++
-std::vector<int> v = {1,2,3,4,5,6,7,8,9};                                      
-for (auto&& sec : sliding_window(v,4)) {                                         
-    for (auto&& i : sec) {                                                       
-        std::cout << i << " ";                                                 
-        i.get() = 90; 
-        //has to be accessed with get if you want to store references
-        //because it is stored in a reference_wrapper (std::vector 
-        //cannot hold references)
-    }                                                                          
-    std::cout << std::endl;                                                    
-}
-```  
+vector<int> v = {1,2,3,4,5,6,7,8,9};
+for (auto&& sec : sliding_window(v,4)) {
+    for (auto&& i : sec) {
+        cout << i << ' ';
+        i.get() = 90;
+    }
+    cout << '\n';
+}
+```
 grouper
 ------
 
-grouper is very similar to sliding window, except instead of the 
+grouper is very similar to sliding window, except instead of the
 section sliding by only 1 it goes the length of the full section.
 
 Example usage:
 ```c++
-std::vector<int> v {1,2,3,4,5,6,7,8,9};                                        
-for (auto&& sec : grouper(v,4)) 
+vector<int> v {1,2,3,4,5,6,7,8,9};
+for (auto&& sec : grouper(v,4))
 //each section will have 4 elements
 //except the last one may be cut short
 {
-    for (auto&& i : sec) {                                                       
-        std::cout << i << " ";                                                 
-        i.get() *= 2;                                                          
-    }                                                                          
-    std::cout << std::endl;                                                    
-}  
+    for (auto&& i : sec) {
+        cout << i << " ";
+        i.get() *= 2;
+    }
+    cout << '\n';
+}
 ```
 
 product
 ------
 
-Generates the cartesian project of the given ranges put together  
+Generates the cartesian project of the given ranges put together
 
-Example usage: 
+Example usage:
 ```c++
-std::vector<int> v1{1,2,3};                                                    
-std::vector<int> v2{7,8};                                                      
-std::vector<std::string> v3{"the","cat"};                                      
-std::vector<std::string> v4{"hi","what","up","dude"}; 
-for (auto&& t : product(v1,v2,v3,v4)) {                                          
-    std::cout << std::get<0>(t) << ", "                                        
-        << std::get<1>(t) << ", "                                              
-        << std::get<2>(t) << ", "                                              
-        << std::get<3>(t) << std::endl;                                        
-} 
+vector<int> v1{1,2,3};
+vector<int> v2{7,8};
+vector<string> v3{"the","cat"};
+vector<string> v4{"hi","what","up","dude"};
+for (auto&& t : product(v1,v2,v3,v4)) {
+    cout << std::get<0>(t) << ", "
+        << std::get<1>(t) << ", "
+        << std::get<2>(t) << ", "
+        << std::get<3>(t) << '\n';
+}
 ```
 
 combinations
@@ -581,17 +576,16 @@ Generates n length unique sequences of the input range.
 
 Example usage:
 ```c++
-vector<int> v = {1,2,3,4,5};                                              
-for (auto&& i : combinations(v,3)) {                                             
-    //cout << i << std::endl;                                             
-    for (auto&& j : i ) cout << j << " ";                                   
-    cout << '\n';                                                      
+vector<int> v = {1,2,3,4,5};
+for (auto&& i : combinations(v,3)) {
+    for (auto&& j : i ) cout << j << " ";
+    cout << '\n';
 }
 ```
 
 combinations_with_replacement
 -----------------------------
-Like combinations, but with replacment of each element.  The
+Like combinations, but with replacement of each element.  The
 below is printed by the loop that follows:
 ```
 {A, A}
@@ -616,27 +610,27 @@ iterators of the sequence passed must have an `operator*() const`
 
 Example usage:
 ```c++
-std::vector<int> v = {1,2,3,4,5};                                              
-for (auto&& vec : permutations(v)) {                                             
-    for (auto&& i : vec) {                                                       
-        std::cout << i << " ";                                                 
-    }                                                                       
-    std::cout << std::endl;                                                 
-} 
+vector<int> v = {1,2,3,4,5};
+for (auto&& vec : permutations(v)) {
+    for (auto&& i : vec) {
+        cout << i << ' ';
+    }
+    cout << '\n';
+}
 ```
 
 powerset
 -------
 
-Generates every possible subset of a set, never run it since it runs in �(2^n).
+Generates every possible subset of a set, runs in O(2^n).
 
 Example usage:
 ```c++
-std::vector<int> vec {1,2,3,4,5,6,7,8,9};                                      
-for (auto&& v : powerset(vec)) {                                                 
-    for (auto&& i : v) std::cout << i << " ";                                    
-    std::cout << std::endl;                                                    
+vector<int> vec {1,2,3,4,5,6,7,8,9};
+for (auto&& v : powerset(vec)) {
+    for (auto&& i : v) {
+        cout << i << " ";
+    }
+    cout << '\n';
 }
 ```
-
-  

From 91201db3b6901ed75b1dc576cb05d4f7613615ed Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining@google.com>
Date: Thu, 21 May 2015 15:27:05 -0700
Subject: [PATCH 1127/1866] removes trailing space

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 0bb7e56a..48d9dcfc 100644
--- a/README.md
+++ b/README.md
@@ -368,7 +368,7 @@ zip
 Takes an arbitrary number of ranges of different types and efficiently iterates
 over them in parallel (so an iterator to each container is incremented
 simultaneously).  When you dereference an iterator to "zipped" range you get a
-tuple of the elements the iterators were holding. 
+tuple of the elements the iterators were holding.
 
 Example usage:
 ```c++

From 3ffaca0d09b5c46321a5e8f1ae397ef99ad27c22 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining@google.com>
Date: Thu, 21 May 2015 18:01:27 -0700
Subject: [PATCH 1128/1866] removes catch from repo, adds download script

scons will check to see if catch.hpp is available, and provide download
instructions if its not
./download_catch.sh
---
 test/SConstruct        |   15 +-
 test/catch.hpp         | 9406 ----------------------------------------
 test/download_catch.sh |    2 +
 3 files changed, 14 insertions(+), 9409 deletions(-)
 delete mode 100644 test/catch.hpp
 create mode 100755 test/download_catch.sh

diff --git a/test/SConstruct b/test/SConstruct
index a9a54bce..350942bb 100644
--- a/test/SConstruct
+++ b/test/SConstruct
@@ -6,7 +6,7 @@ env = Environment(
     CXXFLAGS= ['-g', '-Wall', '-Wextra',
                '-pedantic', '-std=c++11',
                 '-fdiagnostics-color=always',
-               '-I/usr/local/include'],
+               '-I/usr/local/include', '-I.'],
     CPPPATH='..',
     LINKFLAGS='-L/usr/local/lib')
 
@@ -48,13 +48,22 @@ progs = Split(
     helpers
     '''
 )
-if Configure(env).CheckCXXHeader('boost/optional.hpp'):
+
+conf = Configure(env)
+
+# if catch isn't available, exit
+if not conf.CheckCXXHeader('catch.hpp'):
+    print("WARNING: catch.hpp not found, run ./download_catch.sh first")
+    Exit(1)
+
+if conf.CheckCXXHeader('boost/optional.hpp'):
     progs.append('zip_longest')
 
+env = conf.Finish()
+
 test_sources = ['test_{}.cpp'.format(p) for p in progs]
 
 for test_src in test_sources:
     env.Program([test_src, 'test_main.cpp'])
 
 env.Program('test_all', ['test_main.cpp'] + test_sources)
-
diff --git a/test/catch.hpp b/test/catch.hpp
deleted file mode 100644
index c79324cf..00000000
--- a/test/catch.hpp
+++ /dev/null
@@ -1,9406 +0,0 @@
-/*
- *  CATCH v1.1 build 13 (develop branch)
- *  Generated: 2014-12-30 18:47:08.984634
- *  ----------------------------------------------------------
- *  This file has been merged from multiple headers. Please don't edit it directly
- *  Copyright (c) 2012 Two Blue Cubes Ltd. All rights reserved.
- *
- *  Distributed under the Boost Software License, Version 1.0. (See accompanying
- *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
- */
-#ifndef TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
-#define TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
-
-#define TWOBLUECUBES_CATCH_HPP_INCLUDED
-
-// #included from: internal/catch_suppress_warnings.h
-
-#define TWOBLUECUBES_CATCH_SUPPRESS_WARNINGS_H_INCLUDED
-
-#ifdef __clang__
-#pragma clang diagnostic ignored "-Wglobal-constructors"
-#pragma clang diagnostic ignored "-Wvariadic-macros"
-#pragma clang diagnostic ignored "-Wc99-extensions"
-#pragma clang diagnostic ignored "-Wunused-variable"
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wpadded"
-#pragma clang diagnostic ignored "-Wc++98-compat"
-#pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
-#elif defined __GNUC__
-#pragma GCC diagnostic ignored "-Wvariadic-macros"
-#pragma GCC diagnostic ignored "-Wunused-variable"
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wpadded"
-#endif
-
-#if defined(CATCH_CONFIG_MAIN) || defined(CATCH_CONFIG_RUNNER)
-#  define CATCH_IMPL
-#endif
-
-#ifdef CATCH_IMPL
-#  ifndef CLARA_CONFIG_MAIN
-#    define CLARA_CONFIG_MAIN_NOT_DEFINED
-#    define CLARA_CONFIG_MAIN
-#  endif
-#endif
-
-// #included from: internal/catch_notimplemented_exception.h
-#define TWOBLUECUBES_CATCH_NOTIMPLEMENTED_EXCEPTION_H_INCLUDED
-
-// #included from: catch_common.h
-#define TWOBLUECUBES_CATCH_COMMON_H_INCLUDED
-
-#define INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) name##line
-#define INTERNAL_CATCH_UNIQUE_NAME_LINE( name, line ) INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line )
-#define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __LINE__ )
-
-#define INTERNAL_CATCH_STRINGIFY2( expr ) #expr
-#define INTERNAL_CATCH_STRINGIFY( expr ) INTERNAL_CATCH_STRINGIFY2( expr )
-
-#include <sstream>
-#include <stdexcept>
-#include <algorithm>
-
-// #included from: catch_compiler_capabilities.h
-#define TWOBLUECUBES_CATCH_COMPILER_CAPABILITIES_HPP_INCLUDED
-
-// Much of the following code is based on Boost (1.53)
-
-#ifdef __clang__
-
-#  if __has_feature(cxx_nullptr)
-#    define CATCH_CONFIG_CPP11_NULLPTR
-#  endif
-
-#  if __has_feature(cxx_noexcept)
-#    define CATCH_CONFIG_CPP11_NOEXCEPT
-#  endif
-
-#endif // __clang__
-
-////////////////////////////////////////////////////////////////////////////////
-// Borland
-#ifdef __BORLANDC__
-
-#if (__BORLANDC__ > 0x582 )
-//#define CATCH_CONFIG_SFINAE // Not confirmed
-#endif
-
-#endif // __BORLANDC__
-
-////////////////////////////////////////////////////////////////////////////////
-// EDG
-#ifdef __EDG_VERSION__
-
-#if (__EDG_VERSION__ > 238 )
-//#define CATCH_CONFIG_SFINAE // Not confirmed
-#endif
-
-#endif // __EDG_VERSION__
-
-////////////////////////////////////////////////////////////////////////////////
-// Digital Mars
-#ifdef __DMC__
-
-#if (__DMC__ > 0x840 )
-//#define CATCH_CONFIG_SFINAE // Not confirmed
-#endif
-
-#endif // __DMC__
-
-////////////////////////////////////////////////////////////////////////////////
-// GCC
-#ifdef __GNUC__
-
-#if __GNUC__ < 3
-
-#if (__GNUC_MINOR__ >= 96 )
-//#define CATCH_CONFIG_SFINAE
-#endif
-
-#elif __GNUC__ >= 3
-
-// #define CATCH_CONFIG_SFINAE // Taking this out completely for now
-
-#endif // __GNUC__ < 3
-
-#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6 && defined(__GXX_EXPERIMENTAL_CXX0X__) )
-
-#define CATCH_CONFIG_CPP11_NULLPTR
-#endif
-
-#endif // __GNUC__
-
-////////////////////////////////////////////////////////////////////////////////
-// Visual C++
-#ifdef _MSC_VER
-
-#if (_MSC_VER >= 1600)
-#define CATCH_CONFIG_CPP11_NULLPTR
-#endif
-
-#if (_MSC_VER >= 1310 ) // (VC++ 7.0+)
-//#define CATCH_CONFIG_SFINAE // Not confirmed
-#endif
-
-#endif // _MSC_VER
-
-// Use variadic macros if the compiler supports them
-#if ( defined _MSC_VER && _MSC_VER > 1400 && !defined __EDGE__) || \
-    ( defined __WAVE__ && __WAVE_HAS_VARIADICS ) || \
-    ( defined __GNUC__ && __GNUC__ >= 3 ) || \
-    ( !defined __cplusplus && __STDC_VERSION__ >= 199901L || __cplusplus >= 201103L )
-
-#ifndef CATCH_CONFIG_NO_VARIADIC_MACROS
-#define CATCH_CONFIG_VARIADIC_MACROS
-#endif
-
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-// C++ language feature support
-
-// detect language version:
-#if (__cplusplus == 201103L)
-#  define CATCH_CPP11
-#  define CATCH_CPP11_OR_GREATER
-#elif (__cplusplus >= 201103L)
-#  define CATCH_CPP11_OR_GREATER
-#endif
-
-// noexcept support:
-#if defined(CATCH_CONFIG_CPP11_NOEXCEPT) && !defined(CATCH_NOEXCEPT)
-#  define CATCH_NOEXCEPT noexcept
-#  define CATCH_NOEXCEPT_IS(x) noexcept(x)
-#else
-#  define CATCH_NOEXCEPT throw()
-#  define CATCH_NOEXCEPT_IS(x)
-#endif
-
-namespace Catch {
-
-    class NonCopyable {
-#ifdef CATCH_CPP11_OR_GREATER
-        NonCopyable( NonCopyable const& )              = delete;
-        NonCopyable( NonCopyable && )                  = delete;
-        NonCopyable& operator = ( NonCopyable const& ) = delete;
-        NonCopyable& operator = ( NonCopyable && )     = delete;
-#else
-        NonCopyable( NonCopyable const& info );
-        NonCopyable& operator = ( NonCopyable const& );
-#endif
-
-    protected:
-        NonCopyable() {}
-        virtual ~NonCopyable();
-    };
-
-    class SafeBool {
-    public:
-        typedef void (SafeBool::*type)() const;
-
-        static type makeSafe( bool value ) {
-            return value ? &SafeBool::trueValue : 0;
-        }
-    private:
-        void trueValue() const {}
-    };
-
-    template<typename ContainerT>
-    inline void deleteAll( ContainerT& container ) {
-        typename ContainerT::const_iterator it = container.begin();
-        typename ContainerT::const_iterator itEnd = container.end();
-        for(; it != itEnd; ++it )
-            delete *it;
-    }
-    template<typename AssociativeContainerT>
-    inline void deleteAllValues( AssociativeContainerT& container ) {
-        typename AssociativeContainerT::const_iterator it = container.begin();
-        typename AssociativeContainerT::const_iterator itEnd = container.end();
-        for(; it != itEnd; ++it )
-            delete it->second;
-    }
-
-    bool startsWith( std::string const& s, std::string const& prefix );
-    bool endsWith( std::string const& s, std::string const& suffix );
-    bool contains( std::string const& s, std::string const& infix );
-    void toLowerInPlace( std::string& s );
-    std::string toLower( std::string const& s );
-    std::string trim( std::string const& str );
-    bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis );
-
-    struct pluralise {
-        pluralise( std::size_t count, std::string const& label );
-
-        friend std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser );
-
-        std::size_t m_count;
-        std::string m_label;
-    };
-
-    struct SourceLineInfo {
-
-        SourceLineInfo();
-        SourceLineInfo( char const* _file, std::size_t _line );
-        SourceLineInfo( SourceLineInfo const& other );
-#  ifdef CATCH_CPP11_OR_GREATER
-        SourceLineInfo( SourceLineInfo && )                  = default;
-        SourceLineInfo& operator = ( SourceLineInfo const& ) = default;
-        SourceLineInfo& operator = ( SourceLineInfo && )     = default;
-#  endif
-        bool empty() const;
-        bool operator == ( SourceLineInfo const& other ) const;
-
-        std::string file;
-        std::size_t line;
-    };
-
-    std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info );
-
-    // This is just here to avoid compiler warnings with macro constants and boolean literals
-    inline bool isTrue( bool value ){ return value; }
-    inline bool alwaysTrue() { return true; }
-    inline bool alwaysFalse() { return false; }
-
-    void throwLogicError( std::string const& message, SourceLineInfo const& locationInfo );
-
-    // Use this in variadic streaming macros to allow
-    //    >> +StreamEndStop
-    // as well as
-    //    >> stuff +StreamEndStop
-    struct StreamEndStop {
-        std::string operator+() {
-            return std::string();
-        }
-    };
-    template<typename T>
-    T const& operator + ( T const& value, StreamEndStop ) {
-        return value;
-    }
-}
-
-#define CATCH_INTERNAL_LINEINFO ::Catch::SourceLineInfo( __FILE__, static_cast<std::size_t>( __LINE__ ) )
-#define CATCH_INTERNAL_ERROR( msg ) ::Catch::throwLogicError( msg, CATCH_INTERNAL_LINEINFO );
-
-#include <ostream>
-
-namespace Catch {
-
-    class NotImplementedException : public std::exception
-    {
-    public:
-        NotImplementedException( SourceLineInfo const& lineInfo );
-        NotImplementedException( NotImplementedException const& ) {}
-
-        virtual ~NotImplementedException() CATCH_NOEXCEPT {}
-
-        virtual const char* what() const CATCH_NOEXCEPT;
-
-    private:
-        std::string m_what;
-        SourceLineInfo m_lineInfo;
-    };
-
-} // end namespace Catch
-
-///////////////////////////////////////////////////////////////////////////////
-#define CATCH_NOT_IMPLEMENTED throw Catch::NotImplementedException( CATCH_INTERNAL_LINEINFO )
-
-// #included from: internal/catch_context.h
-#define TWOBLUECUBES_CATCH_CONTEXT_H_INCLUDED
-
-// #included from: catch_interfaces_generators.h
-#define TWOBLUECUBES_CATCH_INTERFACES_GENERATORS_H_INCLUDED
-
-#include <string>
-
-namespace Catch {
-
-    struct IGeneratorInfo {
-        virtual ~IGeneratorInfo();
-        virtual bool moveNext() = 0;
-        virtual std::size_t getCurrentIndex() const = 0;
-    };
-
-    struct IGeneratorsForTest {
-        virtual ~IGeneratorsForTest();
-
-        virtual IGeneratorInfo& getGeneratorInfo( std::string const& fileInfo, std::size_t size ) = 0;
-        virtual bool moveNext() = 0;
-    };
-
-    IGeneratorsForTest* createGeneratorsForTest();
-
-} // end namespace Catch
-
-// #included from: catch_ptr.hpp
-#define TWOBLUECUBES_CATCH_PTR_HPP_INCLUDED
-
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wpadded"
-#endif
-
-namespace Catch {
-
-    // An intrusive reference counting smart pointer.
-    // T must implement addRef() and release() methods
-    // typically implementing the IShared interface
-    template<typename T>
-    class Ptr {
-    public:
-        Ptr() : m_p( NULL ){}
-        Ptr( T* p ) : m_p( p ){
-            if( m_p )
-                m_p->addRef();
-        }
-        Ptr( Ptr const& other ) : m_p( other.m_p ){
-            if( m_p )
-                m_p->addRef();
-        }
-        ~Ptr(){
-            if( m_p )
-                m_p->release();
-        }
-        void reset() {
-            if( m_p )
-                m_p->release();
-            m_p = NULL;
-        }
-        Ptr& operator = ( T* p ){
-            Ptr temp( p );
-            swap( temp );
-            return *this;
-        }
-        Ptr& operator = ( Ptr const& other ){
-            Ptr temp( other );
-            swap( temp );
-            return *this;
-        }
-        void swap( Ptr& other ) { std::swap( m_p, other.m_p ); }
-        T* get() { return m_p; }
-        const T* get() const{ return m_p; }
-        T& operator*() const { return *m_p; }
-        T* operator->() const { return m_p; }
-        bool operator !() const { return m_p == NULL; }
-        operator SafeBool::type() const { return SafeBool::makeSafe( m_p != NULL ); }
-
-    private:
-        T* m_p;
-    };
-
-    struct IShared : NonCopyable {
-        virtual ~IShared();
-        virtual void addRef() const = 0;
-        virtual void release() const = 0;
-    };
-
-    template<typename T = IShared>
-    struct SharedImpl : T {
-
-        SharedImpl() : m_rc( 0 ){}
-
-        virtual void addRef() const {
-            ++m_rc;
-        }
-        virtual void release() const {
-            if( --m_rc == 0 )
-                delete this;
-        }
-
-        mutable unsigned int m_rc;
-    };
-
-} // end namespace Catch
-
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-
-#include <memory>
-#include <vector>
-#include <stdlib.h>
-
-namespace Catch {
-
-    class TestCase;
-    class Stream;
-    struct IResultCapture;
-    struct IRunner;
-    struct IGeneratorsForTest;
-    struct IConfig;
-
-    struct IContext
-    {
-        virtual ~IContext();
-
-        virtual IResultCapture* getResultCapture() = 0;
-        virtual IRunner* getRunner() = 0;
-        virtual size_t getGeneratorIndex( std::string const& fileInfo, size_t totalSize ) = 0;
-        virtual bool advanceGeneratorsForCurrentTest() = 0;
-        virtual Ptr<IConfig const> getConfig() const = 0;
-    };
-
-    struct IMutableContext : IContext
-    {
-        virtual ~IMutableContext();
-        virtual void setResultCapture( IResultCapture* resultCapture ) = 0;
-        virtual void setRunner( IRunner* runner ) = 0;
-        virtual void setConfig( Ptr<IConfig const> const& config ) = 0;
-    };
-
-    IContext& getCurrentContext();
-    IMutableContext& getCurrentMutableContext();
-    void cleanUpContext();
-    Stream createStream( std::string const& streamName );
-
-}
-
-// #included from: internal/catch_test_registry.hpp
-#define TWOBLUECUBES_CATCH_TEST_REGISTRY_HPP_INCLUDED
-
-// #included from: catch_interfaces_testcase.h
-#define TWOBLUECUBES_CATCH_INTERFACES_TESTCASE_H_INCLUDED
-
-#include <vector>
-
-namespace Catch {
-
-    class TestSpec;
-
-    struct ITestCase : IShared {
-        virtual void invoke () const = 0;
-    protected:
-        virtual ~ITestCase();
-    };
-
-    class TestCase;
-    struct IConfig;
-
-    struct ITestCaseRegistry {
-        virtual ~ITestCaseRegistry();
-        virtual std::vector<TestCase> const& getAllTests() const = 0;
-        virtual void getFilteredTests( TestSpec const& testSpec, IConfig const& config, std::vector<TestCase>& matchingTestCases, bool negated = false ) const = 0;
-
-    };
-}
-
-namespace Catch {
-
-template<typename C>
-class MethodTestCase : public SharedImpl<ITestCase> {
-
-public:
-    MethodTestCase( void (C::*method)() ) : m_method( method ) {}
-
-    virtual void invoke() const {
-        C obj;
-        (obj.*m_method)();
-    }
-
-private:
-    virtual ~MethodTestCase() {}
-
-    void (C::*m_method)();
-};
-
-typedef void(*TestFunction)();
-
-struct NameAndDesc {
-    NameAndDesc( const char* _name = "", const char* _description= "" )
-    : name( _name ), description( _description )
-    {}
-
-    const char* name;
-    const char* description;
-};
-
-struct AutoReg {
-
-    AutoReg(    TestFunction function,
-                SourceLineInfo const& lineInfo,
-                NameAndDesc const& nameAndDesc );
-
-    template<typename C>
-    AutoReg(    void (C::*method)(),
-                char const* className,
-                NameAndDesc const& nameAndDesc,
-                SourceLineInfo const& lineInfo ) {
-        registerTestCase(   new MethodTestCase<C>( method ),
-                            className,
-                            nameAndDesc,
-                            lineInfo );
-    }
-
-    void registerTestCase(  ITestCase* testCase,
-                            char const* className,
-                            NameAndDesc const& nameAndDesc,
-                            SourceLineInfo const& lineInfo );
-
-    ~AutoReg();
-
-private:
-    AutoReg( AutoReg const& );
-    void operator= ( AutoReg const& );
-};
-
-} // end namespace Catch
-
-#ifdef CATCH_CONFIG_VARIADIC_MACROS
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_TESTCASE( ... ) \
-        static void INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ )(); \
-        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &INTERNAL_CATCH_UNIQUE_NAME(  ____C_A_T_C_H____T_E_S_T____ ), CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( __VA_ARGS__ ) ); }\
-        static void INTERNAL_CATCH_UNIQUE_NAME(  ____C_A_T_C_H____T_E_S_T____ )()
-
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, ... ) \
-        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &QualifiedMethod, "&" #QualifiedMethod, Catch::NameAndDesc( __VA_ARGS__ ), CATCH_INTERNAL_LINEINFO ); }
-
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, ... )\
-        namespace{ \
-            struct INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ) : ClassName{ \
-                void test(); \
-            }; \
-            Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( &INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ )::test, #ClassName, Catch::NameAndDesc( __VA_ARGS__ ), CATCH_INTERNAL_LINEINFO ); \
-        } \
-        void INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ )::test()
-
-#else
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_TESTCASE( Name, Desc ) \
-        static void INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ )(); \
-        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &INTERNAL_CATCH_UNIQUE_NAME(  ____C_A_T_C_H____T_E_S_T____ ), CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( Name, Desc ) ); }\
-        static void INTERNAL_CATCH_UNIQUE_NAME(  ____C_A_T_C_H____T_E_S_T____ )()
-
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, Name, Desc ) \
-        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &QualifiedMethod, "&" #QualifiedMethod, Catch::NameAndDesc( Name, Desc ), CATCH_INTERNAL_LINEINFO ); }
-
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, TestName, Desc )\
-        namespace{ \
-            struct INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ) : ClassName{ \
-                void test(); \
-            }; \
-            Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( &INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ )::test, #ClassName, Catch::NameAndDesc( TestName, Desc ), CATCH_INTERNAL_LINEINFO ); \
-        } \
-        void INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ )::test()
-
-#endif
-
-// #included from: internal/catch_capture.hpp
-#define TWOBLUECUBES_CATCH_CAPTURE_HPP_INCLUDED
-
-// #included from: catch_result_builder.h
-#define TWOBLUECUBES_CATCH_RESULT_BUILDER_H_INCLUDED
-
-// #included from: catch_result_type.h
-#define TWOBLUECUBES_CATCH_RESULT_TYPE_H_INCLUDED
-
-namespace Catch {
-
-    // ResultWas::OfType enum
-    struct ResultWas { enum OfType {
-        Unknown = -1,
-        Ok = 0,
-        Info = 1,
-        Warning = 2,
-
-        FailureBit = 0x10,
-
-        ExpressionFailed = FailureBit | 1,
-        ExplicitFailure = FailureBit | 2,
-
-        Exception = 0x100 | FailureBit,
-
-        ThrewException = Exception | 1,
-        DidntThrowException = Exception | 2,
-
-        FatalErrorCondition = 0x200 | FailureBit
-
-    }; };
-
-    inline bool isOk( ResultWas::OfType resultType ) {
-        return ( resultType & ResultWas::FailureBit ) == 0;
-    }
-    inline bool isJustInfo( int flags ) {
-        return flags == ResultWas::Info;
-    }
-
-    // ResultDisposition::Flags enum
-    struct ResultDisposition { enum Flags {
-        Normal = 0x00,
-
-        ContinueOnFailure = 0x01,   // Failures fail test, but execution continues
-        FalseTest = 0x02,           // Prefix expression with !
-        SuppressFail = 0x04         // Failures are reported but do not fail the test
-    }; };
-
-    inline ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs ) {
-        return static_cast<ResultDisposition::Flags>( static_cast<int>( lhs ) | static_cast<int>( rhs ) );
-    }
-
-    inline bool shouldContinueOnFailure( int flags )    { return ( flags & ResultDisposition::ContinueOnFailure ) != 0; }
-    inline bool isFalseTest( int flags )                { return ( flags & ResultDisposition::FalseTest ) != 0; }
-    inline bool shouldSuppressFailure( int flags )      { return ( flags & ResultDisposition::SuppressFail ) != 0; }
-
-} // end namespace Catch
-
-// #included from: catch_assertionresult.h
-#define TWOBLUECUBES_CATCH_ASSERTIONRESULT_H_INCLUDED
-
-#include <string>
-
-namespace Catch {
-
-    struct AssertionInfo
-    {
-        AssertionInfo() {}
-        AssertionInfo(  std::string const& _macroName,
-                        SourceLineInfo const& _lineInfo,
-                        std::string const& _capturedExpression,
-                        ResultDisposition::Flags _resultDisposition );
-
-        std::string macroName;
-        SourceLineInfo lineInfo;
-        std::string capturedExpression;
-        ResultDisposition::Flags resultDisposition;
-    };
-
-    struct AssertionResultData
-    {
-        AssertionResultData() : resultType( ResultWas::Unknown ) {}
-
-        std::string reconstructedExpression;
-        std::string message;
-        ResultWas::OfType resultType;
-    };
-
-    class AssertionResult {
-    public:
-        AssertionResult();
-        AssertionResult( AssertionInfo const& info, AssertionResultData const& data );
-        ~AssertionResult();
-#  ifdef CATCH_CPP11_OR_GREATER
-         AssertionResult( AssertionResult const& )              = default;
-         AssertionResult( AssertionResult && )                  = default;
-         AssertionResult& operator = ( AssertionResult const& ) = default;
-         AssertionResult& operator = ( AssertionResult && )     = default;
-#  endif
-
-        bool isOk() const;
-        bool succeeded() const;
-        ResultWas::OfType getResultType() const;
-        bool hasExpression() const;
-        bool hasMessage() const;
-        std::string getExpression() const;
-        std::string getExpressionInMacro() const;
-        bool hasExpandedExpression() const;
-        std::string getExpandedExpression() const;
-        std::string getMessage() const;
-        SourceLineInfo getSourceInfo() const;
-        std::string getTestMacroName() const;
-
-    protected:
-        AssertionInfo m_info;
-        AssertionResultData m_resultData;
-    };
-
-} // end namespace Catch
-
-namespace Catch {
-
-    struct TestFailureException{};
-
-    template<typename T> class ExpressionLhs;
-
-    struct STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison;
-
-    struct CopyableStream {
-        CopyableStream() {}
-        CopyableStream( CopyableStream const& other ) {
-            oss << other.oss.str();
-        }
-        CopyableStream& operator=( CopyableStream const& other ) {
-            oss.str("");
-            oss << other.oss.str();
-            return *this;
-        }
-        std::ostringstream oss;
-    };
-
-    class ResultBuilder {
-    public:
-        ResultBuilder(  char const* macroName,
-                        SourceLineInfo const& lineInfo,
-                        char const* capturedExpression,
-                        ResultDisposition::Flags resultDisposition );
-
-        template<typename T>
-        ExpressionLhs<T const&> operator->* ( T const& operand );
-        ExpressionLhs<bool> operator->* ( bool value );
-
-        template<typename T>
-        ResultBuilder& operator << ( T const& value ) {
-            m_stream.oss << value;
-            return *this;
-        }
-
-        template<typename RhsT> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator && ( RhsT const& );
-        template<typename RhsT> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator || ( RhsT const& );
-
-        ResultBuilder& setResultType( ResultWas::OfType result );
-        ResultBuilder& setResultType( bool result );
-        ResultBuilder& setLhs( std::string const& lhs );
-        ResultBuilder& setRhs( std::string const& rhs );
-        ResultBuilder& setOp( std::string const& op );
-
-        void endExpression();
-
-        std::string reconstructExpression() const;
-        AssertionResult build() const;
-
-        void useActiveException( ResultDisposition::Flags resultDisposition = ResultDisposition::Normal );
-        void captureResult( ResultWas::OfType resultType );
-        void captureExpression();
-        void react();
-        bool shouldDebugBreak() const;
-        bool allowThrows() const;
-
-    private:
-        AssertionInfo m_assertionInfo;
-        AssertionResultData m_data;
-        struct ExprComponents {
-            ExprComponents() : testFalse( false ) {}
-            bool testFalse;
-            std::string lhs, rhs, op;
-        } m_exprComponents;
-        CopyableStream m_stream;
-
-        bool m_shouldDebugBreak;
-        bool m_shouldThrow;
-    };
-
-} // namespace Catch
-
-// Include after due to circular dependency:
-// #included from: catch_expression_lhs.hpp
-#define TWOBLUECUBES_CATCH_EXPRESSION_LHS_HPP_INCLUDED
-
-// #included from: catch_evaluate.hpp
-#define TWOBLUECUBES_CATCH_EVALUATE_HPP_INCLUDED
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable:4389) // '==' : signed/unsigned mismatch
-#endif
-
-#include <cstddef>
-
-namespace Catch {
-namespace Internal {
-
-    enum Operator {
-        IsEqualTo,
-        IsNotEqualTo,
-        IsLessThan,
-        IsGreaterThan,
-        IsLessThanOrEqualTo,
-        IsGreaterThanOrEqualTo
-    };
-
-    template<Operator Op> struct OperatorTraits             { static const char* getName(){ return "*error*"; } };
-    template<> struct OperatorTraits<IsEqualTo>             { static const char* getName(){ return "=="; } };
-    template<> struct OperatorTraits<IsNotEqualTo>          { static const char* getName(){ return "!="; } };
-    template<> struct OperatorTraits<IsLessThan>            { static const char* getName(){ return "<"; } };
-    template<> struct OperatorTraits<IsGreaterThan>         { static const char* getName(){ return ">"; } };
-    template<> struct OperatorTraits<IsLessThanOrEqualTo>   { static const char* getName(){ return "<="; } };
-    template<> struct OperatorTraits<IsGreaterThanOrEqualTo>{ static const char* getName(){ return ">="; } };
-
-    template<typename T>
-    inline T& opCast(T const& t) { return const_cast<T&>(t); }
-
-// nullptr_t support based on pull request #154 from Konstantin Baumann
-#ifdef CATCH_CONFIG_CPP11_NULLPTR
-    inline std::nullptr_t opCast(std::nullptr_t) { return nullptr; }
-#endif // CATCH_CONFIG_CPP11_NULLPTR
-
-    // So the compare overloads can be operator agnostic we convey the operator as a template
-    // enum, which is used to specialise an Evaluator for doing the comparison.
-    template<typename T1, typename T2, Operator Op>
-    class Evaluator{};
-
-    template<typename T1, typename T2>
-    struct Evaluator<T1, T2, IsEqualTo> {
-        static bool evaluate( T1 const& lhs, T2 const& rhs) {
-            return opCast( lhs ) ==  opCast( rhs );
-        }
-    };
-    template<typename T1, typename T2>
-    struct Evaluator<T1, T2, IsNotEqualTo> {
-        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
-            return opCast( lhs ) != opCast( rhs );
-        }
-    };
-    template<typename T1, typename T2>
-    struct Evaluator<T1, T2, IsLessThan> {
-        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
-            return opCast( lhs ) < opCast( rhs );
-        }
-    };
-    template<typename T1, typename T2>
-    struct Evaluator<T1, T2, IsGreaterThan> {
-        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
-            return opCast( lhs ) > opCast( rhs );
-        }
-    };
-    template<typename T1, typename T2>
-    struct Evaluator<T1, T2, IsGreaterThanOrEqualTo> {
-        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
-            return opCast( lhs ) >= opCast( rhs );
-        }
-    };
-    template<typename T1, typename T2>
-    struct Evaluator<T1, T2, IsLessThanOrEqualTo> {
-        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
-            return opCast( lhs ) <= opCast( rhs );
-        }
-    };
-
-    template<Operator Op, typename T1, typename T2>
-    bool applyEvaluator( T1 const& lhs, T2 const& rhs ) {
-        return Evaluator<T1, T2, Op>::evaluate( lhs, rhs );
-    }
-
-    // This level of indirection allows us to specialise for integer types
-    // to avoid signed/ unsigned warnings
-
-    // "base" overload
-    template<Operator Op, typename T1, typename T2>
-    bool compare( T1 const& lhs, T2 const& rhs ) {
-        return Evaluator<T1, T2, Op>::evaluate( lhs, rhs );
-    }
-
-    // unsigned X to int
-    template<Operator Op> bool compare( unsigned int lhs, int rhs ) {
-        return applyEvaluator<Op>( lhs, static_cast<unsigned int>( rhs ) );
-    }
-    template<Operator Op> bool compare( unsigned long lhs, int rhs ) {
-        return applyEvaluator<Op>( lhs, static_cast<unsigned int>( rhs ) );
-    }
-    template<Operator Op> bool compare( unsigned char lhs, int rhs ) {
-        return applyEvaluator<Op>( lhs, static_cast<unsigned int>( rhs ) );
-    }
-
-    // unsigned X to long
-    template<Operator Op> bool compare( unsigned int lhs, long rhs ) {
-        return applyEvaluator<Op>( lhs, static_cast<unsigned long>( rhs ) );
-    }
-    template<Operator Op> bool compare( unsigned long lhs, long rhs ) {
-        return applyEvaluator<Op>( lhs, static_cast<unsigned long>( rhs ) );
-    }
-    template<Operator Op> bool compare( unsigned char lhs, long rhs ) {
-        return applyEvaluator<Op>( lhs, static_cast<unsigned long>( rhs ) );
-    }
-
-    // int to unsigned X
-    template<Operator Op> bool compare( int lhs, unsigned int rhs ) {
-        return applyEvaluator<Op>( static_cast<unsigned int>( lhs ), rhs );
-    }
-    template<Operator Op> bool compare( int lhs, unsigned long rhs ) {
-        return applyEvaluator<Op>( static_cast<unsigned int>( lhs ), rhs );
-    }
-    template<Operator Op> bool compare( int lhs, unsigned char rhs ) {
-        return applyEvaluator<Op>( static_cast<unsigned int>( lhs ), rhs );
-    }
-
-    // long to unsigned X
-    template<Operator Op> bool compare( long lhs, unsigned int rhs ) {
-        return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
-    }
-    template<Operator Op> bool compare( long lhs, unsigned long rhs ) {
-        return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
-    }
-    template<Operator Op> bool compare( long lhs, unsigned char rhs ) {
-        return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
-    }
-
-    // pointer to long (when comparing against NULL)
-    template<Operator Op, typename T> bool compare( long lhs, T* rhs ) {
-        return Evaluator<T*, T*, Op>::evaluate( reinterpret_cast<T*>( lhs ), rhs );
-    }
-    template<Operator Op, typename T> bool compare( T* lhs, long rhs ) {
-        return Evaluator<T*, T*, Op>::evaluate( lhs, reinterpret_cast<T*>( rhs ) );
-    }
-
-    // pointer to int (when comparing against NULL)
-    template<Operator Op, typename T> bool compare( int lhs, T* rhs ) {
-        return Evaluator<T*, T*, Op>::evaluate( reinterpret_cast<T*>( lhs ), rhs );
-    }
-    template<Operator Op, typename T> bool compare( T* lhs, int rhs ) {
-        return Evaluator<T*, T*, Op>::evaluate( lhs, reinterpret_cast<T*>( rhs ) );
-    }
-
-#ifdef CATCH_CONFIG_CPP11_NULLPTR
-    // pointer to nullptr_t (when comparing against nullptr)
-    template<Operator Op, typename T> bool compare( std::nullptr_t, T* rhs ) {
-        return Evaluator<T*, T*, Op>::evaluate( NULL, rhs );
-    }
-    template<Operator Op, typename T> bool compare( T* lhs, std::nullptr_t ) {
-        return Evaluator<T*, T*, Op>::evaluate( lhs, NULL );
-    }
-#endif // CATCH_CONFIG_CPP11_NULLPTR
-
-} // end of namespace Internal
-} // end of namespace Catch
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-// #included from: catch_tostring.h
-#define TWOBLUECUBES_CATCH_TOSTRING_H_INCLUDED
-
-// #included from: catch_sfinae.hpp
-#define TWOBLUECUBES_CATCH_SFINAE_HPP_INCLUDED
-
-// Try to detect if the current compiler supports SFINAE
-
-namespace Catch {
-
-    struct TrueType {
-        static const bool value = true;
-        typedef void Enable;
-        char sizer[1];
-    };
-    struct FalseType {
-        static const bool value = false;
-        typedef void Disable;
-        char sizer[2];
-    };
-
-#ifdef CATCH_CONFIG_SFINAE
-
-    template<bool> struct NotABooleanExpression;
-
-    template<bool c> struct If : NotABooleanExpression<c> {};
-    template<> struct If<true> : TrueType {};
-    template<> struct If<false> : FalseType {};
-
-    template<int size> struct SizedIf;
-    template<> struct SizedIf<sizeof(TrueType)> : TrueType {};
-    template<> struct SizedIf<sizeof(FalseType)> : FalseType {};
-
-#endif // CATCH_CONFIG_SFINAE
-
-} // end namespace Catch
-
-#include <sstream>
-#include <iomanip>
-#include <limits>
-#include <vector>
-#include <cstddef>
-
-#ifdef __OBJC__
-// #included from: catch_objc_arc.hpp
-#define TWOBLUECUBES_CATCH_OBJC_ARC_HPP_INCLUDED
-
-#import <Foundation/Foundation.h>
-
-#ifdef __has_feature
-#define CATCH_ARC_ENABLED __has_feature(objc_arc)
-#else
-#define CATCH_ARC_ENABLED 0
-#endif
-
-void arcSafeRelease( NSObject* obj );
-id performOptionalSelector( id obj, SEL sel );
-
-#if !CATCH_ARC_ENABLED
-inline void arcSafeRelease( NSObject* obj ) {
-    [obj release];
-}
-inline id performOptionalSelector( id obj, SEL sel ) {
-    if( [obj respondsToSelector: sel] )
-        return [obj performSelector: sel];
-    return nil;
-}
-#define CATCH_UNSAFE_UNRETAINED
-#define CATCH_ARC_STRONG
-#else
-inline void arcSafeRelease( NSObject* ){}
-inline id performOptionalSelector( id obj, SEL sel ) {
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
-#endif
-    if( [obj respondsToSelector: sel] )
-        return [obj performSelector: sel];
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-    return nil;
-}
-#define CATCH_UNSAFE_UNRETAINED __unsafe_unretained
-#define CATCH_ARC_STRONG __strong
-#endif
-
-#endif
-
-#ifdef CATCH_CPP11_OR_GREATER
-#include <tuple>
-#include <type_traits>
-#endif
-
-namespace Catch {
-
-// Why we're here.
-template<typename T>
-std::string toString( T const& value );
-
-// Built in overloads
-
-std::string toString( std::string const& value );
-std::string toString( std::wstring const& value );
-std::string toString( const char* const value );
-std::string toString( char* const value );
-std::string toString( const wchar_t* const value );
-std::string toString( wchar_t* const value );
-std::string toString( int value );
-std::string toString( unsigned long value );
-std::string toString( unsigned int value );
-std::string toString( const double value );
-std::string toString( const float value );
-std::string toString( bool value );
-std::string toString( char value );
-std::string toString( signed char value );
-std::string toString( unsigned char value );
-
-#ifdef CATCH_CONFIG_CPP11_NULLPTR
-std::string toString( std::nullptr_t );
-#endif
-
-#ifdef __OBJC__
-    std::string toString( NSString const * const& nsstring );
-    std::string toString( NSString * CATCH_ARC_STRONG const& nsstring );
-    std::string toString( NSObject* const& nsObject );
-#endif
-
-namespace Detail {
-
-    extern std::string unprintableString;
-
-// SFINAE is currently disabled by default for all compilers.
-// If the non SFINAE version of IsStreamInsertable is ambiguous for you
-// and your compiler supports SFINAE, try #defining CATCH_CONFIG_SFINAE
-#ifdef CATCH_CONFIG_SFINAE
-
-    template<typename T>
-    class IsStreamInsertableHelper {
-        template<int N> struct TrueIfSizeable : TrueType {};
-
-        template<typename T2>
-        static TrueIfSizeable<sizeof((*(std::ostream*)0) << *((T2 const*)0))> dummy(T2*);
-        static FalseType dummy(...);
-
-    public:
-        typedef SizedIf<sizeof(dummy((T*)0))> type;
-    };
-
-    template<typename T>
-    struct IsStreamInsertable : IsStreamInsertableHelper<T>::type {};
-
-#else
-
-    struct BorgType {
-        template<typename T> BorgType( T const& );
-    };
-
-    TrueType& testStreamable( std::ostream& );
-    FalseType testStreamable( FalseType );
-
-    FalseType operator<<( std::ostream const&, BorgType const& );
-
-    template<typename T>
-    struct IsStreamInsertable {
-        static std::ostream &s;
-        static T  const&t;
-        enum { value = sizeof( testStreamable(s << t) ) == sizeof( TrueType ) };
-    };
-
-#endif
-
-#if defined(CATCH_CPP11_OR_GREATER)
-    template<typename T,
-             bool IsEnum = std::is_enum<T>::value
-             >
-    struct EnumStringMaker
-    {
-        static std::string convert( T const& ) { return unprintableString; }
-    };
-
-    template<typename T>
-    struct EnumStringMaker<T,true>
-    {
-        static std::string convert( T const& v )
-        {
-            return ::Catch::toString(
-                static_cast<typename std::underlying_type<T>::type>(v)
-                );
-        }
-    };
-#endif
-    template<bool C>
-    struct StringMakerBase {
-#if defined(CATCH_CPP11_OR_GREATER)
-        template<typename T>
-        static std::string convert( T const& v )
-        {
-            return EnumStringMaker<T>::convert( v );
-        }
-#else
-        template<typename T>
-        static std::string convert( T const& ) { return unprintableString; }
-#endif
-    };
-
-    template<>
-    struct StringMakerBase<true> {
-        template<typename T>
-        static std::string convert( T const& _value ) {
-            std::ostringstream oss;
-            oss << _value;
-            return oss.str();
-        }
-    };
-
-    std::string rawMemoryToString( const void *object, std::size_t size );
-
-    template<typename T>
-    inline std::string rawMemoryToString( const T& object ) {
-      return rawMemoryToString( &object, sizeof(object) );
-    }
-
-} // end namespace Detail
-
-template<typename T>
-struct StringMaker :
-    Detail::StringMakerBase<Detail::IsStreamInsertable<T>::value> {};
-
-template<typename T>
-struct StringMaker<T*> {
-    template<typename U>
-    static std::string convert( U* p ) {
-        if( !p )
-            return INTERNAL_CATCH_STRINGIFY( NULL );
-        else
-            return Detail::rawMemoryToString( p );
-    }
-};
-
-template<typename R, typename C>
-struct StringMaker<R C::*> {
-    static std::string convert( R C::* p ) {
-        if( !p )
-            return INTERNAL_CATCH_STRINGIFY( NULL );
-        else
-            return Detail::rawMemoryToString( p );
-    }
-};
-
-namespace Detail {
-    template<typename InputIterator>
-    std::string rangeToString( InputIterator first, InputIterator last );
-}
-
-//template<typename T, typename Allocator>
-//struct StringMaker<std::vector<T, Allocator> > {
-//    static std::string convert( std::vector<T,Allocator> const& v ) {
-//        return Detail::rangeToString( v.begin(), v.end() );
-//    }
-//};
-
-template<typename T, typename Allocator>
-std::string toString( std::vector<T,Allocator> const& v ) {
-    return Detail::rangeToString( v.begin(), v.end() );
-}
-
-#ifdef CATCH_CPP11_OR_GREATER
-//toString for tuples
- 
-namespace TupleDetail {
-  template<
-      typename Tuple,
-      std::size_t N = 0,
-      bool = (N < std::tuple_size<Tuple>::value)
-      >
-  struct ElementPrinter {
-      static void print( const Tuple& tuple, std::ostream& os )
-      {
-          os << ( N ? ", " : " " )
-             << Catch::toString(std::get<N>(tuple));
-          ElementPrinter<Tuple,N+1>::print(tuple,os);
-      }
-  };
-
-  template<
-      typename Tuple,
-      std::size_t N
-      >
-  struct ElementPrinter<Tuple,N,false> {
-      static void print( const Tuple&, std::ostream& ) {}
-  };
-
-}
-
-template<typename ...Types>
-struct StringMaker<std::tuple<Types...>> {
-
-    static std::string convert( const std::tuple<Types...>& tuple )
-    {
-        std::ostringstream os;
-        os << '{';
-        TupleDetail::ElementPrinter<std::tuple<Types...>>::print( tuple, os );
-        os << " }";
-        return os.str();
-    }
-};
-#endif
-
-namespace Detail {
-    template<typename T>
-    std::string makeString( T const& value ) {
-        return StringMaker<T>::convert( value );
-    }
-} // end namespace Detail
-
-/// \brief converts any type to a string
-///
-/// The default template forwards on to ostringstream - except when an
-/// ostringstream overload does not exist - in which case it attempts to detect
-/// that and writes {?}.
-/// Overload (not specialise) this template for custom typs that you don't want
-/// to provide an ostream overload for.
-template<typename T>
-std::string toString( T const& value ) {
-    return StringMaker<T>::convert( value );
-}
-
-    namespace Detail {
-    template<typename InputIterator>
-    std::string rangeToString( InputIterator first, InputIterator last ) {
-        std::ostringstream oss;
-        oss << "{ ";
-        if( first != last ) {
-            oss << Catch::toString( *first );
-            for( ++first ; first != last ; ++first )
-                oss << ", " << Catch::toString( *first );
-        }
-        oss << " }";
-        return oss.str();
-    }
-}
-
-} // end namespace Catch
-
-namespace Catch {
-
-// Wraps the LHS of an expression and captures the operator and RHS (if any) -
-// wrapping them all in a ResultBuilder object
-template<typename T>
-class ExpressionLhs {
-    ExpressionLhs& operator = ( ExpressionLhs const& );
-#  ifdef CATCH_CPP11_OR_GREATER
-    ExpressionLhs& operator = ( ExpressionLhs && ) = delete;
-#  endif
-
-public:
-    ExpressionLhs( ResultBuilder& rb, T lhs ) : m_rb( rb ), m_lhs( lhs ) {}
-#  ifdef CATCH_CPP11_OR_GREATER
-    ExpressionLhs( ExpressionLhs const& ) = default;
-    ExpressionLhs( ExpressionLhs && )     = default;
-#  endif
-
-    template<typename RhsT>
-    ResultBuilder& operator == ( RhsT const& rhs ) {
-        return captureExpression<Internal::IsEqualTo>( rhs );
-    }
-
-    template<typename RhsT>
-    ResultBuilder& operator != ( RhsT const& rhs ) {
-        return captureExpression<Internal::IsNotEqualTo>( rhs );
-    }
-
-    template<typename RhsT>
-    ResultBuilder& operator < ( RhsT const& rhs ) {
-        return captureExpression<Internal::IsLessThan>( rhs );
-    }
-
-    template<typename RhsT>
-    ResultBuilder& operator > ( RhsT const& rhs ) {
-        return captureExpression<Internal::IsGreaterThan>( rhs );
-    }
-
-    template<typename RhsT>
-    ResultBuilder& operator <= ( RhsT const& rhs ) {
-        return captureExpression<Internal::IsLessThanOrEqualTo>( rhs );
-    }
-
-    template<typename RhsT>
-    ResultBuilder& operator >= ( RhsT const& rhs ) {
-        return captureExpression<Internal::IsGreaterThanOrEqualTo>( rhs );
-    }
-
-    ResultBuilder& operator == ( bool rhs ) {
-        return captureExpression<Internal::IsEqualTo>( rhs );
-    }
-
-    ResultBuilder& operator != ( bool rhs ) {
-        return captureExpression<Internal::IsNotEqualTo>( rhs );
-    }
-
-    void endExpression() {
-        bool value = m_lhs ? true : false;
-        m_rb
-            .setLhs( Catch::toString( value ) )
-            .setResultType( value )
-            .endExpression();
-    }
-
-    // Only simple binary expressions are allowed on the LHS.
-    // If more complex compositions are required then place the sub expression in parentheses
-    template<typename RhsT> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator + ( RhsT const& );
-    template<typename RhsT> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator - ( RhsT const& );
-    template<typename RhsT> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator / ( RhsT const& );
-    template<typename RhsT> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator * ( RhsT const& );
-    template<typename RhsT> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator && ( RhsT const& );
-    template<typename RhsT> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator || ( RhsT const& );
-
-private:
-    template<Internal::Operator Op, typename RhsT>
-    ResultBuilder& captureExpression( RhsT const& rhs ) {
-        return m_rb
-            .setResultType( Internal::compare<Op>( m_lhs, rhs ) )
-            .setLhs( Catch::toString( m_lhs ) )
-            .setRhs( Catch::toString( rhs ) )
-            .setOp( Internal::OperatorTraits<Op>::getName() );
-    }
-
-private:
-    ResultBuilder& m_rb;
-    T m_lhs;
-};
-
-} // end namespace Catch
-
-
-namespace Catch {
-
-    template<typename T>
-    inline ExpressionLhs<T const&> ResultBuilder::operator->* ( T const& operand ) {
-        return ExpressionLhs<T const&>( *this, operand );
-    }
-
-    inline ExpressionLhs<bool> ResultBuilder::operator->* ( bool value ) {
-        return ExpressionLhs<bool>( *this, value );
-    }
-
-} // namespace Catch
-
-// #included from: catch_message.h
-#define TWOBLUECUBES_CATCH_MESSAGE_H_INCLUDED
-
-#include <string>
-
-namespace Catch {
-
-    struct MessageInfo {
-        MessageInfo(    std::string const& _macroName,
-                        SourceLineInfo const& _lineInfo,
-                        ResultWas::OfType _type );
-
-        std::string macroName;
-        SourceLineInfo lineInfo;
-        ResultWas::OfType type;
-        std::string message;
-        unsigned int sequence;
-
-        bool operator == ( MessageInfo const& other ) const {
-            return sequence == other.sequence;
-        }
-        bool operator < ( MessageInfo const& other ) const {
-            return sequence < other.sequence;
-        }
-    private:
-        static unsigned int globalCount;
-    };
-
-    struct MessageBuilder {
-        MessageBuilder( std::string const& macroName,
-                        SourceLineInfo const& lineInfo,
-                        ResultWas::OfType type )
-        : m_info( macroName, lineInfo, type )
-        {}
-
-        template<typename T>
-        MessageBuilder& operator << ( T const& value ) {
-            m_stream << value;
-            return *this;
-        }
-
-        MessageInfo m_info;
-        std::ostringstream m_stream;
-    };
-
-    class ScopedMessage {
-    public:
-        ScopedMessage( MessageBuilder const& builder );
-        ScopedMessage( ScopedMessage const& other );
-        ~ScopedMessage();
-
-        MessageInfo m_info;
-    };
-
-} // end namespace Catch
-
-// #included from: catch_interfaces_capture.h
-#define TWOBLUECUBES_CATCH_INTERFACES_CAPTURE_H_INCLUDED
-
-#include <string>
-
-namespace Catch {
-
-    class TestCase;
-    class AssertionResult;
-    struct AssertionInfo;
-    struct SectionInfo;
-    struct MessageInfo;
-    class ScopedMessageBuilder;
-    struct Counts;
-
-    struct IResultCapture {
-
-        virtual ~IResultCapture();
-
-        virtual void assertionEnded( AssertionResult const& result ) = 0;
-        virtual bool sectionStarted(    SectionInfo const& sectionInfo,
-                                        Counts& assertions ) = 0;
-        virtual void sectionEnded( SectionInfo const& name, Counts const& assertions, double _durationInSeconds ) = 0;
-        virtual void pushScopedMessage( MessageInfo const& message ) = 0;
-        virtual void popScopedMessage( MessageInfo const& message ) = 0;
-
-        virtual std::string getCurrentTestName() const = 0;
-        virtual const AssertionResult* getLastResult() const = 0;
-
-        virtual void handleFatalErrorCondition( std::string const& message ) = 0;
-    };
-
-    IResultCapture& getResultCapture();
-}
-
-// #included from: catch_debugger.h
-#define TWOBLUECUBES_CATCH_DEBUGGER_H_INCLUDED
-
-// #included from: catch_platform.h
-#define TWOBLUECUBES_CATCH_PLATFORM_H_INCLUDED
-
-#if defined(__MAC_OS_X_VERSION_MIN_REQUIRED)
-#define CATCH_PLATFORM_MAC
-#elif  defined(__IPHONE_OS_VERSION_MIN_REQUIRED)
-#define CATCH_PLATFORM_IPHONE
-#elif defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER)
-#define CATCH_PLATFORM_WINDOWS
-#endif
-
-#include <string>
-
-namespace Catch{
-
-    bool isDebuggerActive();
-    void writeToDebugConsole( std::string const& text );
-}
-
-#ifdef CATCH_PLATFORM_MAC
-
-    // The following code snippet based on:
-    // http://cocoawithlove.com/2008/03/break-into-debugger.html
-    #ifdef DEBUG
-        #if defined(__ppc64__) || defined(__ppc__)
-            #define CATCH_BREAK_INTO_DEBUGGER() \
-                if( Catch::isDebuggerActive() ) { \
-                    __asm__("li r0, 20\nsc\nnop\nli r0, 37\nli r4, 2\nsc\nnop\n" \
-                    : : : "memory","r0","r3","r4" ); \
-                }
-        #else
-            #define CATCH_BREAK_INTO_DEBUGGER() if( Catch::isDebuggerActive() ) {__asm__("int $3\n" : : );}
-        #endif
-    #endif
-
-#elif defined(_MSC_VER)
-    #define CATCH_BREAK_INTO_DEBUGGER() if( Catch::isDebuggerActive() ) { __debugbreak(); }
-#elif defined(__MINGW32__)
-    extern "C" __declspec(dllimport) void __stdcall DebugBreak();
-    #define CATCH_BREAK_INTO_DEBUGGER() if( Catch::isDebuggerActive() ) { DebugBreak(); }
-#endif
-
-#ifndef CATCH_BREAK_INTO_DEBUGGER
-#define CATCH_BREAK_INTO_DEBUGGER() Catch::alwaysTrue();
-#endif
-
-// #included from: catch_interfaces_runner.h
-#define TWOBLUECUBES_CATCH_INTERFACES_RUNNER_H_INCLUDED
-
-namespace Catch {
-    class TestCase;
-
-    struct IRunner {
-        virtual ~IRunner();
-        virtual bool aborting() const = 0;
-    };
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// In the event of a failure works out if the debugger needs to be invoked
-// and/or an exception thrown and takes appropriate action.
-// This needs to be done as a macro so the debugger will stop in the user
-// source code rather than in Catch library code
-#define INTERNAL_CATCH_REACT( resultBuilder ) \
-    if( resultBuilder.shouldDebugBreak() ) CATCH_BREAK_INTO_DEBUGGER(); \
-    resultBuilder.react();
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_TEST( expr, resultDisposition, macroName ) \
-    do { \
-        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #expr, resultDisposition ); \
-        try { \
-            ( __catchResult->*expr ).endExpression(); \
-        } \
-        catch( ... ) { \
-            __catchResult.useActiveException( Catch::ResultDisposition::Normal ); \
-        } \
-        INTERNAL_CATCH_REACT( __catchResult ) \
-    } while( Catch::isTrue( false && (expr) ) ) // expr here is never evaluated at runtime but it forces the compiler to give it a look
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_IF( expr, resultDisposition, macroName ) \
-    INTERNAL_CATCH_TEST( expr, resultDisposition, macroName ); \
-    if( Catch::getResultCapture().getLastResult()->succeeded() )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_ELSE( expr, resultDisposition, macroName ) \
-    INTERNAL_CATCH_TEST( expr, resultDisposition, macroName ); \
-    if( !Catch::getResultCapture().getLastResult()->succeeded() )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_NO_THROW( expr, resultDisposition, macroName ) \
-    do { \
-        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #expr, resultDisposition ); \
-        try { \
-            expr; \
-            __catchResult.captureResult( Catch::ResultWas::Ok ); \
-        } \
-        catch( ... ) { \
-            __catchResult.useActiveException( resultDisposition ); \
-        } \
-        INTERNAL_CATCH_REACT( __catchResult ) \
-    } while( Catch::alwaysFalse() )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_THROWS( expr, resultDisposition, macroName ) \
-    do { \
-        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #expr, resultDisposition ); \
-        if( __catchResult.allowThrows() ) \
-            try { \
-                expr; \
-                __catchResult.captureResult( Catch::ResultWas::DidntThrowException ); \
-            } \
-            catch( ... ) { \
-                __catchResult.captureResult( Catch::ResultWas::Ok ); \
-            } \
-        else \
-            __catchResult.captureResult( Catch::ResultWas::Ok ); \
-        INTERNAL_CATCH_REACT( __catchResult ) \
-    } while( Catch::alwaysFalse() )
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_THROWS_AS( expr, exceptionType, resultDisposition, macroName ) \
-    do { \
-        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #expr, resultDisposition ); \
-        if( __catchResult.allowThrows() ) \
-            try { \
-                expr; \
-                __catchResult.captureResult( Catch::ResultWas::DidntThrowException ); \
-            } \
-            catch( exceptionType ) { \
-                __catchResult.captureResult( Catch::ResultWas::Ok ); \
-            } \
-            catch( ... ) { \
-                __catchResult.useActiveException( resultDisposition ); \
-            } \
-        else \
-            __catchResult.captureResult( Catch::ResultWas::Ok ); \
-        INTERNAL_CATCH_REACT( __catchResult ) \
-    } while( Catch::alwaysFalse() )
-
-///////////////////////////////////////////////////////////////////////////////
-#ifdef CATCH_CONFIG_VARIADIC_MACROS
-    #define INTERNAL_CATCH_MSG( messageType, resultDisposition, macroName, ... ) \
-        do { \
-            Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, "", resultDisposition ); \
-            __catchResult << __VA_ARGS__ + ::Catch::StreamEndStop(); \
-            __catchResult.captureResult( messageType ); \
-            INTERNAL_CATCH_REACT( __catchResult ) \
-        } while( Catch::alwaysFalse() )
-#else
-    #define INTERNAL_CATCH_MSG( messageType, resultDisposition, macroName, log ) \
-        do { \
-            Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, "", resultDisposition ); \
-            __catchResult << log + ::Catch::StreamEndStop(); \
-            __catchResult.captureResult( messageType ); \
-            INTERNAL_CATCH_REACT( __catchResult ) \
-        } while( Catch::alwaysFalse() )
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_INFO( log, macroName ) \
-    Catch::ScopedMessage INTERNAL_CATCH_UNIQUE_NAME( scopedMessage ) = Catch::MessageBuilder( macroName, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log;
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CHECK_THAT( arg, matcher, resultDisposition, macroName ) \
-    do { \
-        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #arg " " #matcher, resultDisposition ); \
-        try { \
-            std::string matcherAsString = ::Catch::Matchers::matcher.toString(); \
-            __catchResult \
-                .setLhs( Catch::toString( arg ) ) \
-                .setRhs( matcherAsString == Catch::Detail::unprintableString ? #matcher : matcherAsString ) \
-                .setOp( "matches" ) \
-                .setResultType( ::Catch::Matchers::matcher.match( arg ) ); \
-            __catchResult.captureExpression(); \
-        } catch( ... ) { \
-            __catchResult.useActiveException( resultDisposition | Catch::ResultDisposition::ContinueOnFailure ); \
-        } \
-        INTERNAL_CATCH_REACT( __catchResult ) \
-    } while( Catch::alwaysFalse() )
-
-// #included from: internal/catch_section.h
-#define TWOBLUECUBES_CATCH_SECTION_H_INCLUDED
-
-// #included from: catch_section_info.h
-#define TWOBLUECUBES_CATCH_SECTION_INFO_H_INCLUDED
-
-namespace Catch {
-
-    struct SectionInfo {
-        SectionInfo
-            (   SourceLineInfo const& _lineInfo,
-                std::string const& _name,
-                std::string const& _description = std::string() );
-
-        std::string name;
-        std::string description;
-        SourceLineInfo lineInfo;
-    };
-
-} // end namespace Catch
-
-// #included from: catch_totals.hpp
-#define TWOBLUECUBES_CATCH_TOTALS_HPP_INCLUDED
-
-#include <cstddef>
-
-namespace Catch {
-
-    struct Counts {
-        Counts() : passed( 0 ), failed( 0 ), failedButOk( 0 ) {}
-
-        Counts operator - ( Counts const& other ) const {
-            Counts diff;
-            diff.passed = passed - other.passed;
-            diff.failed = failed - other.failed;
-            diff.failedButOk = failedButOk - other.failedButOk;
-            return diff;
-        }
-        Counts& operator += ( Counts const& other ) {
-            passed += other.passed;
-            failed += other.failed;
-            failedButOk += other.failedButOk;
-            return *this;
-        }
-
-        std::size_t total() const {
-            return passed + failed + failedButOk;
-        }
-        bool allPassed() const {
-            return failed == 0 && failedButOk == 0;
-        }
-        bool allOk() const {
-            return failed == 0;
-        }
-
-        std::size_t passed;
-        std::size_t failed;
-        std::size_t failedButOk;
-    };
-
-    struct Totals {
-
-        Totals operator - ( Totals const& other ) const {
-            Totals diff;
-            diff.assertions = assertions - other.assertions;
-            diff.testCases = testCases - other.testCases;
-            return diff;
-        }
-
-        Totals delta( Totals const& prevTotals ) const {
-            Totals diff = *this - prevTotals;
-            if( diff.assertions.failed > 0 )
-                ++diff.testCases.failed;
-            else if( diff.assertions.failedButOk > 0 )
-                ++diff.testCases.failedButOk;
-            else
-                ++diff.testCases.passed;
-            return diff;
-        }
-
-        Totals& operator += ( Totals const& other ) {
-            assertions += other.assertions;
-            testCases += other.testCases;
-            return *this;
-        }
-
-        Counts assertions;
-        Counts testCases;
-    };
-}
-
-// #included from: catch_timer.h
-#define TWOBLUECUBES_CATCH_TIMER_H_INCLUDED
-
-#ifdef CATCH_PLATFORM_WINDOWS
-typedef unsigned long long uint64_t;
-#else
-#include <stdint.h>
-#endif
-
-namespace Catch {
-
-    class Timer {
-    public:
-        Timer() : m_ticks( 0 ) {}
-        void start();
-        unsigned int getElapsedMicroseconds() const;
-        unsigned int getElapsedMilliseconds() const;
-        double getElapsedSeconds() const;
-
-    private:
-        uint64_t m_ticks;
-    };
-
-} // namespace Catch
-
-#include <string>
-
-namespace Catch {
-
-    class Section : NonCopyable {
-    public:
-        Section( SectionInfo const& info );
-        ~Section();
-
-        // This indicates whether the section should be executed or not
-        operator bool() const;
-
-    private:
-        SectionInfo m_info;
-
-        std::string m_name;
-        Counts m_assertions;
-        bool m_sectionIncluded;
-        Timer m_timer;
-    };
-
-} // end namespace Catch
-
-#ifdef CATCH_CONFIG_VARIADIC_MACROS
-    #define INTERNAL_CATCH_SECTION( ... ) \
-        if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, __VA_ARGS__ ) )
-#else
-    #define INTERNAL_CATCH_SECTION( name, desc ) \
-        if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, name, desc ) )
-#endif
-
-// #included from: internal/catch_generators.hpp
-#define TWOBLUECUBES_CATCH_GENERATORS_HPP_INCLUDED
-
-#include <iterator>
-#include <vector>
-#include <string>
-#include <stdlib.h>
-
-namespace Catch {
-
-template<typename T>
-struct IGenerator {
-    virtual ~IGenerator() {}
-    virtual T getValue( std::size_t index ) const = 0;
-    virtual std::size_t size () const = 0;
-};
-
-template<typename T>
-class BetweenGenerator : public IGenerator<T> {
-public:
-    BetweenGenerator( T from, T to ) : m_from( from ), m_to( to ){}
-
-    virtual T getValue( std::size_t index ) const {
-        return m_from+static_cast<int>( index );
-    }
-
-    virtual std::size_t size() const {
-        return static_cast<std::size_t>( 1+m_to-m_from );
-    }
-
-private:
-
-    T m_from;
-    T m_to;
-};
-
-template<typename T>
-class ValuesGenerator : public IGenerator<T> {
-public:
-    ValuesGenerator(){}
-
-    void add( T value ) {
-        m_values.push_back( value );
-    }
-
-    virtual T getValue( std::size_t index ) const {
-        return m_values[index];
-    }
-
-    virtual std::size_t size() const {
-        return m_values.size();
-    }
-
-private:
-    std::vector<T> m_values;
-};
-
-template<typename T>
-class CompositeGenerator {
-public:
-    CompositeGenerator() : m_totalSize( 0 ) {}
-
-    // *** Move semantics, similar to auto_ptr ***
-    CompositeGenerator( CompositeGenerator& other )
-    :   m_fileInfo( other.m_fileInfo ),
-        m_totalSize( 0 )
-    {
-        move( other );
-    }
-
-    CompositeGenerator& setFileInfo( const char* fileInfo ) {
-        m_fileInfo = fileInfo;
-        return *this;
-    }
-
-    ~CompositeGenerator() {
-        deleteAll( m_composed );
-    }
-
-    operator T () const {
-        size_t overallIndex = getCurrentContext().getGeneratorIndex( m_fileInfo, m_totalSize );
-
-        typename std::vector<const IGenerator<T>*>::const_iterator it = m_composed.begin();
-        typename std::vector<const IGenerator<T>*>::const_iterator itEnd = m_composed.end();
-        for( size_t index = 0; it != itEnd; ++it )
-        {
-            const IGenerator<T>* generator = *it;
-            if( overallIndex >= index && overallIndex < index + generator->size() )
-            {
-                return generator->getValue( overallIndex-index );
-            }
-            index += generator->size();
-        }
-        CATCH_INTERNAL_ERROR( "Indexed past end of generated range" );
-        return T(); // Suppress spurious "not all control paths return a value" warning in Visual Studio - if you know how to fix this please do so
-    }
-
-    void add( const IGenerator<T>* generator ) {
-        m_totalSize += generator->size();
-        m_composed.push_back( generator );
-    }
-
-    CompositeGenerator& then( CompositeGenerator& other ) {
-        move( other );
-        return *this;
-    }
-
-    CompositeGenerator& then( T value ) {
-        ValuesGenerator<T>* valuesGen = new ValuesGenerator<T>();
-        valuesGen->add( value );
-        add( valuesGen );
-        return *this;
-    }
-
-private:
-
-    void move( CompositeGenerator& other ) {
-        std::copy( other.m_composed.begin(), other.m_composed.end(), std::back_inserter( m_composed ) );
-        m_totalSize += other.m_totalSize;
-        other.m_composed.clear();
-    }
-
-    std::vector<const IGenerator<T>*> m_composed;
-    std::string m_fileInfo;
-    size_t m_totalSize;
-};
-
-namespace Generators
-{
-    template<typename T>
-    CompositeGenerator<T> between( T from, T to ) {
-        CompositeGenerator<T> generators;
-        generators.add( new BetweenGenerator<T>( from, to ) );
-        return generators;
-    }
-
-    template<typename T>
-    CompositeGenerator<T> values( T val1, T val2 ) {
-        CompositeGenerator<T> generators;
-        ValuesGenerator<T>* valuesGen = new ValuesGenerator<T>();
-        valuesGen->add( val1 );
-        valuesGen->add( val2 );
-        generators.add( valuesGen );
-        return generators;
-    }
-
-    template<typename T>
-    CompositeGenerator<T> values( T val1, T val2, T val3 ){
-        CompositeGenerator<T> generators;
-        ValuesGenerator<T>* valuesGen = new ValuesGenerator<T>();
-        valuesGen->add( val1 );
-        valuesGen->add( val2 );
-        valuesGen->add( val3 );
-        generators.add( valuesGen );
-        return generators;
-    }
-
-    template<typename T>
-    CompositeGenerator<T> values( T val1, T val2, T val3, T val4 ) {
-        CompositeGenerator<T> generators;
-        ValuesGenerator<T>* valuesGen = new ValuesGenerator<T>();
-        valuesGen->add( val1 );
-        valuesGen->add( val2 );
-        valuesGen->add( val3 );
-        valuesGen->add( val4 );
-        generators.add( valuesGen );
-        return generators;
-    }
-
-} // end namespace Generators
-
-using namespace Generators;
-
-} // end namespace Catch
-
-#define INTERNAL_CATCH_LINESTR2( line ) #line
-#define INTERNAL_CATCH_LINESTR( line ) INTERNAL_CATCH_LINESTR2( line )
-
-#define INTERNAL_CATCH_GENERATE( expr ) expr.setFileInfo( __FILE__ "(" INTERNAL_CATCH_LINESTR( __LINE__ ) ")" )
-
-// #included from: internal/catch_interfaces_exception.h
-#define TWOBLUECUBES_CATCH_INTERFACES_EXCEPTION_H_INCLUDED
-
-#include <string>
-// #included from: catch_interfaces_registry_hub.h
-#define TWOBLUECUBES_CATCH_INTERFACES_REGISTRY_HUB_H_INCLUDED
-
-#include <string>
-
-namespace Catch {
-
-    class TestCase;
-    struct ITestCaseRegistry;
-    struct IExceptionTranslatorRegistry;
-    struct IExceptionTranslator;
-    struct IReporterRegistry;
-    struct IReporterFactory;
-
-    struct IRegistryHub {
-        virtual ~IRegistryHub();
-
-        virtual IReporterRegistry const& getReporterRegistry() const = 0;
-        virtual ITestCaseRegistry const& getTestCaseRegistry() const = 0;
-        virtual IExceptionTranslatorRegistry& getExceptionTranslatorRegistry() = 0;
-    };
-
-    struct IMutableRegistryHub {
-        virtual ~IMutableRegistryHub();
-        virtual void registerReporter( std::string const& name, IReporterFactory* factory ) = 0;
-        virtual void registerTest( TestCase const& testInfo ) = 0;
-        virtual void registerTranslator( const IExceptionTranslator* translator ) = 0;
-    };
-
-    IRegistryHub& getRegistryHub();
-    IMutableRegistryHub& getMutableRegistryHub();
-    void cleanUp();
-    std::string translateActiveException();
-
-}
-
-
-namespace Catch {
-
-    typedef std::string(*exceptionTranslateFunction)();
-
-    struct IExceptionTranslator {
-        virtual ~IExceptionTranslator();
-        virtual std::string translate() const = 0;
-    };
-
-    struct IExceptionTranslatorRegistry {
-        virtual ~IExceptionTranslatorRegistry();
-
-        virtual std::string translateActiveException() const = 0;
-    };
-
-    class ExceptionTranslatorRegistrar {
-        template<typename T>
-        class ExceptionTranslator : public IExceptionTranslator {
-        public:
-
-            ExceptionTranslator( std::string(*translateFunction)( T& ) )
-            : m_translateFunction( translateFunction )
-            {}
-
-            virtual std::string translate() const {
-                try {
-                    throw;
-                }
-                catch( T& ex ) {
-                    return m_translateFunction( ex );
-                }
-            }
-
-        protected:
-            std::string(*m_translateFunction)( T& );
-        };
-
-    public:
-        template<typename T>
-        ExceptionTranslatorRegistrar( std::string(*translateFunction)( T& ) ) {
-            getMutableRegistryHub().registerTranslator
-                ( new ExceptionTranslator<T>( translateFunction ) );
-        }
-    };
-}
-
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature ) \
-    static std::string INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator )( signature ); \
-    namespace{ Catch::ExceptionTranslatorRegistrar INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionRegistrar )( &INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ) ); }\
-    static std::string INTERNAL_CATCH_UNIQUE_NAME(  catch_internal_ExceptionTranslator )( signature )
-
-// #included from: internal/catch_approx.hpp
-#define TWOBLUECUBES_CATCH_APPROX_HPP_INCLUDED
-
-#include <cmath>
-#include <limits>
-
-namespace Catch {
-namespace Detail {
-
-    class Approx {
-    public:
-        explicit Approx ( double value )
-        :   m_epsilon( std::numeric_limits<float>::epsilon()*100 ),
-            m_scale( 1.0 ),
-            m_value( value )
-        {}
-
-        Approx( Approx const& other )
-        :   m_epsilon( other.m_epsilon ),
-            m_scale( other.m_scale ),
-            m_value( other.m_value )
-        {}
-
-        static Approx custom() {
-            return Approx( 0 );
-        }
-
-        Approx operator()( double value ) {
-            Approx approx( value );
-            approx.epsilon( m_epsilon );
-            approx.scale( m_scale );
-            return approx;
-        }
-
-        friend bool operator == ( double lhs, Approx const& rhs ) {
-            // Thanks to Richard Harris for his help refining this formula
-            return fabs( lhs - rhs.m_value ) < rhs.m_epsilon * (rhs.m_scale + (std::max)( fabs(lhs), fabs(rhs.m_value) ) );
-        }
-
-        friend bool operator == ( Approx const& lhs, double rhs ) {
-            return operator==( rhs, lhs );
-        }
-
-        friend bool operator != ( double lhs, Approx const& rhs ) {
-            return !operator==( lhs, rhs );
-        }
-
-        friend bool operator != ( Approx const& lhs, double rhs ) {
-            return !operator==( rhs, lhs );
-        }
-
-        Approx& epsilon( double newEpsilon ) {
-            m_epsilon = newEpsilon;
-            return *this;
-        }
-
-        Approx& scale( double newScale ) {
-            m_scale = newScale;
-            return *this;
-        }
-
-        std::string toString() const {
-            std::ostringstream oss;
-            oss << "Approx( " << Catch::toString( m_value ) << " )";
-            return oss.str();
-        }
-
-    private:
-        double m_epsilon;
-        double m_scale;
-        double m_value;
-    };
-}
-
-template<>
-inline std::string toString<Detail::Approx>( Detail::Approx const& value ) {
-    return value.toString();
-}
-
-} // end namespace Catch
-
-// #included from: internal/catch_matchers.hpp
-#define TWOBLUECUBES_CATCH_MATCHERS_HPP_INCLUDED
-
-namespace Catch {
-namespace Matchers {
-    namespace Impl {
-
-    template<typename ExpressionT>
-    struct Matcher : SharedImpl<IShared>
-    {
-        typedef ExpressionT ExpressionType;
-
-        virtual ~Matcher() {}
-        virtual Ptr<Matcher> clone() const = 0;
-        virtual bool match( ExpressionT const& expr ) const = 0;
-        virtual std::string toString() const = 0;
-    };
-
-    template<typename DerivedT, typename ExpressionT>
-    struct MatcherImpl : Matcher<ExpressionT> {
-
-        virtual Ptr<Matcher<ExpressionT> > clone() const {
-            return Ptr<Matcher<ExpressionT> >( new DerivedT( static_cast<DerivedT const&>( *this ) ) );
-        }
-    };
-
-    namespace Generic {
-
-        template<typename ExpressionT>
-        class AllOf : public MatcherImpl<AllOf<ExpressionT>, ExpressionT> {
-        public:
-
-            AllOf() {}
-            AllOf( AllOf const& other ) : m_matchers( other.m_matchers ) {}
-
-            AllOf& add( Matcher<ExpressionT> const& matcher ) {
-                m_matchers.push_back( matcher.clone() );
-                return *this;
-            }
-            virtual bool match( ExpressionT const& expr ) const
-            {
-                for( std::size_t i = 0; i < m_matchers.size(); ++i )
-                    if( !m_matchers[i]->match( expr ) )
-                        return false;
-                return true;
-            }
-            virtual std::string toString() const {
-                std::ostringstream oss;
-                oss << "( ";
-                for( std::size_t i = 0; i < m_matchers.size(); ++i ) {
-                    if( i != 0 )
-                        oss << " and ";
-                    oss << m_matchers[i]->toString();
-                }
-                oss << " )";
-                return oss.str();
-            }
-
-        private:
-            std::vector<Ptr<Matcher<ExpressionT> > > m_matchers;
-        };
-
-        template<typename ExpressionT>
-        class AnyOf : public MatcherImpl<AnyOf<ExpressionT>, ExpressionT> {
-        public:
-
-            AnyOf() {}
-            AnyOf( AnyOf const& other ) : m_matchers( other.m_matchers ) {}
-
-            AnyOf& add( Matcher<ExpressionT> const& matcher ) {
-                m_matchers.push_back( matcher.clone() );
-                return *this;
-            }
-            virtual bool match( ExpressionT const& expr ) const
-            {
-                for( std::size_t i = 0; i < m_matchers.size(); ++i )
-                    if( m_matchers[i]->match( expr ) )
-                        return true;
-                return false;
-            }
-            virtual std::string toString() const {
-                std::ostringstream oss;
-                oss << "( ";
-                for( std::size_t i = 0; i < m_matchers.size(); ++i ) {
-                    if( i != 0 )
-                        oss << " or ";
-                    oss << m_matchers[i]->toString();
-                }
-                oss << " )";
-                return oss.str();
-            }
-
-        private:
-            std::vector<Ptr<Matcher<ExpressionT> > > m_matchers;
-        };
-
-    }
-
-    namespace StdString {
-
-        inline std::string makeString( std::string const& str ) { return str; }
-        inline std::string makeString( const char* str ) { return str ? std::string( str ) : std::string(); }
-
-        struct Equals : MatcherImpl<Equals, std::string> {
-            Equals( std::string const& str ) : m_str( str ){}
-            Equals( Equals const& other ) : m_str( other.m_str ){}
-
-            virtual ~Equals();
-
-            virtual bool match( std::string const& expr ) const {
-                return m_str == expr;
-            }
-            virtual std::string toString() const {
-                return "equals: \"" + m_str + "\"";
-            }
-
-            std::string m_str;
-        };
-
-        struct Contains : MatcherImpl<Contains, std::string> {
-            Contains( std::string const& substr ) : m_substr( substr ){}
-            Contains( Contains const& other ) : m_substr( other.m_substr ){}
-
-            virtual ~Contains();
-
-            virtual bool match( std::string const& expr ) const {
-                return expr.find( m_substr ) != std::string::npos;
-            }
-            virtual std::string toString() const {
-                return "contains: \"" + m_substr + "\"";
-            }
-
-            std::string m_substr;
-        };
-
-        struct StartsWith : MatcherImpl<StartsWith, std::string> {
-            StartsWith( std::string const& substr ) : m_substr( substr ){}
-            StartsWith( StartsWith const& other ) : m_substr( other.m_substr ){}
-
-            virtual ~StartsWith();
-
-            virtual bool match( std::string const& expr ) const {
-                return expr.find( m_substr ) == 0;
-            }
-            virtual std::string toString() const {
-                return "starts with: \"" + m_substr + "\"";
-            }
-
-            std::string m_substr;
-        };
-
-        struct EndsWith : MatcherImpl<EndsWith, std::string> {
-            EndsWith( std::string const& substr ) : m_substr( substr ){}
-            EndsWith( EndsWith const& other ) : m_substr( other.m_substr ){}
-
-            virtual ~EndsWith();
-
-            virtual bool match( std::string const& expr ) const {
-                return expr.find( m_substr ) == expr.size() - m_substr.size();
-            }
-            virtual std::string toString() const {
-                return "ends with: \"" + m_substr + "\"";
-            }
-
-            std::string m_substr;
-        };
-    } // namespace StdString
-    } // namespace Impl
-
-    // The following functions create the actual matcher objects.
-    // This allows the types to be inferred
-    template<typename ExpressionT>
-    inline Impl::Generic::AllOf<ExpressionT> AllOf( Impl::Matcher<ExpressionT> const& m1,
-                                                    Impl::Matcher<ExpressionT> const& m2 ) {
-        return Impl::Generic::AllOf<ExpressionT>().add( m1 ).add( m2 );
-    }
-    template<typename ExpressionT>
-    inline Impl::Generic::AllOf<ExpressionT> AllOf( Impl::Matcher<ExpressionT> const& m1,
-                                                    Impl::Matcher<ExpressionT> const& m2,
-                                                    Impl::Matcher<ExpressionT> const& m3 ) {
-        return Impl::Generic::AllOf<ExpressionT>().add( m1 ).add( m2 ).add( m3 );
-    }
-    template<typename ExpressionT>
-    inline Impl::Generic::AnyOf<ExpressionT> AnyOf( Impl::Matcher<ExpressionT> const& m1,
-                                                    Impl::Matcher<ExpressionT> const& m2 ) {
-        return Impl::Generic::AnyOf<ExpressionT>().add( m1 ).add( m2 );
-    }
-    template<typename ExpressionT>
-    inline Impl::Generic::AnyOf<ExpressionT> AnyOf( Impl::Matcher<ExpressionT> const& m1,
-                                                    Impl::Matcher<ExpressionT> const& m2,
-                                                    Impl::Matcher<ExpressionT> const& m3 ) {
-        return Impl::Generic::AnyOf<ExpressionT>().add( m1 ).add( m2 ).add( m3 );
-    }
-
-    inline Impl::StdString::Equals      Equals( std::string const& str ) {
-        return Impl::StdString::Equals( str );
-    }
-    inline Impl::StdString::Equals      Equals( const char* str ) {
-        return Impl::StdString::Equals( Impl::StdString::makeString( str ) );
-    }
-    inline Impl::StdString::Contains    Contains( std::string const& substr ) {
-        return Impl::StdString::Contains( substr );
-    }
-    inline Impl::StdString::Contains    Contains( const char* substr ) {
-        return Impl::StdString::Contains( Impl::StdString::makeString( substr ) );
-    }
-    inline Impl::StdString::StartsWith  StartsWith( std::string const& substr ) {
-        return Impl::StdString::StartsWith( substr );
-    }
-    inline Impl::StdString::StartsWith  StartsWith( const char* substr ) {
-        return Impl::StdString::StartsWith( Impl::StdString::makeString( substr ) );
-    }
-    inline Impl::StdString::EndsWith    EndsWith( std::string const& substr ) {
-        return Impl::StdString::EndsWith( substr );
-    }
-    inline Impl::StdString::EndsWith    EndsWith( const char* substr ) {
-        return Impl::StdString::EndsWith( Impl::StdString::makeString( substr ) );
-    }
-
-} // namespace Matchers
-
-using namespace Matchers;
-
-} // namespace Catch
-
-// #included from: internal/catch_interfaces_tag_alias_registry.h
-#define TWOBLUECUBES_CATCH_INTERFACES_TAG_ALIAS_REGISTRY_H_INCLUDED
-
-// #included from: catch_tag_alias.h
-#define TWOBLUECUBES_CATCH_TAG_ALIAS_H_INCLUDED
-
-#include <string>
-
-namespace Catch {
-
-    struct TagAlias {
-        TagAlias( std::string _tag, SourceLineInfo _lineInfo ) : tag( _tag ), lineInfo( _lineInfo ) {}
-
-        std::string tag;
-        SourceLineInfo lineInfo;
-    };
-
-    struct RegistrarForTagAliases {
-        RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo );
-    };
-
-} // end namespace Catch
-
-#define CATCH_REGISTER_TAG_ALIAS( alias, spec ) namespace{ Catch::RegistrarForTagAliases INTERNAL_CATCH_UNIQUE_NAME( AutoRegisterTagAlias )( alias, spec, CATCH_INTERNAL_LINEINFO ); }
-// #included from: catch_option.hpp
-#define TWOBLUECUBES_CATCH_OPTION_HPP_INCLUDED
-
-namespace Catch {
-
-    // An optional type
-    template<typename T>
-    class Option {
-    public:
-        Option() : nullableValue( NULL ) {}
-        Option( T const& _value )
-        : nullableValue( new( storage ) T( _value ) )
-        {}
-        Option( Option const& _other )
-        : nullableValue( _other ? new( storage ) T( *_other ) : NULL )
-        {}
-
-        ~Option() {
-            reset();
-        }
-
-        Option& operator= ( Option const& _other ) {
-            if( &_other != this ) {
-                reset();
-                if( _other )
-                    nullableValue = new( storage ) T( *_other );
-            }
-            return *this;
-        }
-        Option& operator = ( T const& _value ) {
-            reset();
-            nullableValue = new( storage ) T( _value );
-            return *this;
-        }
-
-        void reset() {
-            if( nullableValue )
-                nullableValue->~T();
-            nullableValue = NULL;
-        }
-
-        T& operator*() { return *nullableValue; }
-        T const& operator*() const { return *nullableValue; }
-        T* operator->() { return nullableValue; }
-        const T* operator->() const { return nullableValue; }
-
-        T valueOr( T const& defaultValue ) const {
-            return nullableValue ? *nullableValue : defaultValue;
-        }
-
-        bool some() const { return nullableValue != NULL; }
-        bool none() const { return nullableValue == NULL; }
-
-        bool operator !() const { return nullableValue == NULL; }
-        operator SafeBool::type() const {
-            return SafeBool::makeSafe( some() );
-        }
-
-    private:
-        T* nullableValue;
-        char storage[sizeof(T)];
-    };
-
-} // end namespace Catch
-
-namespace Catch {
-
-    struct ITagAliasRegistry {
-        virtual ~ITagAliasRegistry();
-        virtual Option<TagAlias> find( std::string const& alias ) const = 0;
-        virtual std::string expandAliases( std::string const& unexpandedTestSpec ) const = 0;
-
-        static ITagAliasRegistry const& get();
-    };
-
-} // end namespace Catch
-
-// These files are included here so the single_include script doesn't put them
-// in the conditionally compiled sections
-// #included from: internal/catch_test_case_info.h
-#define TWOBLUECUBES_CATCH_TEST_CASE_INFO_H_INCLUDED
-
-#include <string>
-#include <set>
-
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wpadded"
-#endif
-
-namespace Catch {
-
-    struct ITestCase;
-
-    struct TestCaseInfo {
-        enum SpecialProperties{
-            None = 0,
-            IsHidden = 1 << 1,
-            ShouldFail = 1 << 2,
-            MayFail = 1 << 3,
-            Throws = 1 << 4
-        };
-
-        TestCaseInfo(   std::string const& _name,
-                        std::string const& _className,
-                        std::string const& _description,
-                        std::set<std::string> const& _tags,
-                        SourceLineInfo const& _lineInfo );
-
-        TestCaseInfo( TestCaseInfo const& other );
-
-        bool isHidden() const;
-        bool throws() const;
-        bool okToFail() const;
-        bool expectedToFail() const;
-
-        std::string name;
-        std::string className;
-        std::string description;
-        std::set<std::string> tags;
-        std::set<std::string> lcaseTags;
-        std::string tagsAsString;
-        SourceLineInfo lineInfo;
-        SpecialProperties properties;
-    };
-
-    class TestCase : public TestCaseInfo {
-    public:
-
-        TestCase( ITestCase* testCase, TestCaseInfo const& info );
-        TestCase( TestCase const& other );
-
-        TestCase withName( std::string const& _newName ) const;
-
-        void invoke() const;
-
-        TestCaseInfo const& getTestCaseInfo() const;
-
-        void swap( TestCase& other );
-        bool operator == ( TestCase const& other ) const;
-        bool operator < ( TestCase const& other ) const;
-        TestCase& operator = ( TestCase const& other );
-
-    private:
-        Ptr<ITestCase> test;
-    };
-
-    TestCase makeTestCase(  ITestCase* testCase,
-                            std::string const& className,
-                            std::string const& name,
-                            std::string const& description,
-                            SourceLineInfo const& lineInfo );
-}
-
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-
-
-#ifdef __OBJC__
-// #included from: internal/catch_objc.hpp
-#define TWOBLUECUBES_CATCH_OBJC_HPP_INCLUDED
-
-#import <objc/runtime.h>
-
-#include <string>
-
-// NB. Any general catch headers included here must be included
-// in catch.hpp first to make sure they are included by the single
-// header for non obj-usage
-
-///////////////////////////////////////////////////////////////////////////////
-// This protocol is really only here for (self) documenting purposes, since
-// all its methods are optional.
-@protocol OcFixture
-
-@optional
-
--(void) setUp;
--(void) tearDown;
-
-@end
-
-namespace Catch {
-
-    class OcMethod : public SharedImpl<ITestCase> {
-
-    public:
-        OcMethod( Class cls, SEL sel ) : m_cls( cls ), m_sel( sel ) {}
-
-        virtual void invoke() const {
-            id obj = [[m_cls alloc] init];
-
-            performOptionalSelector( obj, @selector(setUp)  );
-            performOptionalSelector( obj, m_sel );
-            performOptionalSelector( obj, @selector(tearDown)  );
-
-            arcSafeRelease( obj );
-        }
-    private:
-        virtual ~OcMethod() {}
-
-        Class m_cls;
-        SEL m_sel;
-    };
-
-    namespace Detail{
-
-        inline std::string getAnnotation(   Class cls,
-                                            std::string const& annotationName,
-                                            std::string const& testCaseName ) {
-            NSString* selStr = [[NSString alloc] initWithFormat:@"Catch_%s_%s", annotationName.c_str(), testCaseName.c_str()];
-            SEL sel = NSSelectorFromString( selStr );
-            arcSafeRelease( selStr );
-            id value = performOptionalSelector( cls, sel );
-            if( value )
-                return [(NSString*)value UTF8String];
-            return "";
-        }
-    }
-
-    inline size_t registerTestMethods() {
-        size_t noTestMethods = 0;
-        int noClasses = objc_getClassList( NULL, 0 );
-
-        Class* classes = (CATCH_UNSAFE_UNRETAINED Class *)malloc( sizeof(Class) * noClasses);
-        objc_getClassList( classes, noClasses );
-
-        for( int c = 0; c < noClasses; c++ ) {
-            Class cls = classes[c];
-            {
-                u_int count;
-                Method* methods = class_copyMethodList( cls, &count );
-                for( u_int m = 0; m < count ; m++ ) {
-                    SEL selector = method_getName(methods[m]);
-                    std::string methodName = sel_getName(selector);
-                    if( startsWith( methodName, "Catch_TestCase_" ) ) {
-                        std::string testCaseName = methodName.substr( 15 );
-                        std::string name = Detail::getAnnotation( cls, "Name", testCaseName );
-                        std::string desc = Detail::getAnnotation( cls, "Description", testCaseName );
-                        const char* className = class_getName( cls );
-
-                        getMutableRegistryHub().registerTest( makeTestCase( new OcMethod( cls, selector ), className, name.c_str(), desc.c_str(), SourceLineInfo() ) );
-                        noTestMethods++;
-                    }
-                }
-                free(methods);
-            }
-        }
-        return noTestMethods;
-    }
-
-    namespace Matchers {
-        namespace Impl {
-        namespace NSStringMatchers {
-
-            template<typename MatcherT>
-            struct StringHolder : MatcherImpl<MatcherT, NSString*>{
-                StringHolder( NSString* substr ) : m_substr( [substr copy] ){}
-                StringHolder( StringHolder const& other ) : m_substr( [other.m_substr copy] ){}
-                StringHolder() {
-                    arcSafeRelease( m_substr );
-                }
-
-                NSString* m_substr;
-            };
-
-            struct Equals : StringHolder<Equals> {
-                Equals( NSString* substr ) : StringHolder( substr ){}
-
-                virtual bool match( ExpressionType const& str ) const {
-                    return  (str != nil || m_substr == nil ) &&
-                            [str isEqualToString:m_substr];
-                }
-
-                virtual std::string toString() const {
-                    return "equals string: " + Catch::toString( m_substr );
-                }
-            };
-
-            struct Contains : StringHolder<Contains> {
-                Contains( NSString* substr ) : StringHolder( substr ){}
-
-                virtual bool match( ExpressionType const& str ) const {
-                    return  (str != nil || m_substr == nil ) &&
-                            [str rangeOfString:m_substr].location != NSNotFound;
-                }
-
-                virtual std::string toString() const {
-                    return "contains string: " + Catch::toString( m_substr );
-                }
-            };
-
-            struct StartsWith : StringHolder<StartsWith> {
-                StartsWith( NSString* substr ) : StringHolder( substr ){}
-
-                virtual bool match( ExpressionType const& str ) const {
-                    return  (str != nil || m_substr == nil ) &&
-                            [str rangeOfString:m_substr].location == 0;
-                }
-
-                virtual std::string toString() const {
-                    return "starts with: " + Catch::toString( m_substr );
-                }
-            };
-            struct EndsWith : StringHolder<EndsWith> {
-                EndsWith( NSString* substr ) : StringHolder( substr ){}
-
-                virtual bool match( ExpressionType const& str ) const {
-                    return  (str != nil || m_substr == nil ) &&
-                            [str rangeOfString:m_substr].location == [str length] - [m_substr length];
-                }
-
-                virtual std::string toString() const {
-                    return "ends with: " + Catch::toString( m_substr );
-                }
-            };
-
-        } // namespace NSStringMatchers
-        } // namespace Impl
-
-        inline Impl::NSStringMatchers::Equals
-            Equals( NSString* substr ){ return Impl::NSStringMatchers::Equals( substr ); }
-
-        inline Impl::NSStringMatchers::Contains
-            Contains( NSString* substr ){ return Impl::NSStringMatchers::Contains( substr ); }
-
-        inline Impl::NSStringMatchers::StartsWith
-            StartsWith( NSString* substr ){ return Impl::NSStringMatchers::StartsWith( substr ); }
-
-        inline Impl::NSStringMatchers::EndsWith
-            EndsWith( NSString* substr ){ return Impl::NSStringMatchers::EndsWith( substr ); }
-
-    } // namespace Matchers
-
-    using namespace Matchers;
-
-} // namespace Catch
-
-///////////////////////////////////////////////////////////////////////////////
-#define OC_TEST_CASE( name, desc )\
-+(NSString*) INTERNAL_CATCH_UNIQUE_NAME( Catch_Name_test ) \
-{\
-return @ name; \
-}\
-+(NSString*) INTERNAL_CATCH_UNIQUE_NAME( Catch_Description_test ) \
-{ \
-return @ desc; \
-} \
--(void) INTERNAL_CATCH_UNIQUE_NAME( Catch_TestCase_test )
-
-#endif
-
-#ifdef CATCH_IMPL
-// #included from: internal/catch_impl.hpp
-#define TWOBLUECUBES_CATCH_IMPL_HPP_INCLUDED
-
-// Collect all the implementation files together here
-// These are the equivalent of what would usually be cpp files
-
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wweak-vtables"
-#endif
-
-// #included from: catch_runner.hpp
-#define TWOBLUECUBES_CATCH_RUNNER_HPP_INCLUDED
-
-// #included from: internal/catch_commandline.hpp
-#define TWOBLUECUBES_CATCH_COMMANDLINE_HPP_INCLUDED
-
-// #included from: catch_config.hpp
-#define TWOBLUECUBES_CATCH_CONFIG_HPP_INCLUDED
-
-// #included from: catch_test_spec_parser.hpp
-#define TWOBLUECUBES_CATCH_TEST_SPEC_PARSER_HPP_INCLUDED
-
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wpadded"
-#endif
-
-// #included from: catch_test_spec.hpp
-#define TWOBLUECUBES_CATCH_TEST_SPEC_HPP_INCLUDED
-
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wpadded"
-#endif
-
-#include <string>
-#include <vector>
-
-namespace Catch {
-
-    class TestSpec {
-        struct Pattern : SharedImpl<> {
-            virtual ~Pattern();
-            virtual bool matches( TestCaseInfo const& testCase ) const = 0;
-        };
-        class NamePattern : public Pattern {
-            enum WildcardPosition {
-                NoWildcard = 0,
-                WildcardAtStart = 1,
-                WildcardAtEnd = 2,
-                WildcardAtBothEnds = WildcardAtStart | WildcardAtEnd
-            };
-
-        public:
-            NamePattern( std::string const& name ) : m_name( toLower( name ) ), m_wildcard( NoWildcard ) {
-                if( startsWith( m_name, "*" ) ) {
-                    m_name = m_name.substr( 1 );
-                    m_wildcard = WildcardAtStart;
-                }
-                if( endsWith( m_name, "*" ) ) {
-                    m_name = m_name.substr( 0, m_name.size()-1 );
-                    m_wildcard = static_cast<WildcardPosition>( m_wildcard | WildcardAtEnd );
-                }
-            }
-            virtual ~NamePattern();
-            virtual bool matches( TestCaseInfo const& testCase ) const {
-                switch( m_wildcard ) {
-                    case NoWildcard:
-                        return m_name == toLower( testCase.name );
-                    case WildcardAtStart:
-                        return endsWith( toLower( testCase.name ), m_name );
-                    case WildcardAtEnd:
-                        return startsWith( toLower( testCase.name ), m_name );
-                    case WildcardAtBothEnds:
-                        return contains( toLower( testCase.name ), m_name );
-                }
-
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wunreachable-code"
-#endif
-                throw std::logic_error( "Unknown enum" );
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-            }
-        private:
-            std::string m_name;
-            WildcardPosition m_wildcard;
-        };
-        class TagPattern : public Pattern {
-        public:
-            TagPattern( std::string const& tag ) : m_tag( toLower( tag ) ) {}
-            virtual ~TagPattern();
-            virtual bool matches( TestCaseInfo const& testCase ) const {
-                return testCase.lcaseTags.find( m_tag ) != testCase.lcaseTags.end();
-            }
-        private:
-            std::string m_tag;
-        };
-        class ExcludedPattern : public Pattern {
-        public:
-            ExcludedPattern( Ptr<Pattern> const& underlyingPattern ) : m_underlyingPattern( underlyingPattern ) {}
-            virtual ~ExcludedPattern();
-            virtual bool matches( TestCaseInfo const& testCase ) const { return !m_underlyingPattern->matches( testCase ); }
-        private:
-            Ptr<Pattern> m_underlyingPattern;
-        };
-
-        struct Filter {
-            std::vector<Ptr<Pattern> > m_patterns;
-
-            bool matches( TestCaseInfo const& testCase ) const {
-                // All patterns in a filter must match for the filter to be a match
-                for( std::vector<Ptr<Pattern> >::const_iterator it = m_patterns.begin(), itEnd = m_patterns.end(); it != itEnd; ++it )
-                    if( !(*it)->matches( testCase ) )
-                        return false;
-                    return true;
-            }
-        };
-
-    public:
-        bool hasFilters() const {
-            return !m_filters.empty();
-        }
-        bool matches( TestCaseInfo const& testCase ) const {
-            // A TestSpec matches if any filter matches
-            for( std::vector<Filter>::const_iterator it = m_filters.begin(), itEnd = m_filters.end(); it != itEnd; ++it )
-                if( it->matches( testCase ) )
-                    return true;
-            return false;
-        }
-
-    private:
-        std::vector<Filter> m_filters;
-
-        friend class TestSpecParser;
-    };
-}
-
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-
-namespace Catch {
-
-    class TestSpecParser {
-        enum Mode{ None, Name, QuotedName, Tag };
-        Mode m_mode;
-        bool m_exclusion;
-        std::size_t m_start, m_pos;
-        std::string m_arg;
-        TestSpec::Filter m_currentFilter;
-        TestSpec m_testSpec;
-        ITagAliasRegistry const* m_tagAliases;
-
-    public:
-        TestSpecParser( ITagAliasRegistry const& tagAliases ) : m_tagAliases( &tagAliases ) {}
-
-        TestSpecParser& parse( std::string const& arg ) {
-            m_mode = None;
-            m_exclusion = false;
-            m_start = std::string::npos;
-            m_arg = m_tagAliases->expandAliases( arg );
-            for( m_pos = 0; m_pos < m_arg.size(); ++m_pos )
-                visitChar( m_arg[m_pos] );
-            if( m_mode == Name )
-                addPattern<TestSpec::NamePattern>();
-            return *this;
-        }
-        TestSpec testSpec() {
-            addFilter();
-            return m_testSpec;
-        }
-    private:
-        void visitChar( char c ) {
-            if( m_mode == None ) {
-                switch( c ) {
-                case ' ': return;
-                case '~': m_exclusion = true; return;
-                case '[': return startNewMode( Tag, ++m_pos );
-                case '"': return startNewMode( QuotedName, ++m_pos );
-                default: startNewMode( Name, m_pos ); break;
-                }
-            }
-            if( m_mode == Name ) {
-                if( c == ',' ) {
-                    addPattern<TestSpec::NamePattern>();
-                    addFilter();
-                }
-                else if( c == '[' ) {
-                    if( subString() == "exclude:" )
-                        m_exclusion = true;
-                    else
-                        addPattern<TestSpec::NamePattern>();
-                    startNewMode( Tag, ++m_pos );
-                }
-            }
-            else if( m_mode == QuotedName && c == '"' )
-                addPattern<TestSpec::NamePattern>();
-            else if( m_mode == Tag && c == ']' )
-                addPattern<TestSpec::TagPattern>();
-        }
-        void startNewMode( Mode mode, std::size_t start ) {
-            m_mode = mode;
-            m_start = start;
-        }
-        std::string subString() const { return m_arg.substr( m_start, m_pos - m_start ); }
-        template<typename T>
-        void addPattern() {
-            std::string token = subString();
-            if( startsWith( token, "exclude:" ) ) {
-                m_exclusion = true;
-                token = token.substr( 8 );
-            }
-            if( !token.empty() ) {
-                Ptr<TestSpec::Pattern> pattern = new T( token );
-                if( m_exclusion )
-                    pattern = new TestSpec::ExcludedPattern( pattern );
-                m_currentFilter.m_patterns.push_back( pattern );
-            }
-            m_exclusion = false;
-            m_mode = None;
-        }
-        void addFilter() {
-            if( !m_currentFilter.m_patterns.empty() ) {
-                m_testSpec.m_filters.push_back( m_currentFilter );
-                m_currentFilter = TestSpec::Filter();
-            }
-        }
-    };
-    inline TestSpec parseTestSpec( std::string const& arg ) {
-        return TestSpecParser( ITagAliasRegistry::get() ).parse( arg ).testSpec();
-    }
-
-} // namespace Catch
-
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-
-// #included from: catch_interfaces_config.h
-#define TWOBLUECUBES_CATCH_INTERFACES_CONFIG_H_INCLUDED
-
-#include <iostream>
-#include <string>
-#include <vector>
-
-namespace Catch {
-
-    struct Verbosity { enum Level {
-        NoOutput = 0,
-        Quiet,
-        Normal
-    }; };
-
-    struct WarnAbout { enum What {
-        Nothing = 0x00,
-        NoAssertions = 0x01
-    }; };
-
-    struct ShowDurations { enum OrNot {
-        DefaultForReporter,
-        Always,
-        Never
-    }; };
-    struct RunTests { enum InWhatOrder {
-        InDeclarationOrder,
-        InLexicographicalOrder,
-        InRandomOrder
-    }; };
-
-    class TestSpec;
-
-    struct IConfig : IShared {
-
-        virtual ~IConfig();
-
-        virtual bool allowThrows() const = 0;
-        virtual std::ostream& stream() const = 0;
-        virtual std::string name() const = 0;
-        virtual bool includeSuccessfulResults() const = 0;
-        virtual bool shouldDebugBreak() const = 0;
-        virtual bool warnAboutMissingAssertions() const = 0;
-        virtual int abortAfter() const = 0;
-        virtual bool showInvisibles() const = 0;
-        virtual ShowDurations::OrNot showDurations() const = 0;
-        virtual TestSpec const& testSpec() const = 0;
-        virtual RunTests::InWhatOrder runOrder() const = 0;
-        virtual unsigned int rngSeed() const = 0;
-    };
-}
-
-// #included from: catch_stream.h
-#define TWOBLUECUBES_CATCH_STREAM_H_INCLUDED
-
-#include <streambuf>
-
-#ifdef __clang__
-#pragma clang diagnostic ignored "-Wpadded"
-#endif
-
-namespace Catch {
-
-    class Stream {
-    public:
-        Stream();
-        Stream( std::streambuf* _streamBuf, bool _isOwned );
-        void release();
-
-        std::streambuf* streamBuf;
-
-    private:
-        bool isOwned;
-    };
-
-    std::ostream& cout();
-    std::ostream& cerr();
-}
-
-#include <memory>
-#include <vector>
-#include <string>
-#include <iostream>
-#include <ctime>
-
-#ifndef CATCH_CONFIG_CONSOLE_WIDTH
-#define CATCH_CONFIG_CONSOLE_WIDTH 80
-#endif
-
-namespace Catch {
-
-    struct ConfigData {
-
-        ConfigData()
-        :   listTests( false ),
-            listTags( false ),
-            listReporters( false ),
-            listTestNamesOnly( false ),
-            showSuccessfulTests( false ),
-            shouldDebugBreak( false ),
-            noThrow( false ),
-            showHelp( false ),
-            showInvisibles( false ),
-            abortAfter( -1 ),
-            rngSeed( 0 ),
-            verbosity( Verbosity::Normal ),
-            warnings( WarnAbout::Nothing ),
-            showDurations( ShowDurations::DefaultForReporter ),
-            runOrder( RunTests::InDeclarationOrder )
-        {}
-
-        bool listTests;
-        bool listTags;
-        bool listReporters;
-        bool listTestNamesOnly;
-
-        bool showSuccessfulTests;
-        bool shouldDebugBreak;
-        bool noThrow;
-        bool showHelp;
-        bool showInvisibles;
-
-        int abortAfter;
-        unsigned int rngSeed;
-
-        Verbosity::Level verbosity;
-        WarnAbout::What warnings;
-        ShowDurations::OrNot showDurations;
-        RunTests::InWhatOrder runOrder;
-
-        std::string reporterName;
-        std::string outputFilename;
-        std::string name;
-        std::string processName;
-
-        std::vector<std::string> testsOrTags;
-    };
-
-    class Config : public SharedImpl<IConfig> {
-    private:
-        Config( Config const& other );
-        Config& operator = ( Config const& other );
-        virtual void dummy();
-    public:
-
-        Config()
-        :   m_os( Catch::cout().rdbuf() )
-        {}
-
-        Config( ConfigData const& data )
-        :   m_data( data ),
-            m_os( Catch::cout().rdbuf() )
-        {
-            if( !data.testsOrTags.empty() ) {
-                TestSpecParser parser( ITagAliasRegistry::get() );
-                for( std::size_t i = 0; i < data.testsOrTags.size(); ++i )
-                    parser.parse( data.testsOrTags[i] );
-                m_testSpec = parser.testSpec();
-            }
-        }
-
-        virtual ~Config() {
-            m_os.rdbuf( Catch::cout().rdbuf() );
-            m_stream.release();
-        }
-
-        void setFilename( std::string const& filename ) {
-            m_data.outputFilename = filename;
-        }
-
-        std::string const& getFilename() const {
-            return m_data.outputFilename ;
-        }
-
-        bool listTests() const { return m_data.listTests; }
-        bool listTestNamesOnly() const { return m_data.listTestNamesOnly; }
-        bool listTags() const { return m_data.listTags; }
-        bool listReporters() const { return m_data.listReporters; }
-
-        std::string getProcessName() const { return m_data.processName; }
-
-        bool shouldDebugBreak() const { return m_data.shouldDebugBreak; }
-
-        void setStreamBuf( std::streambuf* buf ) {
-            m_os.rdbuf( buf ? buf : Catch::cout().rdbuf() );
-        }
-
-        void useStream( std::string const& streamName ) {
-            Stream stream = createStream( streamName );
-            setStreamBuf( stream.streamBuf );
-            m_stream.release();
-            m_stream = stream;
-        }
-
-        std::string getReporterName() const { return m_data.reporterName; }
-
-        int abortAfter() const { return m_data.abortAfter; }
-
-        TestSpec const& testSpec() const { return m_testSpec; }
-
-        bool showHelp() const { return m_data.showHelp; }
-        bool showInvisibles() const { return m_data.showInvisibles; }
-
-        // IConfig interface
-        virtual bool allowThrows() const        { return !m_data.noThrow; }
-        virtual std::ostream& stream() const    { return m_os; }
-        virtual std::string name() const        { return m_data.name.empty() ? m_data.processName : m_data.name; }
-        virtual bool includeSuccessfulResults() const   { return m_data.showSuccessfulTests; }
-        virtual bool warnAboutMissingAssertions() const { return m_data.warnings & WarnAbout::NoAssertions; }
-        virtual ShowDurations::OrNot showDurations() const { return m_data.showDurations; }
-        virtual RunTests::InWhatOrder runOrder() const  { return m_data.runOrder; }
-        virtual unsigned int rngSeed() const    { return m_data.rngSeed; }
-
-    private:
-        ConfigData m_data;
-
-        Stream m_stream;
-        mutable std::ostream m_os;
-        TestSpec m_testSpec;
-    };
-
-} // end namespace Catch
-
-// #included from: catch_clara.h
-#define TWOBLUECUBES_CATCH_CLARA_H_INCLUDED
-
-// Use Catch's value for console width (store Clara's off to the side, if present)
-#ifdef CLARA_CONFIG_CONSOLE_WIDTH
-#define CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH CLARA_CONFIG_CONSOLE_WIDTH
-#undef CLARA_CONFIG_CONSOLE_WIDTH
-#endif
-#define CLARA_CONFIG_CONSOLE_WIDTH CATCH_CONFIG_CONSOLE_WIDTH
-
-// Declare Clara inside the Catch namespace
-#define STITCH_CLARA_OPEN_NAMESPACE namespace Catch {
-// #included from: ../external/clara.h
-
-// Only use header guard if we are not using an outer namespace
-#if !defined(TWOBLUECUBES_CLARA_H_INCLUDED) || defined(STITCH_CLARA_OPEN_NAMESPACE)
-
-#ifndef STITCH_CLARA_OPEN_NAMESPACE
-#define TWOBLUECUBES_CLARA_H_INCLUDED
-#define STITCH_CLARA_OPEN_NAMESPACE
-#define STITCH_CLARA_CLOSE_NAMESPACE
-#else
-#define STITCH_CLARA_CLOSE_NAMESPACE }
-#endif
-
-#define STITCH_TBC_TEXT_FORMAT_OPEN_NAMESPACE STITCH_CLARA_OPEN_NAMESPACE
-
-// ----------- #included from tbc_text_format.h -----------
-
-// Only use header guard if we are not using an outer namespace
-#if !defined(TBC_TEXT_FORMAT_H_INCLUDED) || defined(STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE)
-#ifndef STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE
-#define TBC_TEXT_FORMAT_H_INCLUDED
-#endif
-
-#include <string>
-#include <vector>
-#include <sstream>
-
-// Use optional outer namespace
-#ifdef STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE
-namespace STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE {
-#endif
-
-namespace Tbc {
-
-#ifdef TBC_TEXT_FORMAT_CONSOLE_WIDTH
-    const unsigned int consoleWidth = TBC_TEXT_FORMAT_CONSOLE_WIDTH;
-#else
-    const unsigned int consoleWidth = 80;
-#endif
-
-    struct TextAttributes {
-        TextAttributes()
-        :   initialIndent( std::string::npos ),
-            indent( 0 ),
-            width( consoleWidth-1 ),
-            tabChar( '\t' )
-        {}
-
-        TextAttributes& setInitialIndent( std::size_t _value )  { initialIndent = _value; return *this; }
-        TextAttributes& setIndent( std::size_t _value )         { indent = _value; return *this; }
-        TextAttributes& setWidth( std::size_t _value )          { width = _value; return *this; }
-        TextAttributes& setTabChar( char _value )               { tabChar = _value; return *this; }
-
-        std::size_t initialIndent;  // indent of first line, or npos
-        std::size_t indent;         // indent of subsequent lines, or all if initialIndent is npos
-        std::size_t width;          // maximum width of text, including indent. Longer text will wrap
-        char tabChar;               // If this char is seen the indent is changed to current pos
-    };
-
-    class Text {
-    public:
-        Text( std::string const& _str, TextAttributes const& _attr = TextAttributes() )
-        : attr( _attr )
-        {
-            std::string wrappableChars = " [({.,/|\\-";
-            std::size_t indent = _attr.initialIndent != std::string::npos
-                ? _attr.initialIndent
-                : _attr.indent;
-            std::string remainder = _str;
-
-            while( !remainder.empty() ) {
-                if( lines.size() >= 1000 ) {
-                    lines.push_back( "... message truncated due to excessive size" );
-                    return;
-                }
-                std::size_t tabPos = std::string::npos;
-                std::size_t width = (std::min)( remainder.size(), _attr.width - indent );
-                std::size_t pos = remainder.find_first_of( '\n' );
-                if( pos <= width ) {
-                    width = pos;
-                }
-                pos = remainder.find_last_of( _attr.tabChar, width );
-                if( pos != std::string::npos ) {
-                    tabPos = pos;
-                    if( remainder[width] == '\n' )
-                        width--;
-                    remainder = remainder.substr( 0, tabPos ) + remainder.substr( tabPos+1 );
-                }
-
-                if( width == remainder.size() ) {
-                    spliceLine( indent, remainder, width );
-                }
-                else if( remainder[width] == '\n' ) {
-                    spliceLine( indent, remainder, width );
-                    if( width <= 1 || remainder.size() != 1 )
-                        remainder = remainder.substr( 1 );
-                    indent = _attr.indent;
-                }
-                else {
-                    pos = remainder.find_last_of( wrappableChars, width );
-                    if( pos != std::string::npos && pos > 0 ) {
-                        spliceLine( indent, remainder, pos );
-                        if( remainder[0] == ' ' )
-                            remainder = remainder.substr( 1 );
-                    }
-                    else {
-                        spliceLine( indent, remainder, width-1 );
-                        lines.back() += "-";
-                    }
-                    if( lines.size() == 1 )
-                        indent = _attr.indent;
-                    if( tabPos != std::string::npos )
-                        indent += tabPos;
-                }
-            }
-        }
-
-        void spliceLine( std::size_t _indent, std::string& _remainder, std::size_t _pos ) {
-            lines.push_back( std::string( _indent, ' ' ) + _remainder.substr( 0, _pos ) );
-            _remainder = _remainder.substr( _pos );
-        }
-
-        typedef std::vector<std::string>::const_iterator const_iterator;
-
-        const_iterator begin() const { return lines.begin(); }
-        const_iterator end() const { return lines.end(); }
-        std::string const& last() const { return lines.back(); }
-        std::size_t size() const { return lines.size(); }
-        std::string const& operator[]( std::size_t _index ) const { return lines[_index]; }
-        std::string toString() const {
-            std::ostringstream oss;
-            oss << *this;
-            return oss.str();
-        }
-
-        inline friend std::ostream& operator << ( std::ostream& _stream, Text const& _text ) {
-            for( Text::const_iterator it = _text.begin(), itEnd = _text.end();
-                it != itEnd; ++it ) {
-                if( it != _text.begin() )
-                    _stream << "\n";
-                _stream << *it;
-            }
-            return _stream;
-        }
-
-    private:
-        std::string str;
-        TextAttributes attr;
-        std::vector<std::string> lines;
-    };
-
-} // end namespace Tbc
-
-#ifdef STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE
-} // end outer namespace
-#endif
-
-#endif // TBC_TEXT_FORMAT_H_INCLUDED
-
-// ----------- end of #include from tbc_text_format.h -----------
-// ........... back in /Users/philnash/Dev/OSS/Clara/srcs/clara.h
-
-#undef STITCH_TBC_TEXT_FORMAT_OPEN_NAMESPACE
-
-#include <map>
-#include <algorithm>
-#include <stdexcept>
-#include <memory>
-
-// Use optional outer namespace
-#ifdef STITCH_CLARA_OPEN_NAMESPACE
-STITCH_CLARA_OPEN_NAMESPACE
-#endif
-
-namespace Clara {
-
-    struct UnpositionalTag {};
-
-    extern UnpositionalTag _;
-
-#ifdef CLARA_CONFIG_MAIN
-    UnpositionalTag _;
-#endif
-
-    namespace Detail {
-
-#ifdef CLARA_CONSOLE_WIDTH
-    const unsigned int consoleWidth = CLARA_CONFIG_CONSOLE_WIDTH;
-#else
-    const unsigned int consoleWidth = 80;
-#endif
-
-        using namespace Tbc;
-
-        inline bool startsWith( std::string const& str, std::string const& prefix ) {
-            return str.size() >= prefix.size() && str.substr( 0, prefix.size() ) == prefix;
-        }
-
-        template<typename T> struct RemoveConstRef{ typedef T type; };
-        template<typename T> struct RemoveConstRef<T&>{ typedef T type; };
-        template<typename T> struct RemoveConstRef<T const&>{ typedef T type; };
-        template<typename T> struct RemoveConstRef<T const>{ typedef T type; };
-
-        template<typename T>    struct IsBool       { static const bool value = false; };
-        template<>              struct IsBool<bool> { static const bool value = true; };
-
-        template<typename T>
-        void convertInto( std::string const& _source, T& _dest ) {
-            std::stringstream ss;
-            ss << _source;
-            ss >> _dest;
-            if( ss.fail() )
-                throw std::runtime_error( "Unable to convert " + _source + " to destination type" );
-        }
-        inline void convertInto( std::string const& _source, std::string& _dest ) {
-            _dest = _source;
-        }
-        inline void convertInto( std::string const& _source, bool& _dest ) {
-            std::string sourceLC = _source;
-            std::transform( sourceLC.begin(), sourceLC.end(), sourceLC.begin(), ::tolower );
-            if( sourceLC == "y" || sourceLC == "1" || sourceLC == "true" || sourceLC == "yes" || sourceLC == "on" )
-                _dest = true;
-            else if( sourceLC == "n" || sourceLC == "0" || sourceLC == "false" || sourceLC == "no" || sourceLC == "off" )
-                _dest = false;
-            else
-                throw std::runtime_error( "Expected a boolean value but did not recognise:\n  '" + _source + "'" );
-        }
-        inline void convertInto( bool _source, bool& _dest ) {
-            _dest = _source;
-        }
-        template<typename T>
-        inline void convertInto( bool, T& ) {
-            throw std::runtime_error( "Invalid conversion" );
-        }
-
-        template<typename ConfigT>
-        struct IArgFunction {
-            virtual ~IArgFunction() {}
-#  ifdef CATCH_CPP11_OR_GREATER
-            IArgFunction()                      = default;
-            IArgFunction( IArgFunction const& ) = default;
-#  endif
-            virtual void set( ConfigT& config, std::string const& value ) const = 0;
-            virtual void setFlag( ConfigT& config ) const = 0;
-            virtual bool takesArg() const = 0;
-            virtual IArgFunction* clone() const = 0;
-        };
-
-        template<typename ConfigT>
-        class BoundArgFunction {
-        public:
-            BoundArgFunction() : functionObj( NULL ) {}
-            BoundArgFunction( IArgFunction<ConfigT>* _functionObj ) : functionObj( _functionObj ) {}
-            BoundArgFunction( BoundArgFunction const& other ) : functionObj( other.functionObj ? other.functionObj->clone() : NULL ) {}
-            BoundArgFunction& operator = ( BoundArgFunction const& other ) {
-                IArgFunction<ConfigT>* newFunctionObj = other.functionObj ? other.functionObj->clone() : NULL;
-                delete functionObj;
-                functionObj = newFunctionObj;
-                return *this;
-            }
-            ~BoundArgFunction() { delete functionObj; }
-
-            void set( ConfigT& config, std::string const& value ) const {
-                functionObj->set( config, value );
-            }
-            void setFlag( ConfigT& config ) const {
-                functionObj->setFlag( config );
-            }
-            bool takesArg() const { return functionObj->takesArg(); }
-
-            bool isSet() const {
-                return functionObj != NULL;
-            }
-        private:
-            IArgFunction<ConfigT>* functionObj;
-        };
-
-        template<typename C>
-        struct NullBinder : IArgFunction<C>{
-            virtual void set( C&, std::string const& ) const {}
-            virtual void setFlag( C& ) const {}
-            virtual bool takesArg() const { return true; }
-            virtual IArgFunction<C>* clone() const { return new NullBinder( *this ); }
-        };
-
-        template<typename C, typename M>
-        struct BoundDataMember : IArgFunction<C>{
-            BoundDataMember( M C::* _member ) : member( _member ) {}
-            virtual void set( C& p, std::string const& stringValue ) const {
-                convertInto( stringValue, p.*member );
-            }
-            virtual void setFlag( C& p ) const {
-                convertInto( true, p.*member );
-            }
-            virtual bool takesArg() const { return !IsBool<M>::value; }
-            virtual IArgFunction<C>* clone() const { return new BoundDataMember( *this ); }
-            M C::* member;
-        };
-        template<typename C, typename M>
-        struct BoundUnaryMethod : IArgFunction<C>{
-            BoundUnaryMethod( void (C::*_member)( M ) ) : member( _member ) {}
-            virtual void set( C& p, std::string const& stringValue ) const {
-                typename RemoveConstRef<M>::type value;
-                convertInto( stringValue, value );
-                (p.*member)( value );
-            }
-            virtual void setFlag( C& p ) const {
-                typename RemoveConstRef<M>::type value;
-                convertInto( true, value );
-                (p.*member)( value );
-            }
-            virtual bool takesArg() const { return !IsBool<M>::value; }
-            virtual IArgFunction<C>* clone() const { return new BoundUnaryMethod( *this ); }
-            void (C::*member)( M );
-        };
-        template<typename C>
-        struct BoundNullaryMethod : IArgFunction<C>{
-            BoundNullaryMethod( void (C::*_member)() ) : member( _member ) {}
-            virtual void set( C& p, std::string const& stringValue ) const {
-                bool value;
-                convertInto( stringValue, value );
-                if( value )
-                    (p.*member)();
-            }
-            virtual void setFlag( C& p ) const {
-                (p.*member)();
-            }
-            virtual bool takesArg() const { return false; }
-            virtual IArgFunction<C>* clone() const { return new BoundNullaryMethod( *this ); }
-            void (C::*member)();
-        };
-
-        template<typename C>
-        struct BoundUnaryFunction : IArgFunction<C>{
-            BoundUnaryFunction( void (*_function)( C& ) ) : function( _function ) {}
-            virtual void set( C& obj, std::string const& stringValue ) const {
-                bool value;
-                convertInto( stringValue, value );
-                if( value )
-                    function( obj );
-            }
-            virtual void setFlag( C& p ) const {
-                function( p );
-            }
-            virtual bool takesArg() const { return false; }
-            virtual IArgFunction<C>* clone() const { return new BoundUnaryFunction( *this ); }
-            void (*function)( C& );
-        };
-
-        template<typename C, typename T>
-        struct BoundBinaryFunction : IArgFunction<C>{
-            BoundBinaryFunction( void (*_function)( C&, T ) ) : function( _function ) {}
-            virtual void set( C& obj, std::string const& stringValue ) const {
-                typename RemoveConstRef<T>::type value;
-                convertInto( stringValue, value );
-                function( obj, value );
-            }
-            virtual void setFlag( C& obj ) const {
-                typename RemoveConstRef<T>::type value;
-                convertInto( true, value );
-                function( obj, value );
-            }
-            virtual bool takesArg() const { return !IsBool<T>::value; }
-            virtual IArgFunction<C>* clone() const { return new BoundBinaryFunction( *this ); }
-            void (*function)( C&, T );
-        };
-
-    } // namespace Detail
-
-    struct Parser {
-        Parser() : separators( " \t=:" ) {}
-
-        struct Token {
-            enum Type { Positional, ShortOpt, LongOpt };
-            Token( Type _type, std::string const& _data ) : type( _type ), data( _data ) {}
-            Type type;
-            std::string data;
-        };
-
-        void parseIntoTokens( int argc, char const * const * argv, std::vector<Parser::Token>& tokens ) const {
-            const std::string doubleDash = "--";
-            for( int i = 1; i < argc && argv[i] != doubleDash; ++i )
-                parseIntoTokens( argv[i] , tokens);
-        }
-        void parseIntoTokens( std::string arg, std::vector<Parser::Token>& tokens ) const {
-            while( !arg.empty() ) {
-                Parser::Token token( Parser::Token::Positional, arg );
-                arg = "";
-                if( token.data[0] == '-' ) {
-                    if( token.data.size() > 1 && token.data[1] == '-' ) {
-                        token = Parser::Token( Parser::Token::LongOpt, token.data.substr( 2 ) );
-                    }
-                    else {
-                        token = Parser::Token( Parser::Token::ShortOpt, token.data.substr( 1 ) );
-                        if( token.data.size() > 1 && separators.find( token.data[1] ) == std::string::npos ) {
-                            arg = "-" + token.data.substr( 1 );
-                            token.data = token.data.substr( 0, 1 );
-                        }
-                    }
-                }
-                if( token.type != Parser::Token::Positional ) {
-                    std::size_t pos = token.data.find_first_of( separators );
-                    if( pos != std::string::npos ) {
-                        arg = token.data.substr( pos+1 );
-                        token.data = token.data.substr( 0, pos );
-                    }
-                }
-                tokens.push_back( token );
-            }
-        }
-        std::string separators;
-    };
-
-    template<typename ConfigT>
-    struct CommonArgProperties {
-        CommonArgProperties() {}
-        CommonArgProperties( Detail::BoundArgFunction<ConfigT> const& _boundField ) : boundField( _boundField ) {}
-
-        Detail::BoundArgFunction<ConfigT> boundField;
-        std::string description;
-        std::string detail;
-        std::string placeholder; // Only value if boundField takes an arg
-
-        bool takesArg() const {
-            return !placeholder.empty();
-        }
-        void validate() const {
-            if( !boundField.isSet() )
-                throw std::logic_error( "option not bound" );
-        }
-    };
-    struct OptionArgProperties {
-        std::vector<std::string> shortNames;
-        std::string longName;
-
-        bool hasShortName( std::string const& shortName ) const {
-            return std::find( shortNames.begin(), shortNames.end(), shortName ) != shortNames.end();
-        }
-        bool hasLongName( std::string const& _longName ) const {
-            return _longName == longName;
-        }
-    };
-    struct PositionalArgProperties {
-        PositionalArgProperties() : position( -1 ) {}
-        int position; // -1 means non-positional (floating)
-
-        bool isFixedPositional() const {
-            return position != -1;
-        }
-    };
-
-    template<typename ConfigT>
-    class CommandLine {
-
-        struct Arg : CommonArgProperties<ConfigT>, OptionArgProperties, PositionalArgProperties {
-            Arg() {}
-            Arg( Detail::BoundArgFunction<ConfigT> const& _boundField ) : CommonArgProperties<ConfigT>( _boundField ) {}
-
-            using CommonArgProperties<ConfigT>::placeholder; // !TBD
-
-            std::string dbgName() const {
-                if( !longName.empty() )
-                    return "--" + longName;
-                if( !shortNames.empty() )
-                    return "-" + shortNames[0];
-                return "positional args";
-            }
-            std::string commands() const {
-                std::ostringstream oss;
-                bool first = true;
-                std::vector<std::string>::const_iterator it = shortNames.begin(), itEnd = shortNames.end();
-                for(; it != itEnd; ++it ) {
-                    if( first )
-                        first = false;
-                    else
-                        oss << ", ";
-                    oss << "-" << *it;
-                }
-                if( !longName.empty() ) {
-                    if( !first )
-                        oss << ", ";
-                    oss << "--" << longName;
-                }
-                if( !placeholder.empty() )
-                    oss << " <" << placeholder << ">";
-                return oss.str();
-            }
-        };
-
-        // NOTE: std::auto_ptr is deprecated in c++11/c++0x
-#if defined(__cplusplus) && __cplusplus > 199711L
-        typedef std::unique_ptr<Arg> ArgAutoPtr;
-#else
-        typedef std::auto_ptr<Arg> ArgAutoPtr;
-#endif
-
-        friend void addOptName( Arg& arg, std::string const& optName )
-        {
-            if( optName.empty() )
-                return;
-            if( Detail::startsWith( optName, "--" ) ) {
-                if( !arg.longName.empty() )
-                    throw std::logic_error( "Only one long opt may be specified. '"
-                        + arg.longName
-                        + "' already specified, now attempting to add '"
-                        + optName + "'" );
-                arg.longName = optName.substr( 2 );
-            }
-            else if( Detail::startsWith( optName, "-" ) )
-                arg.shortNames.push_back( optName.substr( 1 ) );
-            else
-                throw std::logic_error( "option must begin with - or --. Option was: '" + optName + "'" );
-        }
-        friend void setPositionalArg( Arg& arg, int position )
-        {
-            arg.position = position;
-        }
-
-        class ArgBuilder {
-        public:
-            ArgBuilder( Arg* arg ) : m_arg( arg ) {}
-
-            // Bind a non-boolean data member (requires placeholder string)
-            template<typename C, typename M>
-            void bind( M C::* field, std::string const& placeholder ) {
-                m_arg->boundField = new Detail::BoundDataMember<C,M>( field );
-                m_arg->placeholder = placeholder;
-            }
-            // Bind a boolean data member (no placeholder required)
-            template<typename C>
-            void bind( bool C::* field ) {
-                m_arg->boundField = new Detail::BoundDataMember<C,bool>( field );
-            }
-
-            // Bind a method taking a single, non-boolean argument (requires a placeholder string)
-            template<typename C, typename M>
-            void bind( void (C::* unaryMethod)( M ), std::string const& placeholder ) {
-                m_arg->boundField = new Detail::BoundUnaryMethod<C,M>( unaryMethod );
-                m_arg->placeholder = placeholder;
-            }
-
-            // Bind a method taking a single, boolean argument (no placeholder string required)
-            template<typename C>
-            void bind( void (C::* unaryMethod)( bool ) ) {
-                m_arg->boundField = new Detail::BoundUnaryMethod<C,bool>( unaryMethod );
-            }
-
-            // Bind a method that takes no arguments (will be called if opt is present)
-            template<typename C>
-            void bind( void (C::* nullaryMethod)() ) {
-                m_arg->boundField = new Detail::BoundNullaryMethod<C>( nullaryMethod );
-            }
-
-            // Bind a free function taking a single argument - the object to operate on (no placeholder string required)
-            template<typename C>
-            void bind( void (* unaryFunction)( C& ) ) {
-                m_arg->boundField = new Detail::BoundUnaryFunction<C>( unaryFunction );
-            }
-
-            // Bind a free function taking a single argument - the object to operate on (requires a placeholder string)
-            template<typename C, typename T>
-            void bind( void (* binaryFunction)( C&, T ), std::string const& placeholder ) {
-                m_arg->boundField = new Detail::BoundBinaryFunction<C, T>( binaryFunction );
-                m_arg->placeholder = placeholder;
-            }
-
-            ArgBuilder& describe( std::string const& description ) {
-                m_arg->description = description;
-                return *this;
-            }
-            ArgBuilder& detail( std::string const& detail ) {
-                m_arg->detail = detail;
-                return *this;
-            }
-
-        protected:
-            Arg* m_arg;
-        };
-
-        class OptBuilder : public ArgBuilder {
-        public:
-            OptBuilder( Arg* arg ) : ArgBuilder( arg ) {}
-            OptBuilder( OptBuilder& other ) : ArgBuilder( other ) {}
-
-            OptBuilder& operator[]( std::string const& optName ) {
-                addOptName( *ArgBuilder::m_arg, optName );
-                return *this;
-            }
-        };
-
-    public:
-
-        CommandLine()
-        :   m_boundProcessName( new Detail::NullBinder<ConfigT>() ),
-            m_highestSpecifiedArgPosition( 0 ),
-            m_throwOnUnrecognisedTokens( false )
-        {}
-        CommandLine( CommandLine const& other )
-        :   m_boundProcessName( other.m_boundProcessName ),
-            m_options ( other.m_options ),
-            m_positionalArgs( other.m_positionalArgs ),
-            m_highestSpecifiedArgPosition( other.m_highestSpecifiedArgPosition ),
-            m_throwOnUnrecognisedTokens( other.m_throwOnUnrecognisedTokens )
-        {
-            if( other.m_floatingArg.get() )
-                m_floatingArg.reset( new Arg( *other.m_floatingArg ) );
-        }
-
-        CommandLine& setThrowOnUnrecognisedTokens( bool shouldThrow = true ) {
-            m_throwOnUnrecognisedTokens = shouldThrow;
-            return *this;
-        }
-
-        OptBuilder operator[]( std::string const& optName ) {
-            m_options.push_back( Arg() );
-            addOptName( m_options.back(), optName );
-            OptBuilder builder( &m_options.back() );
-            return builder;
-        }
-
-        ArgBuilder operator[]( int position ) {
-            m_positionalArgs.insert( std::make_pair( position, Arg() ) );
-            if( position > m_highestSpecifiedArgPosition )
-                m_highestSpecifiedArgPosition = position;
-            setPositionalArg( m_positionalArgs[position], position );
-            ArgBuilder builder( &m_positionalArgs[position] );
-            return builder;
-        }
-
-        // Invoke this with the _ instance
-        ArgBuilder operator[]( UnpositionalTag ) {
-            if( m_floatingArg.get() )
-                throw std::logic_error( "Only one unpositional argument can be added" );
-            m_floatingArg.reset( new Arg() );
-            ArgBuilder builder( m_floatingArg.get() );
-            return builder;
-        }
-
-        template<typename C, typename M>
-        void bindProcessName( M C::* field ) {
-            m_boundProcessName = new Detail::BoundDataMember<C,M>( field );
-        }
-        template<typename C, typename M>
-        void bindProcessName( void (C::*_unaryMethod)( M ) ) {
-            m_boundProcessName = new Detail::BoundUnaryMethod<C,M>( _unaryMethod );
-        }
-
-        void optUsage( std::ostream& os, std::size_t indent = 0, std::size_t width = Detail::consoleWidth ) const {
-            typename std::vector<Arg>::const_iterator itBegin = m_options.begin(), itEnd = m_options.end(), it;
-            std::size_t maxWidth = 0;
-            for( it = itBegin; it != itEnd; ++it )
-                maxWidth = (std::max)( maxWidth, it->commands().size() );
-
-            for( it = itBegin; it != itEnd; ++it ) {
-                Detail::Text usage( it->commands(), Detail::TextAttributes()
-                                                        .setWidth( maxWidth+indent )
-                                                        .setIndent( indent ) );
-                Detail::Text desc( it->description, Detail::TextAttributes()
-                                                        .setWidth( width - maxWidth - 3 ) );
-
-                for( std::size_t i = 0; i < (std::max)( usage.size(), desc.size() ); ++i ) {
-                    std::string usageCol = i < usage.size() ? usage[i] : "";
-                    os << usageCol;
-
-                    if( i < desc.size() && !desc[i].empty() )
-                        os  << std::string( indent + 2 + maxWidth - usageCol.size(), ' ' )
-                            << desc[i];
-                    os << "\n";
-                }
-            }
-        }
-        std::string optUsage() const {
-            std::ostringstream oss;
-            optUsage( oss );
-            return oss.str();
-        }
-
-        void argSynopsis( std::ostream& os ) const {
-            for( int i = 1; i <= m_highestSpecifiedArgPosition; ++i ) {
-                if( i > 1 )
-                    os << " ";
-                typename std::map<int, Arg>::const_iterator it = m_positionalArgs.find( i );
-                if( it != m_positionalArgs.end() )
-                    os << "<" << it->second.placeholder << ">";
-                else if( m_floatingArg.get() )
-                    os << "<" << m_floatingArg->placeholder << ">";
-                else
-                    throw std::logic_error( "non consecutive positional arguments with no floating args" );
-            }
-            // !TBD No indication of mandatory args
-            if( m_floatingArg.get() ) {
-                if( m_highestSpecifiedArgPosition > 1 )
-                    os << " ";
-                os << "[<" << m_floatingArg->placeholder << "> ...]";
-            }
-        }
-        std::string argSynopsis() const {
-            std::ostringstream oss;
-            argSynopsis( oss );
-            return oss.str();
-        }
-
-        void usage( std::ostream& os, std::string const& procName ) const {
-            validate();
-            os << "usage:\n  " << procName << " ";
-            argSynopsis( os );
-            if( !m_options.empty() ) {
-                os << " [options]\n\nwhere options are: \n";
-                optUsage( os, 2 );
-            }
-            os << "\n";
-        }
-        std::string usage( std::string const& procName ) const {
-            std::ostringstream oss;
-            usage( oss, procName );
-            return oss.str();
-        }
-
-        ConfigT parse( int argc, char const * const * argv ) const {
-            ConfigT config;
-            parseInto( argc, argv, config );
-            return config;
-        }
-
-        std::vector<Parser::Token> parseInto( int argc, char const * const * argv, ConfigT& config ) const {
-            std::string processName = argv[0];
-            std::size_t lastSlash = processName.find_last_of( "/\\" );
-            if( lastSlash != std::string::npos )
-                processName = processName.substr( lastSlash+1 );
-            m_boundProcessName.set( config, processName );
-            std::vector<Parser::Token> tokens;
-            Parser parser;
-            parser.parseIntoTokens( argc, argv, tokens );
-            return populate( tokens, config );
-        }
-
-        std::vector<Parser::Token> populate( std::vector<Parser::Token> const& tokens, ConfigT& config ) const {
-            validate();
-            std::vector<Parser::Token> unusedTokens = populateOptions( tokens, config );
-            unusedTokens = populateFixedArgs( unusedTokens, config );
-            unusedTokens = populateFloatingArgs( unusedTokens, config );
-            return unusedTokens;
-        }
-
-        std::vector<Parser::Token> populateOptions( std::vector<Parser::Token> const& tokens, ConfigT& config ) const {
-            std::vector<Parser::Token> unusedTokens;
-            std::vector<std::string> errors;
-            for( std::size_t i = 0; i < tokens.size(); ++i ) {
-                Parser::Token const& token = tokens[i];
-                typename std::vector<Arg>::const_iterator it = m_options.begin(), itEnd = m_options.end();
-                for(; it != itEnd; ++it ) {
-                    Arg const& arg = *it;
-
-                    try {
-                        if( ( token.type == Parser::Token::ShortOpt && arg.hasShortName( token.data ) ) ||
-                            ( token.type == Parser::Token::LongOpt && arg.hasLongName( token.data ) ) ) {
-                            if( arg.takesArg() ) {
-                                if( i == tokens.size()-1 || tokens[i+1].type != Parser::Token::Positional )
-                                    errors.push_back( "Expected argument to option: " + token.data );
-                                else
-                                    arg.boundField.set( config, tokens[++i].data );
-                            }
-                            else {
-                                arg.boundField.setFlag( config );
-                            }
-                            break;
-                        }
-                    }
-                    catch( std::exception& ex ) {
-                        errors.push_back( std::string( ex.what() ) + "\n- while parsing: (" + arg.commands() + ")" );
-                    }
-                }
-                if( it == itEnd ) {
-                    if( token.type == Parser::Token::Positional || !m_throwOnUnrecognisedTokens )
-                        unusedTokens.push_back( token );
-                    else if( errors.empty() && m_throwOnUnrecognisedTokens )
-                        errors.push_back( "unrecognised option: " + token.data );
-                }
-            }
-            if( !errors.empty() ) {
-                std::ostringstream oss;
-                for( std::vector<std::string>::const_iterator it = errors.begin(), itEnd = errors.end();
-                        it != itEnd;
-                        ++it ) {
-                    if( it != errors.begin() )
-                        oss << "\n";
-                    oss << *it;
-                }
-                throw std::runtime_error( oss.str() );
-            }
-            return unusedTokens;
-        }
-        std::vector<Parser::Token> populateFixedArgs( std::vector<Parser::Token> const& tokens, ConfigT& config ) const {
-            std::vector<Parser::Token> unusedTokens;
-            int position = 1;
-            for( std::size_t i = 0; i < tokens.size(); ++i ) {
-                Parser::Token const& token = tokens[i];
-                typename std::map<int, Arg>::const_iterator it = m_positionalArgs.find( position );
-                if( it != m_positionalArgs.end() )
-                    it->second.boundField.set( config, token.data );
-                else
-                    unusedTokens.push_back( token );
-                if( token.type == Parser::Token::Positional )
-                    position++;
-            }
-            return unusedTokens;
-        }
-        std::vector<Parser::Token> populateFloatingArgs( std::vector<Parser::Token> const& tokens, ConfigT& config ) const {
-            if( !m_floatingArg.get() )
-                return tokens;
-            std::vector<Parser::Token> unusedTokens;
-            for( std::size_t i = 0; i < tokens.size(); ++i ) {
-                Parser::Token const& token = tokens[i];
-                if( token.type == Parser::Token::Positional )
-                    m_floatingArg->boundField.set( config, token.data );
-                else
-                    unusedTokens.push_back( token );
-            }
-            return unusedTokens;
-        }
-
-        void validate() const
-        {
-            if( m_options.empty() && m_positionalArgs.empty() && !m_floatingArg.get() )
-                throw std::logic_error( "No options or arguments specified" );
-
-            for( typename std::vector<Arg>::const_iterator  it = m_options.begin(),
-                                                            itEnd = m_options.end();
-                    it != itEnd; ++it )
-                it->validate();
-        }
-
-    private:
-        Detail::BoundArgFunction<ConfigT> m_boundProcessName;
-        std::vector<Arg> m_options;
-        std::map<int, Arg> m_positionalArgs;
-        ArgAutoPtr m_floatingArg;
-        int m_highestSpecifiedArgPosition;
-        bool m_throwOnUnrecognisedTokens;
-    };
-
-} // end namespace Clara
-
-STITCH_CLARA_CLOSE_NAMESPACE
-#undef STITCH_CLARA_OPEN_NAMESPACE
-#undef STITCH_CLARA_CLOSE_NAMESPACE
-
-#endif // TWOBLUECUBES_CLARA_H_INCLUDED
-#undef STITCH_CLARA_OPEN_NAMESPACE
-
-// Restore Clara's value for console width, if present
-#ifdef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
-#define CLARA_CONFIG_CONSOLE_WIDTH CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
-#undef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
-#endif
-
-#include <fstream>
-
-namespace Catch {
-
-    inline void abortAfterFirst( ConfigData& config ) { config.abortAfter = 1; }
-    inline void abortAfterX( ConfigData& config, int x ) {
-        if( x < 1 )
-            throw std::runtime_error( "Value after -x or --abortAfter must be greater than zero" );
-        config.abortAfter = x;
-    }
-    inline void addTestOrTags( ConfigData& config, std::string const& _testSpec ) { config.testsOrTags.push_back( _testSpec ); }
-
-    inline void addWarning( ConfigData& config, std::string const& _warning ) {
-        if( _warning == "NoAssertions" )
-            config.warnings = static_cast<WarnAbout::What>( config.warnings | WarnAbout::NoAssertions );
-        else
-            throw std::runtime_error( "Unrecognised warning: '" + _warning + "'" );
-    }
-    inline void setOrder( ConfigData& config, std::string const& order ) {
-        if( startsWith( "declared", order ) )
-            config.runOrder = RunTests::InDeclarationOrder;
-        else if( startsWith( "lexical", order ) )
-            config.runOrder = RunTests::InLexicographicalOrder;
-        else if( startsWith( "random", order ) )
-            config.runOrder = RunTests::InRandomOrder;
-        else
-            throw std::runtime_error( "Unrecognised ordering: '" + order + "'" );
-    }
-    inline void setRngSeed( ConfigData& config, std::string const& seed ) {
-        if( seed == "time" ) {
-            config.rngSeed = static_cast<unsigned int>( std::time(0) );
-        }
-        else {
-            std::stringstream ss;
-            ss << seed;
-            ss >> config.rngSeed;
-            if( ss.fail() )
-                throw std::runtime_error( "Argment to --rng-seed should be the word 'time' or a number" );
-        }
-    }
-    inline void setVerbosity( ConfigData& config, int level ) {
-        // !TBD: accept strings?
-        config.verbosity = static_cast<Verbosity::Level>( level );
-    }
-    inline void setShowDurations( ConfigData& config, bool _showDurations ) {
-        config.showDurations = _showDurations
-            ? ShowDurations::Always
-            : ShowDurations::Never;
-    }
-    inline void loadTestNamesFromFile( ConfigData& config, std::string const& _filename ) {
-        std::ifstream f( _filename.c_str() );
-        if( !f.is_open() )
-            throw std::domain_error( "Unable to load input file: " + _filename );
-
-        std::string line;
-        while( std::getline( f, line ) ) {
-            line = trim(line);
-            if( !line.empty() && !startsWith( line, "#" ) )
-                addTestOrTags( config, "\"" + line + "\"," );
-        }
-    }
-
-    inline Clara::CommandLine<ConfigData> makeCommandLineParser() {
-
-        using namespace Clara;
-        CommandLine<ConfigData> cli;
-
-        cli.bindProcessName( &ConfigData::processName );
-
-        cli["-?"]["-h"]["--help"]
-            .describe( "display usage information" )
-            .bind( &ConfigData::showHelp );
-
-        cli["-l"]["--list-tests"]
-            .describe( "list all/matching test cases" )
-            .bind( &ConfigData::listTests );
-
-        cli["-t"]["--list-tags"]
-            .describe( "list all/matching tags" )
-            .bind( &ConfigData::listTags );
-
-        cli["-s"]["--success"]
-            .describe( "include successful tests in output" )
-            .bind( &ConfigData::showSuccessfulTests );
-
-        cli["-b"]["--break"]
-            .describe( "break into debugger on failure" )
-            .bind( &ConfigData::shouldDebugBreak );
-
-        cli["-e"]["--nothrow"]
-            .describe( "skip exception tests" )
-            .bind( &ConfigData::noThrow );
-
-        cli["-i"]["--invisibles"]
-            .describe( "show invisibles (tabs, newlines)" )
-            .bind( &ConfigData::showInvisibles );
-
-        cli["-o"]["--out"]
-            .describe( "output filename" )
-            .bind( &ConfigData::outputFilename, "filename" );
-
-        cli["-r"]["--reporter"]
-//            .placeholder( "name[:filename]" )
-            .describe( "reporter to use (defaults to console)" )
-            .bind( &ConfigData::reporterName, "name" );
-
-        cli["-n"]["--name"]
-            .describe( "suite name" )
-            .bind( &ConfigData::name, "name" );
-
-        cli["-a"]["--abort"]
-            .describe( "abort at first failure" )
-            .bind( &abortAfterFirst );
-
-        cli["-x"]["--abortx"]
-            .describe( "abort after x failures" )
-            .bind( &abortAfterX, "no. failures" );
-
-        cli["-w"]["--warn"]
-            .describe( "enable warnings" )
-            .bind( &addWarning, "warning name" );
-
-// - needs updating if reinstated
-//        cli.into( &setVerbosity )
-//            .describe( "level of verbosity (0=no output)" )
-//            .shortOpt( "v")
-//            .longOpt( "verbosity" )
-//            .placeholder( "level" );
-
-        cli[_]
-            .describe( "which test or tests to use" )
-            .bind( &addTestOrTags, "test name, pattern or tags" );
-
-        cli["-d"]["--durations"]
-            .describe( "show test durations" )
-            .bind( &setShowDurations, "yes/no" );
-
-        cli["-f"]["--input-file"]
-            .describe( "load test names to run from a file" )
-            .bind( &loadTestNamesFromFile, "filename" );
-
-        // Less common commands which don't have a short form
-        cli["--list-test-names-only"]
-            .describe( "list all/matching test cases names only" )
-            .bind( &ConfigData::listTestNamesOnly );
-
-        cli["--list-reporters"]
-            .describe( "list all reporters" )
-            .bind( &ConfigData::listReporters );
-
-        cli["--order"]
-            .describe( "test case order (defaults to decl)" )
-            .bind( &setOrder, "decl|lex|rand" );
-
-        cli["--rng-seed"]
-            .describe( "set a specific seed for random numbers" )
-            .bind( &setRngSeed, "'time'|number" );
-
-        return cli;
-    }
-
-} // end namespace Catch
-
-// #included from: internal/catch_list.hpp
-#define TWOBLUECUBES_CATCH_LIST_HPP_INCLUDED
-
-// #included from: catch_text.h
-#define TWOBLUECUBES_CATCH_TEXT_H_INCLUDED
-
-#define TBC_TEXT_FORMAT_CONSOLE_WIDTH CATCH_CONFIG_CONSOLE_WIDTH
-
-#define CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE Catch
-// #included from: ../external/tbc_text_format.h
-// Only use header guard if we are not using an outer namespace
-#ifndef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE
-# ifdef TWOBLUECUBES_TEXT_FORMAT_H_INCLUDED
-#  ifndef TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED
-#   define TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED
-#  endif
-# else
-#  define TWOBLUECUBES_TEXT_FORMAT_H_INCLUDED
-# endif
-#endif
-#ifndef TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED
-#include <string>
-#include <vector>
-#include <sstream>
-
-// Use optional outer namespace
-#ifdef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE
-namespace CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE {
-#endif
-
-namespace Tbc {
-
-#ifdef TBC_TEXT_FORMAT_CONSOLE_WIDTH
-    const unsigned int consoleWidth = TBC_TEXT_FORMAT_CONSOLE_WIDTH;
-#else
-    const unsigned int consoleWidth = 80;
-#endif
-
-    struct TextAttributes {
-        TextAttributes()
-        :   initialIndent( std::string::npos ),
-            indent( 0 ),
-            width( consoleWidth-1 ),
-            tabChar( '\t' )
-        {}
-
-        TextAttributes& setInitialIndent( std::size_t _value )  { initialIndent = _value; return *this; }
-        TextAttributes& setIndent( std::size_t _value )         { indent = _value; return *this; }
-        TextAttributes& setWidth( std::size_t _value )          { width = _value; return *this; }
-        TextAttributes& setTabChar( char _value )               { tabChar = _value; return *this; }
-
-        std::size_t initialIndent;  // indent of first line, or npos
-        std::size_t indent;         // indent of subsequent lines, or all if initialIndent is npos
-        std::size_t width;          // maximum width of text, including indent. Longer text will wrap
-        char tabChar;               // If this char is seen the indent is changed to current pos
-    };
-
-    class Text {
-    public:
-        Text( std::string const& _str, TextAttributes const& _attr = TextAttributes() )
-        : attr( _attr )
-        {
-            std::string wrappableChars = " [({.,/|\\-";
-            std::size_t indent = _attr.initialIndent != std::string::npos
-                ? _attr.initialIndent
-                : _attr.indent;
-            std::string remainder = _str;
-
-            while( !remainder.empty() ) {
-                if( lines.size() >= 1000 ) {
-                    lines.push_back( "... message truncated due to excessive size" );
-                    return;
-                }
-                std::size_t tabPos = std::string::npos;
-                std::size_t width = (std::min)( remainder.size(), _attr.width - indent );
-                std::size_t pos = remainder.find_first_of( '\n' );
-                if( pos <= width ) {
-                    width = pos;
-                }
-                pos = remainder.find_last_of( _attr.tabChar, width );
-                if( pos != std::string::npos ) {
-                    tabPos = pos;
-                    if( remainder[width] == '\n' )
-                        width--;
-                    remainder = remainder.substr( 0, tabPos ) + remainder.substr( tabPos+1 );
-                }
-
-                if( width == remainder.size() ) {
-                    spliceLine( indent, remainder, width );
-                }
-                else if( remainder[width] == '\n' ) {
-                    spliceLine( indent, remainder, width );
-                    if( width <= 1 || remainder.size() != 1 )
-                        remainder = remainder.substr( 1 );
-                    indent = _attr.indent;
-                }
-                else {
-                    pos = remainder.find_last_of( wrappableChars, width );
-                    if( pos != std::string::npos && pos > 0 ) {
-                        spliceLine( indent, remainder, pos );
-                        if( remainder[0] == ' ' )
-                            remainder = remainder.substr( 1 );
-                    }
-                    else {
-                        spliceLine( indent, remainder, width-1 );
-                        lines.back() += "-";
-                    }
-                    if( lines.size() == 1 )
-                        indent = _attr.indent;
-                    if( tabPos != std::string::npos )
-                        indent += tabPos;
-                }
-            }
-        }
-
-        void spliceLine( std::size_t _indent, std::string& _remainder, std::size_t _pos ) {
-            lines.push_back( std::string( _indent, ' ' ) + _remainder.substr( 0, _pos ) );
-            _remainder = _remainder.substr( _pos );
-        }
-
-        typedef std::vector<std::string>::const_iterator const_iterator;
-
-        const_iterator begin() const { return lines.begin(); }
-        const_iterator end() const { return lines.end(); }
-        std::string const& last() const { return lines.back(); }
-        std::size_t size() const { return lines.size(); }
-        std::string const& operator[]( std::size_t _index ) const { return lines[_index]; }
-        std::string toString() const {
-            std::ostringstream oss;
-            oss << *this;
-            return oss.str();
-        }
-
-        inline friend std::ostream& operator << ( std::ostream& _stream, Text const& _text ) {
-            for( Text::const_iterator it = _text.begin(), itEnd = _text.end();
-                it != itEnd; ++it ) {
-                if( it != _text.begin() )
-                    _stream << "\n";
-                _stream << *it;
-            }
-            return _stream;
-        }
-
-    private:
-        std::string str;
-        TextAttributes attr;
-        std::vector<std::string> lines;
-    };
-
-} // end namespace Tbc
-
-#ifdef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE
-} // end outer namespace
-#endif
-
-#endif // TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED
-#undef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE
-
-namespace Catch {
-    using Tbc::Text;
-    using Tbc::TextAttributes;
-}
-
-// #included from: catch_console_colour.hpp
-#define TWOBLUECUBES_CATCH_CONSOLE_COLOUR_HPP_INCLUDED
-
-namespace Catch {
-
-    struct Colour {
-        enum Code {
-            None = 0,
-
-            White,
-            Red,
-            Green,
-            Blue,
-            Cyan,
-            Yellow,
-            Grey,
-
-            Bright = 0x10,
-
-            BrightRed = Bright | Red,
-            BrightGreen = Bright | Green,
-            LightGrey = Bright | Grey,
-            BrightWhite = Bright | White,
-
-            // By intention
-            FileName = LightGrey,
-            Warning = Yellow,
-            ResultError = BrightRed,
-            ResultSuccess = BrightGreen,
-            ResultExpectedFailure = Warning,
-
-            Error = BrightRed,
-            Success = Green,
-
-            OriginalExpression = Cyan,
-            ReconstructedExpression = Yellow,
-
-            SecondaryText = LightGrey,
-            Headers = White
-        };
-
-        // Use constructed object for RAII guard
-        Colour( Code _colourCode );
-        Colour( Colour const& other );
-        ~Colour();
-
-        // Use static method for one-shot changes
-        static void use( Code _colourCode );
-
-    private:
-        bool m_moved;
-    };
-
-    inline std::ostream& operator << ( std::ostream& os, Colour const& ) { return os; }
-
-} // end namespace Catch
-
-// #included from: catch_interfaces_reporter.h
-#define TWOBLUECUBES_CATCH_INTERFACES_REPORTER_H_INCLUDED
-
-#include <string>
-#include <ostream>
-#include <map>
-#include <assert.h>
-
-namespace Catch
-{
-    struct ReporterConfig {
-        explicit ReporterConfig( Ptr<IConfig> const& _fullConfig )
-        :   m_stream( &_fullConfig->stream() ), m_fullConfig( _fullConfig ) {}
-
-        ReporterConfig( Ptr<IConfig> const& _fullConfig, std::ostream& _stream )
-        :   m_stream( &_stream ), m_fullConfig( _fullConfig ) {}
-
-        std::ostream& stream() const    { return *m_stream; }
-        Ptr<IConfig> fullConfig() const { return m_fullConfig; }
-
-    private:
-        std::ostream* m_stream;
-        Ptr<IConfig> m_fullConfig;
-    };
-
-    struct ReporterPreferences {
-        ReporterPreferences()
-        : shouldRedirectStdOut( false )
-        {}
-
-        bool shouldRedirectStdOut;
-    };
-
-    template<typename T>
-    struct LazyStat : Option<T> {
-        LazyStat() : used( false ) {}
-        LazyStat& operator=( T const& _value ) {
-            Option<T>::operator=( _value );
-            used = false;
-            return *this;
-        }
-        void reset() {
-            Option<T>::reset();
-            used = false;
-        }
-        bool used;
-    };
-
-    struct TestRunInfo {
-        TestRunInfo( std::string const& _name ) : name( _name ) {}
-        std::string name;
-    };
-    struct GroupInfo {
-        GroupInfo(  std::string const& _name,
-                    std::size_t _groupIndex,
-                    std::size_t _groupsCount )
-        :   name( _name ),
-            groupIndex( _groupIndex ),
-            groupsCounts( _groupsCount )
-        {}
-
-        std::string name;
-        std::size_t groupIndex;
-        std::size_t groupsCounts;
-    };
-
-    struct AssertionStats {
-        AssertionStats( AssertionResult const& _assertionResult,
-                        std::vector<MessageInfo> const& _infoMessages,
-                        Totals const& _totals )
-        :   assertionResult( _assertionResult ),
-            infoMessages( _infoMessages ),
-            totals( _totals )
-        {
-            if( assertionResult.hasMessage() ) {
-                // Copy message into messages list.
-                // !TBD This should have been done earlier, somewhere
-                MessageBuilder builder( assertionResult.getTestMacroName(), assertionResult.getSourceInfo(), assertionResult.getResultType() );
-                builder << assertionResult.getMessage();
-                builder.m_info.message = builder.m_stream.str();
-
-                infoMessages.push_back( builder.m_info );
-            }
-        }
-        virtual ~AssertionStats();
-
-#  ifdef CATCH_CPP11_OR_GREATER
-        AssertionStats( AssertionStats const& )              = default;
-        AssertionStats( AssertionStats && )                  = default;
-        AssertionStats& operator = ( AssertionStats const& ) = default;
-        AssertionStats& operator = ( AssertionStats && )     = default;
-#  endif
-
-        AssertionResult assertionResult;
-        std::vector<MessageInfo> infoMessages;
-        Totals totals;
-    };
-
-    struct SectionStats {
-        SectionStats(   SectionInfo const& _sectionInfo,
-                        Counts const& _assertions,
-                        double _durationInSeconds,
-                        bool _missingAssertions )
-        :   sectionInfo( _sectionInfo ),
-            assertions( _assertions ),
-            durationInSeconds( _durationInSeconds ),
-            missingAssertions( _missingAssertions )
-        {}
-        virtual ~SectionStats();
-#  ifdef CATCH_CPP11_OR_GREATER
-        SectionStats( SectionStats const& )              = default;
-        SectionStats( SectionStats && )                  = default;
-        SectionStats& operator = ( SectionStats const& ) = default;
-        SectionStats& operator = ( SectionStats && )     = default;
-#  endif
-
-        SectionInfo sectionInfo;
-        Counts assertions;
-        double durationInSeconds;
-        bool missingAssertions;
-    };
-
-    struct TestCaseStats {
-        TestCaseStats(  TestCaseInfo const& _testInfo,
-                        Totals const& _totals,
-                        std::string const& _stdOut,
-                        std::string const& _stdErr,
-                        bool _aborting )
-        : testInfo( _testInfo ),
-            totals( _totals ),
-            stdOut( _stdOut ),
-            stdErr( _stdErr ),
-            aborting( _aborting )
-        {}
-        virtual ~TestCaseStats();
-
-#  ifdef CATCH_CPP11_OR_GREATER
-        TestCaseStats( TestCaseStats const& )              = default;
-        TestCaseStats( TestCaseStats && )                  = default;
-        TestCaseStats& operator = ( TestCaseStats const& ) = default;
-        TestCaseStats& operator = ( TestCaseStats && )     = default;
-#  endif
-
-        TestCaseInfo testInfo;
-        Totals totals;
-        std::string stdOut;
-        std::string stdErr;
-        bool aborting;
-    };
-
-    struct TestGroupStats {
-        TestGroupStats( GroupInfo const& _groupInfo,
-                        Totals const& _totals,
-                        bool _aborting )
-        :   groupInfo( _groupInfo ),
-            totals( _totals ),
-            aborting( _aborting )
-        {}
-        TestGroupStats( GroupInfo const& _groupInfo )
-        :   groupInfo( _groupInfo ),
-            aborting( false )
-        {}
-        virtual ~TestGroupStats();
-
-#  ifdef CATCH_CPP11_OR_GREATER
-        TestGroupStats( TestGroupStats const& )              = default;
-        TestGroupStats( TestGroupStats && )                  = default;
-        TestGroupStats& operator = ( TestGroupStats const& ) = default;
-        TestGroupStats& operator = ( TestGroupStats && )     = default;
-#  endif
-
-        GroupInfo groupInfo;
-        Totals totals;
-        bool aborting;
-    };
-
-    struct TestRunStats {
-        TestRunStats(   TestRunInfo const& _runInfo,
-                        Totals const& _totals,
-                        bool _aborting )
-        :   runInfo( _runInfo ),
-            totals( _totals ),
-            aborting( _aborting )
-        {}
-        virtual ~TestRunStats();
-
-#  ifndef CATCH_CPP11_OR_GREATER
-        TestRunStats( TestRunStats const& _other )
-        :   runInfo( _other.runInfo ),
-            totals( _other.totals ),
-            aborting( _other.aborting )
-        {}
-#  else
-        TestRunStats( TestRunStats const& )              = default;
-        TestRunStats( TestRunStats && )                  = default;
-        TestRunStats& operator = ( TestRunStats const& ) = default;
-        TestRunStats& operator = ( TestRunStats && )     = default;
-#  endif
-
-        TestRunInfo runInfo;
-        Totals totals;
-        bool aborting;
-    };
-
-    struct IStreamingReporter : IShared {
-        virtual ~IStreamingReporter();
-
-        // Implementing class must also provide the following static method:
-        // static std::string getDescription();
-
-        virtual ReporterPreferences getPreferences() const = 0;
-
-        virtual void noMatchingTestCases( std::string const& spec ) = 0;
-
-        virtual void testRunStarting( TestRunInfo const& testRunInfo ) = 0;
-        virtual void testGroupStarting( GroupInfo const& groupInfo ) = 0;
-
-        virtual void testCaseStarting( TestCaseInfo const& testInfo ) = 0;
-        virtual void sectionStarting( SectionInfo const& sectionInfo ) = 0;
-
-        virtual void assertionStarting( AssertionInfo const& assertionInfo ) = 0;
-
-        // The return value indicates if the messages buffer should be cleared:
-        virtual bool assertionEnded( AssertionStats const& assertionStats ) = 0;
-        virtual void sectionEnded( SectionStats const& sectionStats ) = 0;
-        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) = 0;
-        virtual void testGroupEnded( TestGroupStats const& testGroupStats ) = 0;
-        virtual void testRunEnded( TestRunStats const& testRunStats ) = 0;
-
-        virtual void skipTest( TestCaseInfo const& testInfo ) = 0;
-    };
-
-    struct IReporterFactory {
-        virtual ~IReporterFactory();
-        virtual IStreamingReporter* create( ReporterConfig const& config ) const = 0;
-        virtual std::string getDescription() const = 0;
-    };
-
-    struct IReporterRegistry {
-        typedef std::map<std::string, IReporterFactory*> FactoryMap;
-
-        virtual ~IReporterRegistry();
-        virtual IStreamingReporter* create( std::string const& name, Ptr<IConfig> const& config ) const = 0;
-        virtual FactoryMap const& getFactories() const = 0;
-    };
-
-}
-
-#include <limits>
-#include <algorithm>
-
-namespace Catch {
-
-    inline std::size_t listTests( Config const& config ) {
-
-        TestSpec testSpec = config.testSpec();
-        if( config.testSpec().hasFilters() )
-            Catch::cout() << "Matching test cases:\n";
-        else {
-            Catch::cout() << "All available test cases:\n";
-            testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "*" ).testSpec();
-        }
-
-        std::size_t matchedTests = 0;
-        TextAttributes nameAttr, tagsAttr;
-        nameAttr.setInitialIndent( 2 ).setIndent( 4 );
-        tagsAttr.setIndent( 6 );
-
-        std::vector<TestCase> matchedTestCases;
-        getRegistryHub().getTestCaseRegistry().getFilteredTests( testSpec, config, matchedTestCases );
-        for( std::vector<TestCase>::const_iterator it = matchedTestCases.begin(), itEnd = matchedTestCases.end();
-                it != itEnd;
-                ++it ) {
-            matchedTests++;
-            TestCaseInfo const& testCaseInfo = it->getTestCaseInfo();
-            Colour::Code colour = testCaseInfo.isHidden()
-                ? Colour::SecondaryText
-                : Colour::None;
-            Colour colourGuard( colour );
-
-            Catch::cout() << Text( testCaseInfo.name, nameAttr ) << std::endl;
-            if( !testCaseInfo.tags.empty() )
-                Catch::cout() << Text( testCaseInfo.tagsAsString, tagsAttr ) << std::endl;
-        }
-
-        if( !config.testSpec().hasFilters() )
-            Catch::cout() << pluralise( matchedTests, "test case" ) << "\n" << std::endl;
-        else
-            Catch::cout() << pluralise( matchedTests, "matching test case" ) << "\n" << std::endl;
-        return matchedTests;
-    }
-
-    inline std::size_t listTestsNamesOnly( Config const& config ) {
-        TestSpec testSpec = config.testSpec();
-        if( !config.testSpec().hasFilters() )
-            testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "*" ).testSpec();
-        std::size_t matchedTests = 0;
-        std::vector<TestCase> matchedTestCases;
-        getRegistryHub().getTestCaseRegistry().getFilteredTests( testSpec, config, matchedTestCases );
-        for( std::vector<TestCase>::const_iterator it = matchedTestCases.begin(), itEnd = matchedTestCases.end();
-                it != itEnd;
-                ++it ) {
-            matchedTests++;
-            TestCaseInfo const& testCaseInfo = it->getTestCaseInfo();
-            Catch::cout() << testCaseInfo.name << std::endl;
-        }
-        return matchedTests;
-    }
-
-    struct TagInfo {
-        TagInfo() : count ( 0 ) {}
-        void add( std::string const& spelling ) {
-            ++count;
-            spellings.insert( spelling );
-        }
-        std::string all() const {
-            std::string out;
-            for( std::set<std::string>::const_iterator it = spellings.begin(), itEnd = spellings.end();
-                        it != itEnd;
-                        ++it )
-                out += "[" + *it + "]";
-            return out;
-        }
-        std::set<std::string> spellings;
-        std::size_t count;
-    };
-
-    inline std::size_t listTags( Config const& config ) {
-        TestSpec testSpec = config.testSpec();
-        if( config.testSpec().hasFilters() )
-            Catch::cout() << "Tags for matching test cases:\n";
-        else {
-            Catch::cout() << "All available tags:\n";
-            testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "*" ).testSpec();
-        }
-
-        std::map<std::string, TagInfo> tagCounts;
-
-        std::vector<TestCase> matchedTestCases;
-        getRegistryHub().getTestCaseRegistry().getFilteredTests( testSpec, config, matchedTestCases );
-        for( std::vector<TestCase>::const_iterator it = matchedTestCases.begin(), itEnd = matchedTestCases.end();
-                it != itEnd;
-                ++it ) {
-            for( std::set<std::string>::const_iterator  tagIt = it->getTestCaseInfo().tags.begin(),
-                                                        tagItEnd = it->getTestCaseInfo().tags.end();
-                    tagIt != tagItEnd;
-                    ++tagIt ) {
-                std::string tagName = *tagIt;
-                std::string lcaseTagName = toLower( tagName );
-                std::map<std::string, TagInfo>::iterator countIt = tagCounts.find( lcaseTagName );
-                if( countIt == tagCounts.end() )
-                    countIt = tagCounts.insert( std::make_pair( lcaseTagName, TagInfo() ) ).first;
-                countIt->second.add( tagName );
-            }
-        }
-
-        for( std::map<std::string, TagInfo>::const_iterator countIt = tagCounts.begin(),
-                                                            countItEnd = tagCounts.end();
-                countIt != countItEnd;
-                ++countIt ) {
-            std::ostringstream oss;
-            oss << "  " << std::setw(2) << countIt->second.count << "  ";
-            Text wrapper( countIt->second.all(), TextAttributes()
-                                                    .setInitialIndent( 0 )
-                                                    .setIndent( oss.str().size() )
-                                                    .setWidth( CATCH_CONFIG_CONSOLE_WIDTH-10 ) );
-            Catch::cout() << oss.str() << wrapper << "\n";
-        }
-        Catch::cout() << pluralise( tagCounts.size(), "tag" ) << "\n" << std::endl;
-        return tagCounts.size();
-    }
-
-    inline std::size_t listReporters( Config const& /*config*/ ) {
-        Catch::cout() << "Available reporters:\n";
-        IReporterRegistry::FactoryMap const& factories = getRegistryHub().getReporterRegistry().getFactories();
-        IReporterRegistry::FactoryMap::const_iterator itBegin = factories.begin(), itEnd = factories.end(), it;
-        std::size_t maxNameLen = 0;
-        for(it = itBegin; it != itEnd; ++it )
-            maxNameLen = (std::max)( maxNameLen, it->first.size() );
-
-        for(it = itBegin; it != itEnd; ++it ) {
-            Text wrapper( it->second->getDescription(), TextAttributes()
-                                                        .setInitialIndent( 0 )
-                                                        .setIndent( 7+maxNameLen )
-                                                        .setWidth( CATCH_CONFIG_CONSOLE_WIDTH - maxNameLen-8 ) );
-            Catch::cout() << "  "
-                    << it->first
-                    << ":"
-                    << std::string( maxNameLen - it->first.size() + 2, ' ' )
-                    << wrapper << "\n";
-        }
-        Catch::cout() << std::endl;
-        return factories.size();
-    }
-
-    inline Option<std::size_t> list( Config const& config ) {
-        Option<std::size_t> listedCount;
-        if( config.listTests() )
-            listedCount = listedCount.valueOr(0) + listTests( config );
-        if( config.listTestNamesOnly() )
-            listedCount = listedCount.valueOr(0) + listTestsNamesOnly( config );
-        if( config.listTags() )
-            listedCount = listedCount.valueOr(0) + listTags( config );
-        if( config.listReporters() )
-            listedCount = listedCount.valueOr(0) + listReporters( config );
-        return listedCount;
-    }
-
-} // end namespace Catch
-
-// #included from: internal/catch_runner_impl.hpp
-#define TWOBLUECUBES_CATCH_RUNNER_IMPL_HPP_INCLUDED
-
-// #included from: catch_test_case_tracker.hpp
-#define TWOBLUECUBES_CATCH_TEST_CASE_TRACKER_HPP_INCLUDED
-
-#include <map>
-#include <string>
-#include <assert.h>
-
-namespace Catch {
-namespace SectionTracking {
-
-    class TrackedSection {
-
-        typedef std::map<std::string, TrackedSection> TrackedSections;
-
-    public:
-        enum RunState {
-            NotStarted,
-            Executing,
-            ExecutingChildren,
-            Completed
-        };
-
-        TrackedSection( std::string const& name, TrackedSection* parent )
-        :   m_name( name ), m_runState( NotStarted ), m_parent( parent )
-        {}
-
-        RunState runState() const { return m_runState; }
-
-        TrackedSection* findChild( std::string const& childName ) {
-            TrackedSections::iterator it = m_children.find( childName );
-            return it != m_children.end()
-                ? &it->second
-                : NULL;
-        }
-        TrackedSection* acquireChild( std::string const& childName ) {
-            if( TrackedSection* child = findChild( childName ) )
-                return child;
-            m_children.insert( std::make_pair( childName, TrackedSection( childName, this ) ) );
-            return findChild( childName );
-        }
-        void enter() {
-            if( m_runState == NotStarted )
-                m_runState = Executing;
-        }
-        void leave() {
-            for( TrackedSections::const_iterator it = m_children.begin(), itEnd = m_children.end();
-                    it != itEnd;
-                    ++it )
-                if( it->second.runState() != Completed ) {
-                    m_runState = ExecutingChildren;
-                    return;
-                }
-            m_runState = Completed;
-        }
-        TrackedSection* getParent() {
-            return m_parent;
-        }
-        bool hasChildren() const {
-            return !m_children.empty();
-        }
-
-    private:
-        std::string m_name;
-        RunState m_runState;
-        TrackedSections m_children;
-        TrackedSection* m_parent;
-
-    };
-
-    class TestCaseTracker {
-    public:
-        TestCaseTracker( std::string const& testCaseName )
-        :   m_testCase( testCaseName, NULL ),
-            m_currentSection( &m_testCase ),
-            m_completedASectionThisRun( false )
-        {}
-
-        bool enterSection( std::string const& name ) {
-            TrackedSection* child = m_currentSection->acquireChild( name );
-            if( m_completedASectionThisRun || child->runState() == TrackedSection::Completed )
-                return false;
-
-            m_currentSection = child;
-            m_currentSection->enter();
-            return true;
-        }
-        void leaveSection() {
-            m_currentSection->leave();
-            m_currentSection = m_currentSection->getParent();
-            assert( m_currentSection != NULL );
-            m_completedASectionThisRun = true;
-        }
-
-        bool currentSectionHasChildren() const {
-            return m_currentSection->hasChildren();
-        }
-        bool isCompleted() const {
-            return m_testCase.runState() == TrackedSection::Completed;
-        }
-
-        class Guard {
-        public:
-            Guard( TestCaseTracker& tracker ) : m_tracker( tracker ) {
-                m_tracker.enterTestCase();
-            }
-            ~Guard() {
-                m_tracker.leaveTestCase();
-            }
-        private:
-            Guard( Guard const& );
-            void operator = ( Guard const& );
-            TestCaseTracker& m_tracker;
-        };
-
-    private:
-        void enterTestCase() {
-            m_currentSection = &m_testCase;
-            m_completedASectionThisRun = false;
-            m_testCase.enter();
-        }
-        void leaveTestCase() {
-            m_testCase.leave();
-        }
-
-        TrackedSection m_testCase;
-        TrackedSection* m_currentSection;
-        bool m_completedASectionThisRun;
-    };
-
-} // namespace SectionTracking
-
-using SectionTracking::TestCaseTracker;
-
-} // namespace Catch
-
-// #included from: catch_fatal_condition.hpp
-#define TWOBLUECUBES_CATCH_FATAL_CONDITION_H_INCLUDED
-
-namespace Catch {
-
-    // Report the error condition then exit the process
-    inline void fatal( std::string const& message, int exitCode ) {
-        IContext& context = Catch::getCurrentContext();
-        IResultCapture* resultCapture = context.getResultCapture();
-        resultCapture->handleFatalErrorCondition( message );
-
-		if( Catch::alwaysTrue() ) // avoids "no return" warnings
-            exit( exitCode );
-    }
-
-} // namespace Catch
-
-#if defined ( CATCH_PLATFORM_WINDOWS ) /////////////////////////////////////////
-
-namespace Catch {
-
-    struct FatalConditionHandler {
-		void reset() {}
-	};
-
-} // namespace Catch
-
-#else // Not Windows - assumed to be POSIX compatible //////////////////////////
-
-#include <signal.h>
-
-namespace Catch {
-
-    struct SignalDefs { int id; const char* name; };
-    extern SignalDefs signalDefs[];
-    SignalDefs signalDefs[] = {
-            { SIGINT,  "SIGINT - Terminal interrupt signal" },
-            { SIGILL,  "SIGILL - Illegal instruction signal" },
-            { SIGFPE,  "SIGFPE - Floating point error signal" },
-            { SIGSEGV, "SIGSEGV - Segmentation violation signal" },
-            { SIGTERM, "SIGTERM - Termination request signal" },
-            { SIGABRT, "SIGABRT - Abort (abnormal termination) signal" }
-        };
-
-    struct FatalConditionHandler {
-
-        static void handleSignal( int sig ) {
-            for( std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i )
-                if( sig == signalDefs[i].id )
-                    fatal( signalDefs[i].name, -sig );
-            fatal( "<unknown signal>", -sig );
-        }
-
-        FatalConditionHandler() : m_isSet( true ) {
-            for( std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i )
-                signal( signalDefs[i].id, handleSignal );
-        }
-        ~FatalConditionHandler() {
-            reset();
-        }
-        void reset() {
-            if( m_isSet ) {
-                for( std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i )
-                    signal( signalDefs[i].id, SIG_DFL );
-                m_isSet = false;
-            }
-        }
-
-        bool m_isSet;
-    };
-
-} // namespace Catch
-
-#endif // not Windows
-
-#include <set>
-#include <string>
-
-namespace Catch {
-
-    class StreamRedirect {
-
-    public:
-        StreamRedirect( std::ostream& stream, std::string& targetString )
-        :   m_stream( stream ),
-            m_prevBuf( stream.rdbuf() ),
-            m_targetString( targetString )
-        {
-            stream.rdbuf( m_oss.rdbuf() );
-        }
-
-        ~StreamRedirect() {
-            m_targetString += m_oss.str();
-            m_stream.rdbuf( m_prevBuf );
-        }
-
-    private:
-        std::ostream& m_stream;
-        std::streambuf* m_prevBuf;
-        std::ostringstream m_oss;
-        std::string& m_targetString;
-    };
-
-    ///////////////////////////////////////////////////////////////////////////
-
-    class RunContext : public IResultCapture, public IRunner {
-
-        RunContext( RunContext const& );
-        void operator =( RunContext const& );
-
-    public:
-
-        explicit RunContext( Ptr<IConfig const> const& config, Ptr<IStreamingReporter> const& reporter )
-        :   m_runInfo( config->name() ),
-            m_context( getCurrentMutableContext() ),
-            m_activeTestCase( NULL ),
-            m_config( config ),
-            m_reporter( reporter ),
-            m_prevRunner( m_context.getRunner() ),
-            m_prevResultCapture( m_context.getResultCapture() ),
-            m_prevConfig( m_context.getConfig() )
-        {
-            m_context.setRunner( this );
-            m_context.setConfig( m_config );
-            m_context.setResultCapture( this );
-            m_reporter->testRunStarting( m_runInfo );
-        }
-
-        virtual ~RunContext() {
-            m_reporter->testRunEnded( TestRunStats( m_runInfo, m_totals, aborting() ) );
-            m_context.setRunner( m_prevRunner );
-            m_context.setConfig( NULL );
-            m_context.setResultCapture( m_prevResultCapture );
-            m_context.setConfig( m_prevConfig );
-        }
-
-        void testGroupStarting( std::string const& testSpec, std::size_t groupIndex, std::size_t groupsCount ) {
-            m_reporter->testGroupStarting( GroupInfo( testSpec, groupIndex, groupsCount ) );
-        }
-        void testGroupEnded( std::string const& testSpec, Totals const& totals, std::size_t groupIndex, std::size_t groupsCount ) {
-            m_reporter->testGroupEnded( TestGroupStats( GroupInfo( testSpec, groupIndex, groupsCount ), totals, aborting() ) );
-        }
-
-        Totals runTest( TestCase const& testCase ) {
-            Totals prevTotals = m_totals;
-
-            std::string redirectedCout;
-            std::string redirectedCerr;
-
-            TestCaseInfo testInfo = testCase.getTestCaseInfo();
-
-            m_reporter->testCaseStarting( testInfo );
-
-            m_activeTestCase = &testCase;
-            m_testCaseTracker = TestCaseTracker( testInfo.name );
-
-            do {
-                do {
-                    runCurrentTest( redirectedCout, redirectedCerr );
-                }
-                while( !m_testCaseTracker->isCompleted() && !aborting() );
-            }
-            while( getCurrentContext().advanceGeneratorsForCurrentTest() && !aborting() );
-
-            Totals deltaTotals = m_totals.delta( prevTotals );
-            m_totals.testCases += deltaTotals.testCases;
-            m_reporter->testCaseEnded( TestCaseStats(   testInfo,
-                                                        deltaTotals,
-                                                        redirectedCout,
-                                                        redirectedCerr,
-                                                        aborting() ) );
-
-            m_activeTestCase = NULL;
-            m_testCaseTracker.reset();
-
-            return deltaTotals;
-        }
-
-        Ptr<IConfig const> config() const {
-            return m_config;
-        }
-
-    private: // IResultCapture
-
-        virtual void assertionEnded( AssertionResult const& result ) {
-            if( result.getResultType() == ResultWas::Ok ) {
-                m_totals.assertions.passed++;
-            }
-            else if( !result.isOk() ) {
-                m_totals.assertions.failed++;
-            }
-
-            if( m_reporter->assertionEnded( AssertionStats( result, m_messages, m_totals ) ) )
-                m_messages.clear();
-
-            // Reset working state
-            m_lastAssertionInfo = AssertionInfo( "", m_lastAssertionInfo.lineInfo, "{Unknown expression after the reported line}" , m_lastAssertionInfo.resultDisposition );
-            m_lastResult = result;
-        }
-
-        virtual bool sectionStarted (
-            SectionInfo const& sectionInfo,
-            Counts& assertions
-        )
-        {
-            std::ostringstream oss;
-            oss << sectionInfo.name << "@" << sectionInfo.lineInfo;
-
-            if( !m_testCaseTracker->enterSection( oss.str() ) )
-                return false;
-
-            m_lastAssertionInfo.lineInfo = sectionInfo.lineInfo;
-
-            m_reporter->sectionStarting( sectionInfo );
-
-            assertions = m_totals.assertions;
-
-            return true;
-        }
-        bool testForMissingAssertions( Counts& assertions ) {
-            if( assertions.total() != 0 ||
-                    !m_config->warnAboutMissingAssertions() ||
-                    m_testCaseTracker->currentSectionHasChildren() )
-                return false;
-            m_totals.assertions.failed++;
-            assertions.failed++;
-            return true;
-        }
-
-        virtual void sectionEnded( SectionInfo const& info, Counts const& prevAssertions, double _durationInSeconds ) {
-            if( std::uncaught_exception() ) {
-                m_unfinishedSections.push_back( UnfinishedSections( info, prevAssertions, _durationInSeconds ) );
-                return;
-            }
-
-            Counts assertions = m_totals.assertions - prevAssertions;
-            bool missingAssertions = testForMissingAssertions( assertions );
-
-            m_testCaseTracker->leaveSection();
-
-            m_reporter->sectionEnded( SectionStats( info, assertions, _durationInSeconds, missingAssertions ) );
-            m_messages.clear();
-        }
-
-        virtual void pushScopedMessage( MessageInfo const& message ) {
-            m_messages.push_back( message );
-        }
-
-        virtual void popScopedMessage( MessageInfo const& message ) {
-            m_messages.erase( std::remove( m_messages.begin(), m_messages.end(), message ), m_messages.end() );
-        }
-
-        virtual std::string getCurrentTestName() const {
-            return m_activeTestCase
-                ? m_activeTestCase->getTestCaseInfo().name
-                : "";
-        }
-
-        virtual const AssertionResult* getLastResult() const {
-            return &m_lastResult;
-        }
-
-        virtual void handleFatalErrorCondition( std::string const& message ) {
-            ResultBuilder resultBuilder = makeUnexpectedResultBuilder();
-            resultBuilder.setResultType( ResultWas::FatalErrorCondition );
-            resultBuilder << message;
-            resultBuilder.captureExpression();
-
-            handleUnfinishedSections();
-
-            // Recreate section for test case (as we will lose the one that was in scope)
-            TestCaseInfo const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
-            SectionInfo testCaseSection( testCaseInfo.lineInfo, testCaseInfo.name, testCaseInfo.description );
-
-            Counts assertions;
-            assertions.failed = 1;
-            SectionStats testCaseSectionStats( testCaseSection, assertions, 0, false );
-            m_reporter->sectionEnded( testCaseSectionStats );
-
-            TestCaseInfo testInfo = m_activeTestCase->getTestCaseInfo();
-
-            Totals deltaTotals;
-            deltaTotals.testCases.failed = 1;
-            m_reporter->testCaseEnded( TestCaseStats(   testInfo,
-                                                        deltaTotals,
-                                                        "",
-                                                        "",
-                                                        false ) );
-            m_totals.testCases.failed++;
-            testGroupEnded( "", m_totals, 1, 1 );
-            m_reporter->testRunEnded( TestRunStats( m_runInfo, m_totals, false ) );
-        }
-
-    public:
-        // !TBD We need to do this another way!
-        bool aborting() const {
-            return m_totals.assertions.failed == static_cast<std::size_t>( m_config->abortAfter() );
-        }
-
-    private:
-
-        void runCurrentTest( std::string& redirectedCout, std::string& redirectedCerr ) {
-            TestCaseInfo const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
-            SectionInfo testCaseSection( testCaseInfo.lineInfo, testCaseInfo.name, testCaseInfo.description );
-            m_reporter->sectionStarting( testCaseSection );
-            Counts prevAssertions = m_totals.assertions;
-            double duration = 0;
-            try {
-                m_lastAssertionInfo = AssertionInfo( "TEST_CASE", testCaseInfo.lineInfo, "", ResultDisposition::Normal );
-                TestCaseTracker::Guard guard( *m_testCaseTracker );
-
-                Timer timer;
-                timer.start();
-                if( m_reporter->getPreferences().shouldRedirectStdOut ) {
-                    StreamRedirect coutRedir( Catch::cout(), redirectedCout );
-                    StreamRedirect cerrRedir( Catch::cerr(), redirectedCerr );
-                    invokeActiveTestCase();
-                }
-                else {
-                    invokeActiveTestCase();
-                }
-                duration = timer.getElapsedSeconds();
-            }
-            catch( TestFailureException& ) {
-                // This just means the test was aborted due to failure
-            }
-            catch(...) {
-                makeUnexpectedResultBuilder().useActiveException();
-            }
-            handleUnfinishedSections();
-            m_messages.clear();
-
-            Counts assertions = m_totals.assertions - prevAssertions;
-            bool missingAssertions = testForMissingAssertions( assertions );
-
-            if( testCaseInfo.okToFail() ) {
-                std::swap( assertions.failedButOk, assertions.failed );
-                m_totals.assertions.failed -= assertions.failedButOk;
-                m_totals.assertions.failedButOk += assertions.failedButOk;
-            }
-
-            SectionStats testCaseSectionStats( testCaseSection, assertions, duration, missingAssertions );
-            m_reporter->sectionEnded( testCaseSectionStats );
-        }
-
-        void invokeActiveTestCase() {
-            FatalConditionHandler fatalConditionHandler; // Handle signals
-            m_activeTestCase->invoke();
-            fatalConditionHandler.reset();
-        }
-
-    private:
-
-        ResultBuilder makeUnexpectedResultBuilder() const {
-            return ResultBuilder(   m_lastAssertionInfo.macroName.c_str(),
-                                    m_lastAssertionInfo.lineInfo,
-                                    m_lastAssertionInfo.capturedExpression.c_str(),
-                                    m_lastAssertionInfo.resultDisposition );
-        }
-
-        void handleUnfinishedSections() {
-            // If sections ended prematurely due to an exception we stored their
-            // infos here so we can tear them down outside the unwind process.
-            for( std::vector<UnfinishedSections>::const_reverse_iterator it = m_unfinishedSections.rbegin(),
-                        itEnd = m_unfinishedSections.rend();
-                    it != itEnd;
-                    ++it )
-                sectionEnded( it->info, it->prevAssertions, it->durationInSeconds );
-            m_unfinishedSections.clear();
-        }
-
-        struct UnfinishedSections {
-            UnfinishedSections( SectionInfo const& _info, Counts const& _prevAssertions, double _durationInSeconds )
-            : info( _info ), prevAssertions( _prevAssertions ), durationInSeconds( _durationInSeconds )
-            {}
-
-            SectionInfo info;
-            Counts prevAssertions;
-            double durationInSeconds;
-        };
-
-        TestRunInfo m_runInfo;
-        IMutableContext& m_context;
-        TestCase const* m_activeTestCase;
-        Option<TestCaseTracker> m_testCaseTracker;
-        AssertionResult m_lastResult;
-
-        Ptr<IConfig const> m_config;
-        Totals m_totals;
-        Ptr<IStreamingReporter> m_reporter;
-        std::vector<MessageInfo> m_messages;
-        IRunner* m_prevRunner;
-        IResultCapture* m_prevResultCapture;
-        Ptr<IConfig const> m_prevConfig;
-        AssertionInfo m_lastAssertionInfo;
-        std::vector<UnfinishedSections> m_unfinishedSections;
-    };
-
-    IResultCapture& getResultCapture() {
-        if( IResultCapture* capture = getCurrentContext().getResultCapture() )
-            return *capture;
-        else
-            throw std::logic_error( "No result capture instance" );
-    }
-
-} // end namespace Catch
-
-// #included from: internal/catch_version.h
-#define TWOBLUECUBES_CATCH_VERSION_H_INCLUDED
-
-namespace Catch {
-
-    // Versioning information
-    struct Version {
-        Version(    unsigned int _majorVersion,
-                    unsigned int _minorVersion,
-                    unsigned int _buildNumber,
-                    char const* const _branchName )
-        :   majorVersion( _majorVersion ),
-            minorVersion( _minorVersion ),
-            buildNumber( _buildNumber ),
-            branchName( _branchName )
-        {}
-
-        unsigned int const majorVersion;
-        unsigned int const minorVersion;
-        unsigned int const buildNumber;
-        char const* const branchName;
-
-    private:
-        void operator=( Version const& );
-    };
-
-    extern Version libraryVersion;
-}
-
-#include <fstream>
-#include <stdlib.h>
-#include <limits>
-
-namespace Catch {
-
-    class Runner {
-
-    public:
-        Runner( Ptr<Config> const& config )
-        :   m_config( config )
-        {
-            openStream();
-            makeReporter();
-        }
-
-        Totals runTests() {
-
-            RunContext context( m_config.get(), m_reporter );
-
-            Totals totals;
-
-            context.testGroupStarting( "all tests", 1, 1 ); // deprecated?
-
-            TestSpec testSpec = m_config->testSpec();
-            if( !testSpec.hasFilters() )
-                testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "~[.]" ).testSpec(); // All not hidden tests
-
-            std::vector<TestCase> testCases;
-            getRegistryHub().getTestCaseRegistry().getFilteredTests( testSpec, *m_config, testCases );
-
-            int testsRunForGroup = 0;
-            for( std::vector<TestCase>::const_iterator it = testCases.begin(), itEnd = testCases.end();
-                    it != itEnd;
-                    ++it ) {
-                testsRunForGroup++;
-                if( m_testsAlreadyRun.find( *it ) == m_testsAlreadyRun.end() ) {
-
-                    if( context.aborting() )
-                        break;
-
-                    totals += context.runTest( *it );
-                    m_testsAlreadyRun.insert( *it );
-                }
-            }
-            std::vector<TestCase> skippedTestCases;
-            getRegistryHub().getTestCaseRegistry().getFilteredTests( testSpec, *m_config, skippedTestCases, true );
-
-            for( std::vector<TestCase>::const_iterator it = skippedTestCases.begin(), itEnd = skippedTestCases.end();
-                    it != itEnd;
-                    ++it )
-                m_reporter->skipTest( *it );
-
-            context.testGroupEnded( "all tests", totals, 1, 1 );
-            return totals;
-        }
-
-    private:
-        void openStream() {
-            // Open output file, if specified
-            if( !m_config->getFilename().empty() ) {
-                m_ofs.open( m_config->getFilename().c_str() );
-                if( m_ofs.fail() ) {
-                    std::ostringstream oss;
-                    oss << "Unable to open file: '" << m_config->getFilename() << "'";
-                    throw std::domain_error( oss.str() );
-                }
-                m_config->setStreamBuf( m_ofs.rdbuf() );
-            }
-        }
-        void makeReporter() {
-            std::string reporterName = m_config->getReporterName().empty()
-                ? "console"
-                : m_config->getReporterName();
-
-            m_reporter = getRegistryHub().getReporterRegistry().create( reporterName, m_config.get() );
-            if( !m_reporter ) {
-                std::ostringstream oss;
-                oss << "No reporter registered with name: '" << reporterName << "'";
-                throw std::domain_error( oss.str() );
-            }
-        }
-
-    private:
-        Ptr<Config> m_config;
-        std::ofstream m_ofs;
-        Ptr<IStreamingReporter> m_reporter;
-        std::set<TestCase> m_testsAlreadyRun;
-    };
-
-    class Session : NonCopyable {
-        static bool alreadyInstantiated;
-
-    public:
-
-        struct OnUnusedOptions { enum DoWhat { Ignore, Fail }; };
-
-        Session()
-        : m_cli( makeCommandLineParser() ) {
-            if( alreadyInstantiated ) {
-                std::string msg = "Only one instance of Catch::Session can ever be used";
-                Catch::cerr() << msg << std::endl;
-                throw std::logic_error( msg );
-            }
-            alreadyInstantiated = true;
-        }
-        ~Session() {
-            Catch::cleanUp();
-        }
-
-        void showHelp( std::string const& processName ) {
-            Catch::cout() << "\nCatch v"    << libraryVersion.majorVersion << "."
-                                        << libraryVersion.minorVersion << " build "
-                                        << libraryVersion.buildNumber;
-            if( libraryVersion.branchName != std::string( "master" ) )
-                Catch::cout() << " (" << libraryVersion.branchName << " branch)";
-            Catch::cout() << "\n";
-
-            m_cli.usage( Catch::cout(), processName );
-            Catch::cout() << "For more detail usage please see the project docs\n" << std::endl;
-        }
-
-        int applyCommandLine( int argc, char* const argv[], OnUnusedOptions::DoWhat unusedOptionBehaviour = OnUnusedOptions::Fail ) {
-            try {
-                m_cli.setThrowOnUnrecognisedTokens( unusedOptionBehaviour == OnUnusedOptions::Fail );
-                m_unusedTokens = m_cli.parseInto( argc, argv, m_configData );
-                if( m_configData.showHelp )
-                    showHelp( m_configData.processName );
-                m_config.reset();
-            }
-            catch( std::exception& ex ) {
-                {
-                    Colour colourGuard( Colour::Red );
-                    Catch::cerr()   << "\nError(s) in input:\n"
-                                << Text( ex.what(), TextAttributes().setIndent(2) )
-                                << "\n\n";
-                }
-                m_cli.usage( Catch::cout(), m_configData.processName );
-                return (std::numeric_limits<int>::max)();
-            }
-            return 0;
-        }
-
-        void useConfigData( ConfigData const& _configData ) {
-            m_configData = _configData;
-            m_config.reset();
-        }
-
-        int run( int argc, char* const argv[] ) {
-
-            int returnCode = applyCommandLine( argc, argv );
-            if( returnCode == 0 )
-                returnCode = run();
-            return returnCode;
-        }
-
-        int run() {
-            if( m_configData.showHelp )
-                return 0;
-
-            try
-            {
-                config(); // Force config to be constructed
-
-                std::srand( m_configData.rngSeed );
-
-                Runner runner( m_config );
-
-                // Handle list request
-                if( Option<std::size_t> listed = list( config() ) )
-                    return static_cast<int>( *listed );
-
-                return static_cast<int>( runner.runTests().assertions.failed );
-            }
-            catch( std::exception& ex ) {
-                Catch::cerr() << ex.what() << std::endl;
-                return (std::numeric_limits<int>::max)();
-            }
-        }
-
-        Clara::CommandLine<ConfigData> const& cli() const {
-            return m_cli;
-        }
-        std::vector<Clara::Parser::Token> const& unusedTokens() const {
-            return m_unusedTokens;
-        }
-        ConfigData& configData() {
-            return m_configData;
-        }
-        Config& config() {
-            if( !m_config )
-                m_config = new Config( m_configData );
-            return *m_config;
-        }
-
-    private:
-        Clara::CommandLine<ConfigData> m_cli;
-        std::vector<Clara::Parser::Token> m_unusedTokens;
-        ConfigData m_configData;
-        Ptr<Config> m_config;
-    };
-
-    bool Session::alreadyInstantiated = false;
-
-} // end namespace Catch
-
-// #included from: catch_registry_hub.hpp
-#define TWOBLUECUBES_CATCH_REGISTRY_HUB_HPP_INCLUDED
-
-// #included from: catch_test_case_registry_impl.hpp
-#define TWOBLUECUBES_CATCH_TEST_CASE_REGISTRY_IMPL_HPP_INCLUDED
-
-#include <vector>
-#include <set>
-#include <sstream>
-#include <iostream>
-#include <algorithm>
-
-namespace Catch {
-
-    class TestRegistry : public ITestCaseRegistry {
-        struct LexSort {
-            bool operator() (TestCase i,TestCase j) const { return (i<j);}
-        };
-        struct RandomNumberGenerator {
-            int operator()( int n ) const { return std::rand() % n; }
-        };
-
-    public:
-        TestRegistry() : m_unnamedCount( 0 ) {}
-        virtual ~TestRegistry();
-
-        virtual void registerTest( TestCase const& testCase ) {
-            std::string name = testCase.getTestCaseInfo().name;
-            if( name == "" ) {
-                std::ostringstream oss;
-                oss << "Anonymous test case " << ++m_unnamedCount;
-                return registerTest( testCase.withName( oss.str() ) );
-            }
-
-            if( m_functions.find( testCase ) == m_functions.end() ) {
-                m_functions.insert( testCase );
-                m_functionsInOrder.push_back( testCase );
-                if( !testCase.isHidden() )
-                    m_nonHiddenFunctions.push_back( testCase );
-            }
-            else {
-                TestCase const& prev = *m_functions.find( testCase );
-                {
-                    Colour colourGuard( Colour::Red );
-                    Catch::cerr()   << "error: TEST_CASE( \"" << name << "\" ) already defined.\n"
-                                << "\tFirst seen at " << prev.getTestCaseInfo().lineInfo << "\n"
-                                << "\tRedefined at " << testCase.getTestCaseInfo().lineInfo << std::endl;
-                }
-                exit(1);
-            }
-        }
-
-        virtual std::vector<TestCase> const& getAllTests() const {
-            return m_functionsInOrder;
-        }
-
-        virtual std::vector<TestCase> const& getAllNonHiddenTests() const {
-            return m_nonHiddenFunctions;
-        }
-
-        virtual void getFilteredTests( TestSpec const& testSpec, IConfig const& config, std::vector<TestCase>& matchingTestCases, bool negated = false ) const {
-
-            for( std::vector<TestCase>::const_iterator  it = m_functionsInOrder.begin(),
-                                                        itEnd = m_functionsInOrder.end();
-                    it != itEnd;
-                    ++it ) {
-                bool includeTest = testSpec.matches( *it ) && ( config.allowThrows() || !it->throws() );
-                if( includeTest != negated )
-                    matchingTestCases.push_back( *it );
-            }
-            sortTests( config, matchingTestCases );
-        }
-
-    private:
-
-        static void sortTests( IConfig const& config, std::vector<TestCase>& matchingTestCases ) {
-
-            switch( config.runOrder() ) {
-                case RunTests::InLexicographicalOrder:
-                    std::sort( matchingTestCases.begin(), matchingTestCases.end(), LexSort() );
-                    break;
-                case RunTests::InRandomOrder:
-                {
-                    RandomNumberGenerator rng;
-                    std::random_shuffle( matchingTestCases.begin(), matchingTestCases.end(), rng );
-                }
-                    break;
-                case RunTests::InDeclarationOrder:
-                    // already in declaration order
-                    break;
-            }
-        }
-        std::set<TestCase> m_functions;
-        std::vector<TestCase> m_functionsInOrder;
-        std::vector<TestCase> m_nonHiddenFunctions;
-        size_t m_unnamedCount;
-    };
-
-    ///////////////////////////////////////////////////////////////////////////
-
-    class FreeFunctionTestCase : public SharedImpl<ITestCase> {
-    public:
-
-        FreeFunctionTestCase( TestFunction fun ) : m_fun( fun ) {}
-
-        virtual void invoke() const {
-            m_fun();
-        }
-
-    private:
-        virtual ~FreeFunctionTestCase();
-
-        TestFunction m_fun;
-    };
-
-    inline std::string extractClassName( std::string const& classOrQualifiedMethodName ) {
-        std::string className = classOrQualifiedMethodName;
-        if( startsWith( className, "&" ) )
-        {
-            std::size_t lastColons = className.rfind( "::" );
-            std::size_t penultimateColons = className.rfind( "::", lastColons-1 );
-            if( penultimateColons == std::string::npos )
-                penultimateColons = 1;
-            className = className.substr( penultimateColons, lastColons-penultimateColons );
-        }
-        return className;
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-
-    AutoReg::AutoReg(   TestFunction function,
-                        SourceLineInfo const& lineInfo,
-                        NameAndDesc const& nameAndDesc ) {
-        registerTestCase( new FreeFunctionTestCase( function ), "", nameAndDesc, lineInfo );
-    }
-
-    AutoReg::~AutoReg() {}
-
-    void AutoReg::registerTestCase( ITestCase* testCase,
-                                    char const* classOrQualifiedMethodName,
-                                    NameAndDesc const& nameAndDesc,
-                                    SourceLineInfo const& lineInfo ) {
-
-        getMutableRegistryHub().registerTest
-            ( makeTestCase( testCase,
-                            extractClassName( classOrQualifiedMethodName ),
-                            nameAndDesc.name,
-                            nameAndDesc.description,
-                            lineInfo ) );
-    }
-
-} // end namespace Catch
-
-// #included from: catch_reporter_registry.hpp
-#define TWOBLUECUBES_CATCH_REPORTER_REGISTRY_HPP_INCLUDED
-
-#include <map>
-
-namespace Catch {
-
-    class ReporterRegistry : public IReporterRegistry {
-
-    public:
-
-        virtual ~ReporterRegistry() {
-            deleteAllValues( m_factories );
-        }
-
-        virtual IStreamingReporter* create( std::string const& name, Ptr<IConfig> const& config ) const {
-            FactoryMap::const_iterator it =  m_factories.find( name );
-            if( it == m_factories.end() )
-                return NULL;
-            return it->second->create( ReporterConfig( config ) );
-        }
-
-        void registerReporter( std::string const& name, IReporterFactory* factory ) {
-            m_factories.insert( std::make_pair( name, factory ) );
-        }
-
-        FactoryMap const& getFactories() const {
-            return m_factories;
-        }
-
-    private:
-        FactoryMap m_factories;
-    };
-}
-
-// #included from: catch_exception_translator_registry.hpp
-#define TWOBLUECUBES_CATCH_EXCEPTION_TRANSLATOR_REGISTRY_HPP_INCLUDED
-
-#ifdef __OBJC__
-#import "Foundation/Foundation.h"
-#endif
-
-namespace Catch {
-
-    class ExceptionTranslatorRegistry : public IExceptionTranslatorRegistry {
-    public:
-        ~ExceptionTranslatorRegistry() {
-            deleteAll( m_translators );
-        }
-
-        virtual void registerTranslator( const IExceptionTranslator* translator ) {
-            m_translators.push_back( translator );
-        }
-
-        virtual std::string translateActiveException() const {
-            try {
-#ifdef __OBJC__
-                // In Objective-C try objective-c exceptions first
-                @try {
-                    throw;
-                }
-                @catch (NSException *exception) {
-                    return Catch::toString( [exception description] );
-                }
-#else
-                throw;
-#endif
-            }
-            catch( TestFailureException& ) {
-                throw;
-            }
-            catch( std::exception& ex ) {
-                return ex.what();
-            }
-            catch( std::string& msg ) {
-                return msg;
-            }
-            catch( const char* msg ) {
-                return msg;
-            }
-            catch(...) {
-                return tryTranslators( m_translators.begin() );
-            }
-        }
-
-        std::string tryTranslators( std::vector<const IExceptionTranslator*>::const_iterator it ) const {
-            if( it == m_translators.end() )
-                return "Unknown exception";
-
-            try {
-                return (*it)->translate();
-            }
-            catch(...) {
-                return tryTranslators( it+1 );
-            }
-        }
-
-    private:
-        std::vector<const IExceptionTranslator*> m_translators;
-    };
-}
-
-namespace Catch {
-
-    namespace {
-
-        class RegistryHub : public IRegistryHub, public IMutableRegistryHub {
-
-            RegistryHub( RegistryHub const& );
-            void operator=( RegistryHub const& );
-
-        public: // IRegistryHub
-            RegistryHub() {
-            }
-            virtual IReporterRegistry const& getReporterRegistry() const {
-                return m_reporterRegistry;
-            }
-            virtual ITestCaseRegistry const& getTestCaseRegistry() const {
-                return m_testCaseRegistry;
-            }
-            virtual IExceptionTranslatorRegistry& getExceptionTranslatorRegistry() {
-                return m_exceptionTranslatorRegistry;
-            }
-
-        public: // IMutableRegistryHub
-            virtual void registerReporter( std::string const& name, IReporterFactory* factory ) {
-                m_reporterRegistry.registerReporter( name, factory );
-            }
-            virtual void registerTest( TestCase const& testInfo ) {
-                m_testCaseRegistry.registerTest( testInfo );
-            }
-            virtual void registerTranslator( const IExceptionTranslator* translator ) {
-                m_exceptionTranslatorRegistry.registerTranslator( translator );
-            }
-
-        private:
-            TestRegistry m_testCaseRegistry;
-            ReporterRegistry m_reporterRegistry;
-            ExceptionTranslatorRegistry m_exceptionTranslatorRegistry;
-        };
-
-        // Single, global, instance
-        inline RegistryHub*& getTheRegistryHub() {
-            static RegistryHub* theRegistryHub = NULL;
-            if( !theRegistryHub )
-                theRegistryHub = new RegistryHub();
-            return theRegistryHub;
-        }
-    }
-
-    IRegistryHub& getRegistryHub() {
-        return *getTheRegistryHub();
-    }
-    IMutableRegistryHub& getMutableRegistryHub() {
-        return *getTheRegistryHub();
-    }
-    void cleanUp() {
-        delete getTheRegistryHub();
-        getTheRegistryHub() = NULL;
-        cleanUpContext();
-    }
-    std::string translateActiveException() {
-        return getRegistryHub().getExceptionTranslatorRegistry().translateActiveException();
-    }
-
-} // end namespace Catch
-
-// #included from: catch_notimplemented_exception.hpp
-#define TWOBLUECUBES_CATCH_NOTIMPLEMENTED_EXCEPTION_HPP_INCLUDED
-
-#include <ostream>
-
-namespace Catch {
-
-    NotImplementedException::NotImplementedException( SourceLineInfo const& lineInfo )
-    :   m_lineInfo( lineInfo ) {
-        std::ostringstream oss;
-        oss << lineInfo << ": function ";
-        oss << "not implemented";
-        m_what = oss.str();
-    }
-
-    const char* NotImplementedException::what() const CATCH_NOEXCEPT {
-        return m_what.c_str();
-    }
-
-} // end namespace Catch
-
-// #included from: catch_context_impl.hpp
-#define TWOBLUECUBES_CATCH_CONTEXT_IMPL_HPP_INCLUDED
-
-// #included from: catch_stream.hpp
-#define TWOBLUECUBES_CATCH_STREAM_HPP_INCLUDED
-
-// #included from: catch_streambuf.h
-#define TWOBLUECUBES_CATCH_STREAMBUF_H_INCLUDED
-
-#include <streambuf>
-
-namespace Catch {
-
-    class StreamBufBase : public std::streambuf {
-    public:
-        virtual ~StreamBufBase() CATCH_NOEXCEPT;
-    };
-}
-
-#include <stdexcept>
-#include <cstdio>
-#include <iostream>
-
-namespace Catch {
-
-    template<typename WriterF, size_t bufferSize=256>
-    class StreamBufImpl : public StreamBufBase {
-        char data[bufferSize];
-        WriterF m_writer;
-
-    public:
-        StreamBufImpl() {
-            setp( data, data + sizeof(data) );
-        }
-
-        ~StreamBufImpl() CATCH_NOEXCEPT {
-            sync();
-        }
-
-    private:
-        int overflow( int c ) {
-            sync();
-
-            if( c != EOF ) {
-                if( pbase() == epptr() )
-                    m_writer( std::string( 1, static_cast<char>( c ) ) );
-                else
-                    sputc( static_cast<char>( c ) );
-            }
-            return 0;
-        }
-
-        int sync() {
-            if( pbase() != pptr() ) {
-                m_writer( std::string( pbase(), static_cast<std::string::size_type>( pptr() - pbase() ) ) );
-                setp( pbase(), epptr() );
-            }
-            return 0;
-        }
-    };
-
-    ///////////////////////////////////////////////////////////////////////////
-
-    struct OutputDebugWriter {
-
-        void operator()( std::string const&str ) {
-            writeToDebugConsole( str );
-        }
-    };
-
-    Stream::Stream()
-    : streamBuf( NULL ), isOwned( false )
-    {}
-
-    Stream::Stream( std::streambuf* _streamBuf, bool _isOwned )
-    : streamBuf( _streamBuf ), isOwned( _isOwned )
-    {}
-
-    void Stream::release() {
-        if( isOwned ) {
-            delete streamBuf;
-            streamBuf = NULL;
-            isOwned = false;
-        }
-    }
-
-#ifndef CATCH_CONFIG_NOSTDOUT // If you #define this you must implement this functions
-    std::ostream& cout() {
-        return std::cout;
-    }
-    std::ostream& cerr() {
-        return std::cerr;
-    }
-#endif
-}
-
-namespace Catch {
-
-    class Context : public IMutableContext {
-
-        Context() : m_config( NULL ), m_runner( NULL ), m_resultCapture( NULL ) {}
-        Context( Context const& );
-        void operator=( Context const& );
-
-    public: // IContext
-        virtual IResultCapture* getResultCapture() {
-            return m_resultCapture;
-        }
-        virtual IRunner* getRunner() {
-            return m_runner;
-        }
-        virtual size_t getGeneratorIndex( std::string const& fileInfo, size_t totalSize ) {
-            return getGeneratorsForCurrentTest()
-            .getGeneratorInfo( fileInfo, totalSize )
-            .getCurrentIndex();
-        }
-        virtual bool advanceGeneratorsForCurrentTest() {
-            IGeneratorsForTest* generators = findGeneratorsForCurrentTest();
-            return generators && generators->moveNext();
-        }
-
-        virtual Ptr<IConfig const> getConfig() const {
-            return m_config;
-        }
-
-    public: // IMutableContext
-        virtual void setResultCapture( IResultCapture* resultCapture ) {
-            m_resultCapture = resultCapture;
-        }
-        virtual void setRunner( IRunner* runner ) {
-            m_runner = runner;
-        }
-        virtual void setConfig( Ptr<IConfig const> const& config ) {
-            m_config = config;
-        }
-
-        friend IMutableContext& getCurrentMutableContext();
-
-    private:
-        IGeneratorsForTest* findGeneratorsForCurrentTest() {
-            std::string testName = getResultCapture()->getCurrentTestName();
-
-            std::map<std::string, IGeneratorsForTest*>::const_iterator it =
-            m_generatorsByTestName.find( testName );
-            return it != m_generatorsByTestName.end()
-                ? it->second
-                : NULL;
-        }
-
-        IGeneratorsForTest& getGeneratorsForCurrentTest() {
-            IGeneratorsForTest* generators = findGeneratorsForCurrentTest();
-            if( !generators ) {
-                std::string testName = getResultCapture()->getCurrentTestName();
-                generators = createGeneratorsForTest();
-                m_generatorsByTestName.insert( std::make_pair( testName, generators ) );
-            }
-            return *generators;
-        }
-
-    private:
-        Ptr<IConfig const> m_config;
-        IRunner* m_runner;
-        IResultCapture* m_resultCapture;
-        std::map<std::string, IGeneratorsForTest*> m_generatorsByTestName;
-    };
-
-    namespace {
-        Context* currentContext = NULL;
-    }
-    IMutableContext& getCurrentMutableContext() {
-        if( !currentContext )
-            currentContext = new Context();
-        return *currentContext;
-    }
-    IContext& getCurrentContext() {
-        return getCurrentMutableContext();
-    }
-
-    Stream createStream( std::string const& streamName ) {
-        if( streamName == "stdout" ) return Stream( Catch::cout().rdbuf(), false );
-        if( streamName == "stderr" ) return Stream( Catch::cerr().rdbuf(), false );
-        if( streamName == "debug" ) return Stream( new StreamBufImpl<OutputDebugWriter>, true );
-
-        throw std::domain_error( "Unknown stream: " + streamName );
-    }
-
-    void cleanUpContext() {
-        delete currentContext;
-        currentContext = NULL;
-    }
-}
-
-// #included from: catch_console_colour_impl.hpp
-#define TWOBLUECUBES_CATCH_CONSOLE_COLOUR_IMPL_HPP_INCLUDED
-
-namespace Catch {
-    namespace {
-
-        struct IColourImpl {
-            virtual ~IColourImpl() {}
-            virtual void use( Colour::Code _colourCode ) = 0;
-        };
-
-        struct NoColourImpl : IColourImpl {
-            void use( Colour::Code ) {}
-
-            static IColourImpl* instance() {
-                static NoColourImpl s_instance;
-                return &s_instance;
-            }
-        };
-
-    } // anon namespace
-} // namespace Catch
-
-#if !defined( CATCH_CONFIG_COLOUR_NONE ) && !defined( CATCH_CONFIG_COLOUR_WINDOWS ) && !defined( CATCH_CONFIG_COLOUR_ANSI )
-#   ifdef CATCH_PLATFORM_WINDOWS
-#       define CATCH_CONFIG_COLOUR_WINDOWS
-#   else
-#       define CATCH_CONFIG_COLOUR_ANSI
-#   endif
-#endif
-
-#if defined ( CATCH_CONFIG_COLOUR_WINDOWS ) /////////////////////////////////////////
-
-#ifndef NOMINMAX
-#define NOMINMAX
-#endif
-
-#ifdef __AFXDLL
-#include <AfxWin.h>
-#else
-#include <windows.h>
-#endif
-
-namespace Catch {
-namespace {
-
-    class Win32ColourImpl : public IColourImpl {
-    public:
-        Win32ColourImpl() : stdoutHandle( GetStdHandle(STD_OUTPUT_HANDLE) )
-        {
-            CONSOLE_SCREEN_BUFFER_INFO csbiInfo;
-            GetConsoleScreenBufferInfo( stdoutHandle, &csbiInfo );
-            originalAttributes = csbiInfo.wAttributes;
-        }
-
-        virtual void use( Colour::Code _colourCode ) {
-            switch( _colourCode ) {
-                case Colour::None:      return setTextAttribute( originalAttributes );
-                case Colour::White:     return setTextAttribute( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
-                case Colour::Red:       return setTextAttribute( FOREGROUND_RED );
-                case Colour::Green:     return setTextAttribute( FOREGROUND_GREEN );
-                case Colour::Blue:      return setTextAttribute( FOREGROUND_BLUE );
-                case Colour::Cyan:      return setTextAttribute( FOREGROUND_BLUE | FOREGROUND_GREEN );
-                case Colour::Yellow:    return setTextAttribute( FOREGROUND_RED | FOREGROUND_GREEN );
-                case Colour::Grey:      return setTextAttribute( 0 );
-
-                case Colour::LightGrey:     return setTextAttribute( FOREGROUND_INTENSITY );
-                case Colour::BrightRed:     return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED );
-                case Colour::BrightGreen:   return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN );
-                case Colour::BrightWhite:   return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
-
-                case Colour::Bright: throw std::logic_error( "not a colour" );
-            }
-        }
-
-    private:
-        void setTextAttribute( WORD _textAttribute ) {
-            SetConsoleTextAttribute( stdoutHandle, _textAttribute );
-        }
-        HANDLE stdoutHandle;
-        WORD originalAttributes;
-    };
-
-    IColourImpl* platformColourInstance() {
-        static Win32ColourImpl s_instance;
-        return &s_instance;
-    }
-
-} // end anon namespace
-} // end namespace Catch
-
-#elif defined( CATCH_CONFIG_COLOUR_ANSI ) //////////////////////////////////////
-
-#include <unistd.h>
-
-namespace Catch {
-namespace {
-
-    // use POSIX/ ANSI console terminal codes
-    // Thanks to Adam Strzelecki for original contribution
-    // (http://github.com/nanoant)
-    // https://github.com/philsquared/Catch/pull/131
-    class PosixColourImpl : public IColourImpl {
-    public:
-        virtual void use( Colour::Code _colourCode ) {
-            switch( _colourCode ) {
-                case Colour::None:
-                case Colour::White:     return setColour( "[0m" );
-                case Colour::Red:       return setColour( "[0;31m" );
-                case Colour::Green:     return setColour( "[0;32m" );
-                case Colour::Blue:      return setColour( "[0:34m" );
-                case Colour::Cyan:      return setColour( "[0;36m" );
-                case Colour::Yellow:    return setColour( "[0;33m" );
-                case Colour::Grey:      return setColour( "[1;30m" );
-
-                case Colour::LightGrey:     return setColour( "[0;37m" );
-                case Colour::BrightRed:     return setColour( "[1;31m" );
-                case Colour::BrightGreen:   return setColour( "[1;32m" );
-                case Colour::BrightWhite:   return setColour( "[1;37m" );
-
-                case Colour::Bright: throw std::logic_error( "not a colour" );
-            }
-        }
-        static IColourImpl* instance() {
-            static PosixColourImpl s_instance;
-            return &s_instance;
-        }
-
-    private:
-        void setColour( const char* _escapeCode ) {
-            Catch::cout() << '\033' << _escapeCode;
-        }
-    };
-
-    IColourImpl* platformColourInstance() {
-        return isatty(STDOUT_FILENO)
-            ? PosixColourImpl::instance()
-            : NoColourImpl::instance();
-    }
-
-} // end anon namespace
-} // end namespace Catch
-
-#else  // not Windows or ANSI ///////////////////////////////////////////////
-
-namespace Catch {
-
-    static IColourImpl* platformColourInstance() { return NoColourImpl::instance(); }
-
-} // end namespace Catch
-
-#endif // Windows/ ANSI/ None
-
-namespace Catch {
-
-    Colour::Colour( Code _colourCode ) : m_moved( false ) { use( _colourCode ); }
-    Colour::Colour( Colour const& _other ) : m_moved( false ) { const_cast<Colour&>( _other ).m_moved = true; }
-    Colour::~Colour(){ if( !m_moved ) use( None ); }
-
-    void Colour::use( Code _colourCode ) {
-        static IColourImpl* impl = isDebuggerActive()
-            ? NoColourImpl::instance()
-            : platformColourInstance();
-        impl->use( _colourCode );
-    }
-
-} // end namespace Catch
-
-// #included from: catch_generators_impl.hpp
-#define TWOBLUECUBES_CATCH_GENERATORS_IMPL_HPP_INCLUDED
-
-#include <vector>
-#include <string>
-#include <map>
-
-namespace Catch {
-
-    struct GeneratorInfo : IGeneratorInfo {
-
-        GeneratorInfo( std::size_t size )
-        :   m_size( size ),
-            m_currentIndex( 0 )
-        {}
-
-        bool moveNext() {
-            if( ++m_currentIndex == m_size ) {
-                m_currentIndex = 0;
-                return false;
-            }
-            return true;
-        }
-
-        std::size_t getCurrentIndex() const {
-            return m_currentIndex;
-        }
-
-        std::size_t m_size;
-        std::size_t m_currentIndex;
-    };
-
-    ///////////////////////////////////////////////////////////////////////////
-
-    class GeneratorsForTest : public IGeneratorsForTest {
-
-    public:
-        ~GeneratorsForTest() {
-            deleteAll( m_generatorsInOrder );
-        }
-
-        IGeneratorInfo& getGeneratorInfo( std::string const& fileInfo, std::size_t size ) {
-            std::map<std::string, IGeneratorInfo*>::const_iterator it = m_generatorsByName.find( fileInfo );
-            if( it == m_generatorsByName.end() ) {
-                IGeneratorInfo* info = new GeneratorInfo( size );
-                m_generatorsByName.insert( std::make_pair( fileInfo, info ) );
-                m_generatorsInOrder.push_back( info );
-                return *info;
-            }
-            return *it->second;
-        }
-
-        bool moveNext() {
-            std::vector<IGeneratorInfo*>::const_iterator it = m_generatorsInOrder.begin();
-            std::vector<IGeneratorInfo*>::const_iterator itEnd = m_generatorsInOrder.end();
-            for(; it != itEnd; ++it ) {
-                if( (*it)->moveNext() )
-                    return true;
-            }
-            return false;
-        }
-
-    private:
-        std::map<std::string, IGeneratorInfo*> m_generatorsByName;
-        std::vector<IGeneratorInfo*> m_generatorsInOrder;
-    };
-
-    IGeneratorsForTest* createGeneratorsForTest()
-    {
-        return new GeneratorsForTest();
-    }
-
-} // end namespace Catch
-
-// #included from: catch_assertionresult.hpp
-#define TWOBLUECUBES_CATCH_ASSERTIONRESULT_HPP_INCLUDED
-
-namespace Catch {
-
-    AssertionInfo::AssertionInfo(   std::string const& _macroName,
-                                    SourceLineInfo const& _lineInfo,
-                                    std::string const& _capturedExpression,
-                                    ResultDisposition::Flags _resultDisposition )
-    :   macroName( _macroName ),
-        lineInfo( _lineInfo ),
-        capturedExpression( _capturedExpression ),
-        resultDisposition( _resultDisposition )
-    {}
-
-    AssertionResult::AssertionResult() {}
-
-    AssertionResult::AssertionResult( AssertionInfo const& info, AssertionResultData const& data )
-    :   m_info( info ),
-        m_resultData( data )
-    {}
-
-    AssertionResult::~AssertionResult() {}
-
-    // Result was a success
-    bool AssertionResult::succeeded() const {
-        return Catch::isOk( m_resultData.resultType );
-    }
-
-    // Result was a success, or failure is suppressed
-    bool AssertionResult::isOk() const {
-        return Catch::isOk( m_resultData.resultType ) || shouldSuppressFailure( m_info.resultDisposition );
-    }
-
-    ResultWas::OfType AssertionResult::getResultType() const {
-        return m_resultData.resultType;
-    }
-
-    bool AssertionResult::hasExpression() const {
-        return !m_info.capturedExpression.empty();
-    }
-
-    bool AssertionResult::hasMessage() const {
-        return !m_resultData.message.empty();
-    }
-
-    std::string AssertionResult::getExpression() const {
-        if( isFalseTest( m_info.resultDisposition ) )
-            return "!" + m_info.capturedExpression;
-        else
-            return m_info.capturedExpression;
-    }
-    std::string AssertionResult::getExpressionInMacro() const {
-        if( m_info.macroName.empty() )
-            return m_info.capturedExpression;
-        else
-            return m_info.macroName + "( " + m_info.capturedExpression + " )";
-    }
-
-    bool AssertionResult::hasExpandedExpression() const {
-        return hasExpression() && getExpandedExpression() != getExpression();
-    }
-
-    std::string AssertionResult::getExpandedExpression() const {
-        return m_resultData.reconstructedExpression;
-    }
-
-    std::string AssertionResult::getMessage() const {
-        return m_resultData.message;
-    }
-    SourceLineInfo AssertionResult::getSourceInfo() const {
-        return m_info.lineInfo;
-    }
-
-    std::string AssertionResult::getTestMacroName() const {
-        return m_info.macroName;
-    }
-
-} // end namespace Catch
-
-// #included from: catch_test_case_info.hpp
-#define TWOBLUECUBES_CATCH_TEST_CASE_INFO_HPP_INCLUDED
-
-namespace Catch {
-
-    inline TestCaseInfo::SpecialProperties parseSpecialTag( std::string const& tag ) {
-        if( startsWith( tag, "." ) ||
-            tag == "hide" ||
-            tag == "!hide" )
-            return TestCaseInfo::IsHidden;
-        else if( tag == "!throws" )
-            return TestCaseInfo::Throws;
-        else if( tag == "!shouldfail" )
-            return TestCaseInfo::ShouldFail;
-        else if( tag == "!mayfail" )
-            return TestCaseInfo::MayFail;
-        else
-            return TestCaseInfo::None;
-    }
-    inline bool isReservedTag( std::string const& tag ) {
-        return TestCaseInfo::None && tag.size() > 0 && !isalnum( tag[0] );
-    }
-    inline void enforceNotReservedTag( std::string const& tag, SourceLineInfo const& _lineInfo ) {
-        if( isReservedTag( tag ) ) {
-            {
-                Colour colourGuard( Colour::Red );
-                Catch::cerr()
-                    << "Tag name [" << tag << "] not allowed.\n"
-                    << "Tag names starting with non alpha-numeric characters are reserved\n";
-            }
-            {
-                Colour colourGuard( Colour::FileName );
-                Catch::cerr() << _lineInfo << std::endl;
-            }
-            exit(1);
-        }
-    }
-
-    TestCase makeTestCase(  ITestCase* _testCase,
-                            std::string const& _className,
-                            std::string const& _name,
-                            std::string const& _descOrTags,
-                            SourceLineInfo const& _lineInfo )
-    {
-        bool isHidden( startsWith( _name, "./" ) ); // Legacy support
-
-        // Parse out tags
-        std::set<std::string> tags;
-        std::string desc, tag;
-        bool inTag = false;
-        for( std::size_t i = 0; i < _descOrTags.size(); ++i ) {
-            char c = _descOrTags[i];
-            if( !inTag ) {
-                if( c == '[' )
-                    inTag = true;
-                else
-                    desc += c;
-            }
-            else {
-                if( c == ']' ) {
-                    TestCaseInfo::SpecialProperties prop = parseSpecialTag( tag );
-                    if( prop == TestCaseInfo::IsHidden )
-                        isHidden = true;
-                    else if( prop == TestCaseInfo::None )
-                        enforceNotReservedTag( tag, _lineInfo );
-
-                    tags.insert( tag );
-                    tag.clear();
-                    inTag = false;
-                }
-                else
-                    tag += c;
-            }
-        }
-        if( isHidden ) {
-            tags.insert( "hide" );
-            tags.insert( "." );
-        }
-
-        TestCaseInfo info( _name, _className, desc, tags, _lineInfo );
-        return TestCase( _testCase, info );
-    }
-
-    TestCaseInfo::TestCaseInfo( std::string const& _name,
-                                std::string const& _className,
-                                std::string const& _description,
-                                std::set<std::string> const& _tags,
-                                SourceLineInfo const& _lineInfo )
-    :   name( _name ),
-        className( _className ),
-        description( _description ),
-        tags( _tags ),
-        lineInfo( _lineInfo ),
-        properties( None )
-    {
-        std::ostringstream oss;
-        for( std::set<std::string>::const_iterator it = _tags.begin(), itEnd = _tags.end(); it != itEnd; ++it ) {
-            oss << "[" << *it << "]";
-            std::string lcaseTag = toLower( *it );
-            properties = static_cast<SpecialProperties>( properties | parseSpecialTag( lcaseTag ) );
-            lcaseTags.insert( lcaseTag );
-        }
-        tagsAsString = oss.str();
-    }
-
-    TestCaseInfo::TestCaseInfo( TestCaseInfo const& other )
-    :   name( other.name ),
-        className( other.className ),
-        description( other.description ),
-        tags( other.tags ),
-        lcaseTags( other.lcaseTags ),
-        tagsAsString( other.tagsAsString ),
-        lineInfo( other.lineInfo ),
-        properties( other.properties )
-    {}
-
-    bool TestCaseInfo::isHidden() const {
-        return ( properties & IsHidden ) != 0;
-    }
-    bool TestCaseInfo::throws() const {
-        return ( properties & Throws ) != 0;
-    }
-    bool TestCaseInfo::okToFail() const {
-        return ( properties & (ShouldFail | MayFail ) ) != 0;
-    }
-    bool TestCaseInfo::expectedToFail() const {
-        return ( properties & (ShouldFail ) ) != 0;
-    }
-
-    TestCase::TestCase( ITestCase* testCase, TestCaseInfo const& info ) : TestCaseInfo( info ), test( testCase ) {}
-
-    TestCase::TestCase( TestCase const& other )
-    :   TestCaseInfo( other ),
-        test( other.test )
-    {}
-
-    TestCase TestCase::withName( std::string const& _newName ) const {
-        TestCase other( *this );
-        other.name = _newName;
-        return other;
-    }
-
-    void TestCase::swap( TestCase& other ) {
-        test.swap( other.test );
-        name.swap( other.name );
-        className.swap( other.className );
-        description.swap( other.description );
-        tags.swap( other.tags );
-        lcaseTags.swap( other.lcaseTags );
-        tagsAsString.swap( other.tagsAsString );
-        std::swap( TestCaseInfo::properties, static_cast<TestCaseInfo&>( other ).properties );
-        std::swap( lineInfo, other.lineInfo );
-    }
-
-    void TestCase::invoke() const {
-        test->invoke();
-    }
-
-    bool TestCase::operator == ( TestCase const& other ) const {
-        return  test.get() == other.test.get() &&
-                name == other.name &&
-                className == other.className;
-    }
-
-    bool TestCase::operator < ( TestCase const& other ) const {
-        return name < other.name;
-    }
-    TestCase& TestCase::operator = ( TestCase const& other ) {
-        TestCase temp( other );
-        swap( temp );
-        return *this;
-    }
-
-    TestCaseInfo const& TestCase::getTestCaseInfo() const
-    {
-        return *this;
-    }
-
-} // end namespace Catch
-
-// #included from: catch_version.hpp
-#define TWOBLUECUBES_CATCH_VERSION_HPP_INCLUDED
-
-namespace Catch {
-
-    // These numbers are maintained by a script
-    Version libraryVersion( 1, 1, 13, "develop" );
-}
-
-// #included from: catch_message.hpp
-#define TWOBLUECUBES_CATCH_MESSAGE_HPP_INCLUDED
-
-namespace Catch {
-
-    MessageInfo::MessageInfo(   std::string const& _macroName,
-                                SourceLineInfo const& _lineInfo,
-                                ResultWas::OfType _type )
-    :   macroName( _macroName ),
-        lineInfo( _lineInfo ),
-        type( _type ),
-        sequence( ++globalCount )
-    {}
-
-    // This may need protecting if threading support is added
-    unsigned int MessageInfo::globalCount = 0;
-
-    ////////////////////////////////////////////////////////////////////////////
-
-    ScopedMessage::ScopedMessage( MessageBuilder const& builder )
-    : m_info( builder.m_info )
-    {
-        m_info.message = builder.m_stream.str();
-        getResultCapture().pushScopedMessage( m_info );
-    }
-    ScopedMessage::ScopedMessage( ScopedMessage const& other )
-    : m_info( other.m_info )
-    {}
-
-    ScopedMessage::~ScopedMessage() {
-        getResultCapture().popScopedMessage( m_info );
-    }
-
-} // end namespace Catch
-
-// #included from: catch_legacy_reporter_adapter.hpp
-#define TWOBLUECUBES_CATCH_LEGACY_REPORTER_ADAPTER_HPP_INCLUDED
-
-// #included from: catch_legacy_reporter_adapter.h
-#define TWOBLUECUBES_CATCH_LEGACY_REPORTER_ADAPTER_H_INCLUDED
-
-namespace Catch
-{
-    // Deprecated
-    struct IReporter : IShared {
-        virtual ~IReporter();
-
-        virtual bool shouldRedirectStdout() const = 0;
-
-        virtual void StartTesting() = 0;
-        virtual void EndTesting( Totals const& totals ) = 0;
-        virtual void StartGroup( std::string const& groupName ) = 0;
-        virtual void EndGroup( std::string const& groupName, Totals const& totals ) = 0;
-        virtual void StartTestCase( TestCaseInfo const& testInfo ) = 0;
-        virtual void EndTestCase( TestCaseInfo const& testInfo, Totals const& totals, std::string const& stdOut, std::string const& stdErr ) = 0;
-        virtual void StartSection( std::string const& sectionName, std::string const& description ) = 0;
-        virtual void EndSection( std::string const& sectionName, Counts const& assertions ) = 0;
-        virtual void NoAssertionsInSection( std::string const& sectionName ) = 0;
-        virtual void NoAssertionsInTestCase( std::string const& testName ) = 0;
-        virtual void Aborted() = 0;
-        virtual void Result( AssertionResult const& result ) = 0;
-    };
-
-    class LegacyReporterAdapter : public SharedImpl<IStreamingReporter>
-    {
-    public:
-        LegacyReporterAdapter( Ptr<IReporter> const& legacyReporter );
-        virtual ~LegacyReporterAdapter();
-
-        virtual ReporterPreferences getPreferences() const;
-        virtual void noMatchingTestCases( std::string const& );
-        virtual void testRunStarting( TestRunInfo const& );
-        virtual void testGroupStarting( GroupInfo const& groupInfo );
-        virtual void testCaseStarting( TestCaseInfo const& testInfo );
-        virtual void sectionStarting( SectionInfo const& sectionInfo );
-        virtual void assertionStarting( AssertionInfo const& );
-        virtual bool assertionEnded( AssertionStats const& assertionStats );
-        virtual void sectionEnded( SectionStats const& sectionStats );
-        virtual void testCaseEnded( TestCaseStats const& testCaseStats );
-        virtual void testGroupEnded( TestGroupStats const& testGroupStats );
-        virtual void testRunEnded( TestRunStats const& testRunStats );
-        virtual void skipTest( TestCaseInfo const& );
-
-    private:
-        Ptr<IReporter> m_legacyReporter;
-    };
-}
-
-namespace Catch
-{
-    LegacyReporterAdapter::LegacyReporterAdapter( Ptr<IReporter> const& legacyReporter )
-    :   m_legacyReporter( legacyReporter )
-    {}
-    LegacyReporterAdapter::~LegacyReporterAdapter() {}
-
-    ReporterPreferences LegacyReporterAdapter::getPreferences() const {
-        ReporterPreferences prefs;
-        prefs.shouldRedirectStdOut = m_legacyReporter->shouldRedirectStdout();
-        return prefs;
-    }
-
-    void LegacyReporterAdapter::noMatchingTestCases( std::string const& ) {}
-    void LegacyReporterAdapter::testRunStarting( TestRunInfo const& ) {
-        m_legacyReporter->StartTesting();
-    }
-    void LegacyReporterAdapter::testGroupStarting( GroupInfo const& groupInfo ) {
-        m_legacyReporter->StartGroup( groupInfo.name );
-    }
-    void LegacyReporterAdapter::testCaseStarting( TestCaseInfo const& testInfo ) {
-        m_legacyReporter->StartTestCase( testInfo );
-    }
-    void LegacyReporterAdapter::sectionStarting( SectionInfo const& sectionInfo ) {
-        m_legacyReporter->StartSection( sectionInfo.name, sectionInfo.description );
-    }
-    void LegacyReporterAdapter::assertionStarting( AssertionInfo const& ) {
-        // Not on legacy interface
-    }
-
-    bool LegacyReporterAdapter::assertionEnded( AssertionStats const& assertionStats ) {
-        if( assertionStats.assertionResult.getResultType() != ResultWas::Ok ) {
-            for( std::vector<MessageInfo>::const_iterator it = assertionStats.infoMessages.begin(), itEnd = assertionStats.infoMessages.end();
-                    it != itEnd;
-                    ++it ) {
-                if( it->type == ResultWas::Info ) {
-                    ResultBuilder rb( it->macroName.c_str(), it->lineInfo, "", ResultDisposition::Normal );
-                    rb << it->message;
-                    rb.setResultType( ResultWas::Info );
-                    AssertionResult result = rb.build();
-                    m_legacyReporter->Result( result );
-                }
-            }
-        }
-        m_legacyReporter->Result( assertionStats.assertionResult );
-        return true;
-    }
-    void LegacyReporterAdapter::sectionEnded( SectionStats const& sectionStats ) {
-        if( sectionStats.missingAssertions )
-            m_legacyReporter->NoAssertionsInSection( sectionStats.sectionInfo.name );
-        m_legacyReporter->EndSection( sectionStats.sectionInfo.name, sectionStats.assertions );
-    }
-    void LegacyReporterAdapter::testCaseEnded( TestCaseStats const& testCaseStats ) {
-        m_legacyReporter->EndTestCase
-            (   testCaseStats.testInfo,
-                testCaseStats.totals,
-                testCaseStats.stdOut,
-                testCaseStats.stdErr );
-    }
-    void LegacyReporterAdapter::testGroupEnded( TestGroupStats const& testGroupStats ) {
-        if( testGroupStats.aborting )
-            m_legacyReporter->Aborted();
-        m_legacyReporter->EndGroup( testGroupStats.groupInfo.name, testGroupStats.totals );
-    }
-    void LegacyReporterAdapter::testRunEnded( TestRunStats const& testRunStats ) {
-        m_legacyReporter->EndTesting( testRunStats.totals );
-    }
-    void LegacyReporterAdapter::skipTest( TestCaseInfo const& ) {
-    }
-}
-
-// #included from: catch_timer.hpp
-
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wc++11-long-long"
-#endif
-
-#ifdef CATCH_PLATFORM_WINDOWS
-#include <windows.h>
-#else
-#include <sys/time.h>
-#endif
-
-namespace Catch {
-
-    namespace {
-#ifdef CATCH_PLATFORM_WINDOWS
-        uint64_t getCurrentTicks() {
-            static uint64_t hz=0, hzo=0;
-            if (!hz) {
-                QueryPerformanceFrequency((LARGE_INTEGER*)&hz);
-                QueryPerformanceCounter((LARGE_INTEGER*)&hzo);
-            }
-            uint64_t t;
-            QueryPerformanceCounter((LARGE_INTEGER*)&t);
-            return ((t-hzo)*1000000)/hz;
-        }
-#else
-        uint64_t getCurrentTicks() {
-            timeval t;
-            gettimeofday(&t,NULL);
-            return static_cast<uint64_t>( t.tv_sec ) * 1000000ull + static_cast<uint64_t>( t.tv_usec );
-        }
-#endif
-    }
-
-    void Timer::start() {
-        m_ticks = getCurrentTicks();
-    }
-    unsigned int Timer::getElapsedMicroseconds() const {
-        return static_cast<unsigned int>(getCurrentTicks() - m_ticks);
-    }
-    unsigned int Timer::getElapsedMilliseconds() const {
-        return static_cast<unsigned int>(getElapsedMicroseconds()/1000);
-    }
-    double Timer::getElapsedSeconds() const {
-        return getElapsedMicroseconds()/1000000.0;
-    }
-
-} // namespace Catch
-
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-// #included from: catch_common.hpp
-#define TWOBLUECUBES_CATCH_COMMON_HPP_INCLUDED
-
-namespace Catch {
-
-    bool startsWith( std::string const& s, std::string const& prefix ) {
-        return s.size() >= prefix.size() && s.substr( 0, prefix.size() ) == prefix;
-    }
-    bool endsWith( std::string const& s, std::string const& suffix ) {
-        return s.size() >= suffix.size() && s.substr( s.size()-suffix.size(), suffix.size() ) == suffix;
-    }
-    bool contains( std::string const& s, std::string const& infix ) {
-        return s.find( infix ) != std::string::npos;
-    }
-    void toLowerInPlace( std::string& s ) {
-        std::transform( s.begin(), s.end(), s.begin(), ::tolower );
-    }
-    std::string toLower( std::string const& s ) {
-        std::string lc = s;
-        toLowerInPlace( lc );
-        return lc;
-    }
-    std::string trim( std::string const& str ) {
-        static char const* whitespaceChars = "\n\r\t ";
-        std::string::size_type start = str.find_first_not_of( whitespaceChars );
-        std::string::size_type end = str.find_last_not_of( whitespaceChars );
-
-        return start != std::string::npos ? str.substr( start, 1+end-start ) : "";
-    }
-
-    bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis ) {
-        bool replaced = false;
-        std::size_t i = str.find( replaceThis );
-        while( i != std::string::npos ) {
-            replaced = true;
-            str = str.substr( 0, i ) + withThis + str.substr( i+replaceThis.size() );
-            if( i < str.size()-withThis.size() )
-                i = str.find( replaceThis, i+withThis.size() );
-            else
-                i = std::string::npos;
-        }
-        return replaced;
-    }
-
-    pluralise::pluralise( std::size_t count, std::string const& label )
-    :   m_count( count ),
-        m_label( label )
-    {}
-
-    std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser ) {
-        os << pluraliser.m_count << " " << pluraliser.m_label;
-        if( pluraliser.m_count != 1 )
-            os << "s";
-        return os;
-    }
-
-    SourceLineInfo::SourceLineInfo() : line( 0 ){}
-    SourceLineInfo::SourceLineInfo( char const* _file, std::size_t _line )
-    :   file( _file ),
-        line( _line )
-    {}
-    SourceLineInfo::SourceLineInfo( SourceLineInfo const& other )
-    :   file( other.file ),
-        line( other.line )
-    {}
-    bool SourceLineInfo::empty() const {
-        return file.empty();
-    }
-    bool SourceLineInfo::operator == ( SourceLineInfo const& other ) const {
-        return line == other.line && file == other.file;
-    }
-
-    std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ) {
-#ifndef __GNUG__
-        os << info.file << "(" << info.line << ")";
-#else
-        os << info.file << ":" << info.line;
-#endif
-        return os;
-    }
-
-    void throwLogicError( std::string const& message, SourceLineInfo const& locationInfo ) {
-        std::ostringstream oss;
-        oss << locationInfo << ": Internal Catch error: '" << message << "'";
-        if( alwaysTrue() )
-            throw std::logic_error( oss.str() );
-    }
-}
-
-// #included from: catch_section.hpp
-#define TWOBLUECUBES_CATCH_SECTION_HPP_INCLUDED
-
-namespace Catch {
-
-    SectionInfo::SectionInfo
-        (   SourceLineInfo const& _lineInfo,
-            std::string const& _name,
-            std::string const& _description )
-    :   name( _name ),
-        description( _description ),
-        lineInfo( _lineInfo )
-    {}
-
-    Section::Section( SectionInfo const& info )
-    :   m_info( info ),
-        m_sectionIncluded( getResultCapture().sectionStarted( m_info, m_assertions ) )
-    {
-        m_timer.start();
-    }
-
-    Section::~Section() {
-        if( m_sectionIncluded )
-            getResultCapture().sectionEnded( m_info, m_assertions, m_timer.getElapsedSeconds() );
-    }
-
-    // This indicates whether the section should be executed or not
-    Section::operator bool() const {
-        return m_sectionIncluded;
-    }
-
-} // end namespace Catch
-
-// #included from: catch_debugger.hpp
-#define TWOBLUECUBES_CATCH_DEBUGGER_HPP_INCLUDED
-
-#include <iostream>
-
-#ifdef CATCH_PLATFORM_MAC
-
-    #include <assert.h>
-    #include <stdbool.h>
-    #include <sys/types.h>
-    #include <unistd.h>
-    #include <sys/sysctl.h>
-
-    namespace Catch{
-
-        // The following function is taken directly from the following technical note:
-        // http://developer.apple.com/library/mac/#qa/qa2004/qa1361.html
-
-        // Returns true if the current process is being debugged (either
-        // running under the debugger or has a debugger attached post facto).
-        bool isDebuggerActive(){
-
-            int                 mib[4];
-            struct kinfo_proc   info;
-            size_t              size;
-
-            // Initialize the flags so that, if sysctl fails for some bizarre
-            // reason, we get a predictable result.
-
-            info.kp_proc.p_flag = 0;
-
-            // Initialize mib, which tells sysctl the info we want, in this case
-            // we're looking for information about a specific process ID.
-
-            mib[0] = CTL_KERN;
-            mib[1] = KERN_PROC;
-            mib[2] = KERN_PROC_PID;
-            mib[3] = getpid();
-
-            // Call sysctl.
-
-            size = sizeof(info);
-            if( sysctl(mib, sizeof(mib) / sizeof(*mib), &info, &size, NULL, 0) != 0 ) {
-                Catch::cerr() << "\n** Call to sysctl failed - unable to determine if debugger is active **\n" << std::endl;
-                return false;
-            }
-
-            // We're being debugged if the P_TRACED flag is set.
-
-            return ( (info.kp_proc.p_flag & P_TRACED) != 0 );
-        }
-    } // namespace Catch
-
-#elif defined(_MSC_VER)
-    extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
-    namespace Catch {
-        bool isDebuggerActive() {
-            return IsDebuggerPresent() != 0;
-        }
-    }
-#elif defined(__MINGW32__)
-    extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
-    namespace Catch {
-        bool isDebuggerActive() {
-            return IsDebuggerPresent() != 0;
-        }
-    }
-#else
-    namespace Catch {
-       inline bool isDebuggerActive() { return false; }
-    }
-#endif // Platform
-
-#ifdef CATCH_PLATFORM_WINDOWS
-    extern "C" __declspec(dllimport) void __stdcall OutputDebugStringA( const char* );
-    namespace Catch {
-        void writeToDebugConsole( std::string const& text ) {
-            ::OutputDebugStringA( text.c_str() );
-        }
-    }
-#else
-    namespace Catch {
-        void writeToDebugConsole( std::string const& text ) {
-            // !TBD: Need a version for Mac/ XCode and other IDEs
-            Catch::cout() << text;
-        }
-    }
-#endif // Platform
-
-// #included from: catch_tostring.hpp
-#define TWOBLUECUBES_CATCH_TOSTRING_HPP_INCLUDED
-
-namespace Catch {
-
-namespace Detail {
-
-    std::string unprintableString = "{?}";
-
-    namespace {
-        struct Endianness {
-            enum Arch { Big, Little };
-
-            static Arch which() {
-                union _{
-                    int asInt;
-                    char asChar[sizeof (int)];
-                } u;
-
-                u.asInt = 1;
-                return ( u.asChar[sizeof(int)-1] == 1 ) ? Big : Little;
-            }
-        };
-    }
-
-    std::string rawMemoryToString( const void *object, std::size_t size )
-    {
-        // Reverse order for little endian architectures
-        int i = 0, end = static_cast<int>( size ), inc = 1;
-        if( Endianness::which() == Endianness::Little ) {
-            i = end-1;
-            end = inc = -1;
-        }
-
-        unsigned char const *bytes = static_cast<unsigned char const *>(object);
-        std::ostringstream os;
-        os << "0x" << std::setfill('0') << std::hex;
-        for( ; i != end; i += inc )
-             os << std::setw(2) << static_cast<unsigned>(bytes[i]);
-       return os.str();
-    }
-}
-
-std::string toString( std::string const& value ) {
-    std::string s = value;
-    if( getCurrentContext().getConfig()->showInvisibles() ) {
-        for(size_t i = 0; i < s.size(); ++i ) {
-            std::string subs;
-            switch( s[i] ) {
-            case '\n': subs = "\\n"; break;
-            case '\t': subs = "\\t"; break;
-            default: break;
-            }
-            if( !subs.empty() ) {
-                s = s.substr( 0, i ) + subs + s.substr( i+1 );
-                ++i;
-            }
-        }
-    }
-    return "\"" + s + "\"";
-}
-std::string toString( std::wstring const& value ) {
-
-    std::string s;
-    s.reserve( value.size() );
-    for(size_t i = 0; i < value.size(); ++i )
-        s += value[i] <= 0xff ? static_cast<char>( value[i] ) : '?';
-    return Catch::toString( s );
-}
-
-std::string toString( const char* const value ) {
-    return value ? Catch::toString( std::string( value ) ) : std::string( "{null string}" );
-}
-
-std::string toString( char* const value ) {
-    return Catch::toString( static_cast<const char*>( value ) );
-}
-
-std::string toString( const wchar_t* const value )
-{
-	return value ? Catch::toString( std::wstring(value) ) : std::string( "{null string}" );
-}
-
-std::string toString( wchar_t* const value )
-{
-	return Catch::toString( static_cast<const wchar_t*>( value ) );
-}
-
-std::string toString( int value ) {
-    std::ostringstream oss;
-    if( value > 8192 )
-        oss << "0x" << std::hex << value;
-    else
-        oss << value;
-    return oss.str();
-}
-
-std::string toString( unsigned long value ) {
-    std::ostringstream oss;
-    if( value > 8192 )
-        oss << "0x" << std::hex << value;
-    else
-        oss << value;
-    return oss.str();
-}
-
-std::string toString( unsigned int value ) {
-    return Catch::toString( static_cast<unsigned long>( value ) );
-}
-
-template<typename T>
-std::string fpToString( T value, int precision ) {
-    std::ostringstream oss;
-    oss << std::setprecision( precision )
-        << std::fixed
-        << value;
-    std::string d = oss.str();
-    std::size_t i = d.find_last_not_of( '0' );
-    if( i != std::string::npos && i != d.size()-1 ) {
-        if( d[i] == '.' )
-            i++;
-        d = d.substr( 0, i+1 );
-    }
-    return d;
-}
-
-std::string toString( const double value ) {
-    return fpToString( value, 10 );
-}
-std::string toString( const float value ) {
-    return fpToString( value, 5 ) + "f";
-}
-
-std::string toString( bool value ) {
-    return value ? "true" : "false";
-}
-
-std::string toString( char value ) {
-    return value < ' '
-        ? toString( static_cast<unsigned int>( value ) )
-        : Detail::makeString( value );
-}
-
-std::string toString( signed char value ) {
-    return toString( static_cast<char>( value ) );
-}
-
-std::string toString( unsigned char value ) {
-    return toString( static_cast<char>( value ) );
-}
-
-#ifdef CATCH_CONFIG_CPP11_NULLPTR
-std::string toString( std::nullptr_t ) {
-    return "nullptr";
-}
-#endif
-
-#ifdef __OBJC__
-    std::string toString( NSString const * const& nsstring ) {
-        if( !nsstring )
-            return "nil";
-        return "@" + toString([nsstring UTF8String]);
-    }
-    std::string toString( NSString * CATCH_ARC_STRONG const& nsstring ) {
-        if( !nsstring )
-            return "nil";
-        return "@" + toString([nsstring UTF8String]);
-    }
-    std::string toString( NSObject* const& nsObject ) {
-        return toString( [nsObject description] );
-    }
-#endif
-
-} // end namespace Catch
-
-// #included from: catch_result_builder.hpp
-#define TWOBLUECUBES_CATCH_RESULT_BUILDER_HPP_INCLUDED
-
-namespace Catch {
-
-    ResultBuilder::ResultBuilder(   char const* macroName,
-                                    SourceLineInfo const& lineInfo,
-                                    char const* capturedExpression,
-                                    ResultDisposition::Flags resultDisposition )
-    :   m_assertionInfo( macroName, lineInfo, capturedExpression, resultDisposition ),
-        m_shouldDebugBreak( false ),
-        m_shouldThrow( false )
-    {}
-
-    ResultBuilder& ResultBuilder::setResultType( ResultWas::OfType result ) {
-        m_data.resultType = result;
-        return *this;
-    }
-    ResultBuilder& ResultBuilder::setResultType( bool result ) {
-        m_data.resultType = result ? ResultWas::Ok : ResultWas::ExpressionFailed;
-        return *this;
-    }
-    ResultBuilder& ResultBuilder::setLhs( std::string const& lhs ) {
-        m_exprComponents.lhs = lhs;
-        return *this;
-    }
-    ResultBuilder& ResultBuilder::setRhs( std::string const& rhs ) {
-        m_exprComponents.rhs = rhs;
-        return *this;
-    }
-    ResultBuilder& ResultBuilder::setOp( std::string const& op ) {
-        m_exprComponents.op = op;
-        return *this;
-    }
-
-    void ResultBuilder::endExpression() {
-        m_exprComponents.testFalse = isFalseTest( m_assertionInfo.resultDisposition );
-        captureExpression();
-    }
-
-    void ResultBuilder::useActiveException( ResultDisposition::Flags resultDisposition ) {
-        m_assertionInfo.resultDisposition = resultDisposition;
-        m_stream.oss << Catch::translateActiveException();
-        captureResult( ResultWas::ThrewException );
-    }
-
-    void ResultBuilder::captureResult( ResultWas::OfType resultType ) {
-        setResultType( resultType );
-        captureExpression();
-    }
-
-    void ResultBuilder::captureExpression() {
-        AssertionResult result = build();
-        getResultCapture().assertionEnded( result );
-
-        if( !result.isOk() ) {
-            if( getCurrentContext().getConfig()->shouldDebugBreak() )
-                m_shouldDebugBreak = true;
-            if( getCurrentContext().getRunner()->aborting() || m_assertionInfo.resultDisposition == ResultDisposition::Normal )
-                m_shouldThrow = true;
-        }
-    }
-    void ResultBuilder::react() {
-        if( m_shouldThrow )
-            throw Catch::TestFailureException();
-    }
-
-    bool ResultBuilder::shouldDebugBreak() const { return m_shouldDebugBreak; }
-    bool ResultBuilder::allowThrows() const { return getCurrentContext().getConfig()->allowThrows(); }
-
-    AssertionResult ResultBuilder::build() const
-    {
-        assert( m_data.resultType != ResultWas::Unknown );
-
-        AssertionResultData data = m_data;
-
-        // Flip bool results if testFalse is set
-        if( m_exprComponents.testFalse ) {
-            if( data.resultType == ResultWas::Ok )
-                data.resultType = ResultWas::ExpressionFailed;
-            else if( data.resultType == ResultWas::ExpressionFailed )
-                data.resultType = ResultWas::Ok;
-        }
-
-        data.message = m_stream.oss.str();
-        data.reconstructedExpression = reconstructExpression();
-        if( m_exprComponents.testFalse ) {
-            if( m_exprComponents.op == "" )
-                data.reconstructedExpression = "!" + data.reconstructedExpression;
-            else
-                data.reconstructedExpression = "!(" + data.reconstructedExpression + ")";
-        }
-        return AssertionResult( m_assertionInfo, data );
-    }
-    std::string ResultBuilder::reconstructExpression() const {
-        if( m_exprComponents.op == "" )
-            return m_exprComponents.lhs.empty() ? m_assertionInfo.capturedExpression : m_exprComponents.op + m_exprComponents.lhs;
-        else if( m_exprComponents.op == "matches" )
-            return m_exprComponents.lhs + " " + m_exprComponents.rhs;
-        else if( m_exprComponents.op != "!" ) {
-            if( m_exprComponents.lhs.size() + m_exprComponents.rhs.size() < 40 &&
-                m_exprComponents.lhs.find("\n") == std::string::npos &&
-                m_exprComponents.rhs.find("\n") == std::string::npos )
-                return m_exprComponents.lhs + " " + m_exprComponents.op + " " + m_exprComponents.rhs;
-            else
-                return m_exprComponents.lhs + "\n" + m_exprComponents.op + "\n" + m_exprComponents.rhs;
-        }
-        else
-            return "{can't expand - use " + m_assertionInfo.macroName + "_FALSE( " + m_assertionInfo.capturedExpression.substr(1) + " ) instead of " + m_assertionInfo.macroName + "( " + m_assertionInfo.capturedExpression + " ) for better diagnostics}";
-    }
-
-} // end namespace Catch
-
-// #included from: catch_tag_alias_registry.hpp
-#define TWOBLUECUBES_CATCH_TAG_ALIAS_REGISTRY_HPP_INCLUDED
-
-// #included from: catch_tag_alias_registry.h
-#define TWOBLUECUBES_CATCH_TAG_ALIAS_REGISTRY_H_INCLUDED
-
-#include <map>
-
-namespace Catch {
-
-    class TagAliasRegistry : public ITagAliasRegistry {
-    public:
-        virtual ~TagAliasRegistry();
-        virtual Option<TagAlias> find( std::string const& alias ) const;
-        virtual std::string expandAliases( std::string const& unexpandedTestSpec ) const;
-        void add( char const* alias, char const* tag, SourceLineInfo const& lineInfo );
-        static TagAliasRegistry& get();
-
-    private:
-        std::map<std::string, TagAlias> m_registry;
-    };
-
-} // end namespace Catch
-
-#include <map>
-#include <iostream>
-
-namespace Catch {
-
-    TagAliasRegistry::~TagAliasRegistry() {}
-
-    Option<TagAlias> TagAliasRegistry::find( std::string const& alias ) const {
-        std::map<std::string, TagAlias>::const_iterator it = m_registry.find( alias );
-        if( it != m_registry.end() )
-            return it->second;
-        else
-            return Option<TagAlias>();
-    }
-
-    std::string TagAliasRegistry::expandAliases( std::string const& unexpandedTestSpec ) const {
-        std::string expandedTestSpec = unexpandedTestSpec;
-        for( std::map<std::string, TagAlias>::const_iterator it = m_registry.begin(), itEnd = m_registry.end();
-                it != itEnd;
-                ++it ) {
-            std::size_t pos = expandedTestSpec.find( it->first );
-            if( pos != std::string::npos ) {
-                expandedTestSpec =  expandedTestSpec.substr( 0, pos ) +
-                                    it->second.tag +
-                                    expandedTestSpec.substr( pos + it->first.size() );
-            }
-        }
-        return expandedTestSpec;
-    }
-
-    void TagAliasRegistry::add( char const* alias, char const* tag, SourceLineInfo const& lineInfo ) {
-
-        if( !startsWith( alias, "[@" ) || !endsWith( alias, "]" ) ) {
-            std::ostringstream oss;
-            oss << "error: tag alias, \"" << alias << "\" is not of the form [@alias name].\n" << lineInfo;
-            throw std::domain_error( oss.str().c_str() );
-        }
-        if( !m_registry.insert( std::make_pair( alias, TagAlias( tag, lineInfo ) ) ).second ) {
-            std::ostringstream oss;
-            oss << "error: tag alias, \"" << alias << "\" already registered.\n"
-                << "\tFirst seen at " << find(alias)->lineInfo << "\n"
-                << "\tRedefined at " << lineInfo;
-            throw std::domain_error( oss.str().c_str() );
-        }
-    }
-
-    TagAliasRegistry& TagAliasRegistry::get() {
-        static TagAliasRegistry instance;
-        return instance;
-
-    }
-
-    ITagAliasRegistry::~ITagAliasRegistry() {}
-    ITagAliasRegistry const& ITagAliasRegistry::get() { return TagAliasRegistry::get(); }
-
-    RegistrarForTagAliases::RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo ) {
-        try {
-            TagAliasRegistry::get().add( alias, tag, lineInfo );
-        }
-        catch( std::exception& ex ) {
-            Colour colourGuard( Colour::Red );
-            Catch::cerr() << ex.what() << std::endl;
-            exit(1);
-        }
-    }
-
-} // end namespace Catch
-
-// #included from: ../reporters/catch_reporter_xml.hpp
-#define TWOBLUECUBES_CATCH_REPORTER_XML_HPP_INCLUDED
-
-// #included from: catch_reporter_bases.hpp
-#define TWOBLUECUBES_CATCH_REPORTER_BASES_HPP_INCLUDED
-
-#include <cstring>
-
-namespace Catch {
-
-    struct StreamingReporterBase : SharedImpl<IStreamingReporter> {
-
-        StreamingReporterBase( ReporterConfig const& _config )
-        :   m_config( _config.fullConfig() ),
-            stream( _config.stream() )
-        {}
-
-        virtual ~StreamingReporterBase();
-
-        virtual void noMatchingTestCases( std::string const& ) {}
-
-        virtual void testRunStarting( TestRunInfo const& _testRunInfo ) {
-            currentTestRunInfo = _testRunInfo;
-        }
-        virtual void testGroupStarting( GroupInfo const& _groupInfo ) {
-            currentGroupInfo = _groupInfo;
-        }
-
-        virtual void testCaseStarting( TestCaseInfo const& _testInfo ) {
-            currentTestCaseInfo = _testInfo;
-        }
-        virtual void sectionStarting( SectionInfo const& _sectionInfo ) {
-            m_sectionStack.push_back( _sectionInfo );
-        }
-
-        virtual void sectionEnded( SectionStats const& /* _sectionStats */ ) {
-            m_sectionStack.pop_back();
-        }
-        virtual void testCaseEnded( TestCaseStats const& /* _testCaseStats */ ) {
-            currentTestCaseInfo.reset();
-            assert( m_sectionStack.empty() );
-        }
-        virtual void testGroupEnded( TestGroupStats const& /* _testGroupStats */ ) {
-            currentGroupInfo.reset();
-        }
-        virtual void testRunEnded( TestRunStats const& /* _testRunStats */ ) {
-            currentTestCaseInfo.reset();
-            currentGroupInfo.reset();
-            currentTestRunInfo.reset();
-        }
-
-        virtual void skipTest( TestCaseInfo const& ) {
-            // Don't do anything with this by default.
-            // It can optionally be overridden in the derived class.
-        }
-
-        Ptr<IConfig> m_config;
-        std::ostream& stream;
-
-        LazyStat<TestRunInfo> currentTestRunInfo;
-        LazyStat<GroupInfo> currentGroupInfo;
-        LazyStat<TestCaseInfo> currentTestCaseInfo;
-
-        std::vector<SectionInfo> m_sectionStack;
-    };
-
-    struct CumulativeReporterBase : SharedImpl<IStreamingReporter> {
-        template<typename T, typename ChildNodeT>
-        struct Node : SharedImpl<> {
-            explicit Node( T const& _value ) : value( _value ) {}
-            virtual ~Node() {}
-
-            typedef std::vector<Ptr<ChildNodeT> > ChildNodes;
-            T value;
-            ChildNodes children;
-        };
-        struct SectionNode : SharedImpl<> {
-            explicit SectionNode( SectionStats const& _stats ) : stats( _stats ) {}
-            virtual ~SectionNode();
-
-            bool operator == ( SectionNode const& other ) const {
-                return stats.sectionInfo.lineInfo == other.stats.sectionInfo.lineInfo;
-            }
-            bool operator == ( Ptr<SectionNode> const& other ) const {
-                return operator==( *other );
-            }
-
-            SectionStats stats;
-            typedef std::vector<Ptr<SectionNode> > ChildSections;
-            typedef std::vector<AssertionStats> Assertions;
-            ChildSections childSections;
-            Assertions assertions;
-            std::string stdOut;
-            std::string stdErr;
-        };
-
-        struct BySectionInfo {
-            BySectionInfo( SectionInfo const& other ) : m_other( other ) {}
-			BySectionInfo( BySectionInfo const& other ) : m_other( other.m_other ) {}
-            bool operator() ( Ptr<SectionNode> const& node ) const {
-                return node->stats.sectionInfo.lineInfo == m_other.lineInfo;
-            }
-        private:
-			void operator=( BySectionInfo const& );
-            SectionInfo const& m_other;
-        };
-
-        typedef Node<TestCaseStats, SectionNode> TestCaseNode;
-        typedef Node<TestGroupStats, TestCaseNode> TestGroupNode;
-        typedef Node<TestRunStats, TestGroupNode> TestRunNode;
-
-        CumulativeReporterBase( ReporterConfig const& _config )
-        :   m_config( _config.fullConfig() ),
-            stream( _config.stream() )
-        {}
-        ~CumulativeReporterBase();
-
-        virtual void testRunStarting( TestRunInfo const& ) {}
-        virtual void testGroupStarting( GroupInfo const& ) {}
-
-        virtual void testCaseStarting( TestCaseInfo const& ) {}
-
-        virtual void sectionStarting( SectionInfo const& sectionInfo ) {
-            SectionStats incompleteStats( sectionInfo, Counts(), 0, false );
-            Ptr<SectionNode> node;
-            if( m_sectionStack.empty() ) {
-                if( !m_rootSection )
-                    m_rootSection = new SectionNode( incompleteStats );
-                node = m_rootSection;
-            }
-            else {
-                SectionNode& parentNode = *m_sectionStack.back();
-                SectionNode::ChildSections::const_iterator it =
-                    std::find_if(   parentNode.childSections.begin(),
-                                    parentNode.childSections.end(),
-                                    BySectionInfo( sectionInfo ) );
-                if( it == parentNode.childSections.end() ) {
-                    node = new SectionNode( incompleteStats );
-                    parentNode.childSections.push_back( node );
-                }
-                else
-                    node = *it;
-            }
-            m_sectionStack.push_back( node );
-            m_deepestSection = node;
-        }
-
-        virtual void assertionStarting( AssertionInfo const& ) {}
-
-        virtual bool assertionEnded( AssertionStats const& assertionStats ) {
-            assert( !m_sectionStack.empty() );
-            SectionNode& sectionNode = *m_sectionStack.back();
-            sectionNode.assertions.push_back( assertionStats );
-            return true;
-        }
-        virtual void sectionEnded( SectionStats const& sectionStats ) {
-            assert( !m_sectionStack.empty() );
-            SectionNode& node = *m_sectionStack.back();
-            node.stats = sectionStats;
-            m_sectionStack.pop_back();
-        }
-        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) {
-            Ptr<TestCaseNode> node = new TestCaseNode( testCaseStats );
-            assert( m_sectionStack.size() == 0 );
-            node->children.push_back( m_rootSection );
-            m_testCases.push_back( node );
-            m_rootSection.reset();
-
-            assert( m_deepestSection );
-            m_deepestSection->stdOut = testCaseStats.stdOut;
-            m_deepestSection->stdErr = testCaseStats.stdErr;
-        }
-        virtual void testGroupEnded( TestGroupStats const& testGroupStats ) {
-            Ptr<TestGroupNode> node = new TestGroupNode( testGroupStats );
-            node->children.swap( m_testCases );
-            m_testGroups.push_back( node );
-        }
-        virtual void testRunEnded( TestRunStats const& testRunStats ) {
-            Ptr<TestRunNode> node = new TestRunNode( testRunStats );
-            node->children.swap( m_testGroups );
-            m_testRuns.push_back( node );
-            testRunEndedCumulative();
-        }
-        virtual void testRunEndedCumulative() = 0;
-
-        virtual void skipTest( TestCaseInfo const& ) {}
-
-        Ptr<IConfig> m_config;
-        std::ostream& stream;
-        std::vector<AssertionStats> m_assertions;
-        std::vector<std::vector<Ptr<SectionNode> > > m_sections;
-        std::vector<Ptr<TestCaseNode> > m_testCases;
-        std::vector<Ptr<TestGroupNode> > m_testGroups;
-
-        std::vector<Ptr<TestRunNode> > m_testRuns;
-
-        Ptr<SectionNode> m_rootSection;
-        Ptr<SectionNode> m_deepestSection;
-        std::vector<Ptr<SectionNode> > m_sectionStack;
-
-    };
-
-    template<char C>
-    char const* getLineOfChars() {
-        static char line[CATCH_CONFIG_CONSOLE_WIDTH] = {0};
-        if( !*line ) {
-            memset( line, C, CATCH_CONFIG_CONSOLE_WIDTH-1 );
-            line[CATCH_CONFIG_CONSOLE_WIDTH-1] = 0;
-        }
-        return line;
-    }
-
-} // end namespace Catch
-
-// #included from: ../internal/catch_reporter_registrars.hpp
-#define TWOBLUECUBES_CATCH_REPORTER_REGISTRARS_HPP_INCLUDED
-
-namespace Catch {
-
-    template<typename T>
-    class LegacyReporterRegistrar {
-
-        class ReporterFactory : public IReporterFactory {
-            virtual IStreamingReporter* create( ReporterConfig const& config ) const {
-                return new LegacyReporterAdapter( new T( config ) );
-            }
-
-            virtual std::string getDescription() const {
-                return T::getDescription();
-            }
-        };
-
-    public:
-
-        LegacyReporterRegistrar( std::string const& name ) {
-            getMutableRegistryHub().registerReporter( name, new ReporterFactory() );
-        }
-    };
-
-    template<typename T>
-    class ReporterRegistrar {
-
-        class ReporterFactory : public IReporterFactory {
-
-            // *** Please Note ***:
-            // - If you end up here looking at a compiler error because it's trying to register
-            // your custom reporter class be aware that the native reporter interface has changed
-            // to IStreamingReporter. The "legacy" interface, IReporter, is still supported via
-            // an adapter. Just use REGISTER_LEGACY_REPORTER to take advantage of the adapter.
-            // However please consider updating to the new interface as the old one is now
-            // deprecated and will probably be removed quite soon!
-            // Please contact me via github if you have any questions at all about this.
-            // In fact, ideally, please contact me anyway to let me know you've hit this - as I have
-            // no idea who is actually using custom reporters at all (possibly no-one!).
-            // The new interface is designed to minimise exposure to interface changes in the future.
-            virtual IStreamingReporter* create( ReporterConfig const& config ) const {
-                return new T( config );
-            }
-
-            virtual std::string getDescription() const {
-                return T::getDescription();
-            }
-        };
-
-    public:
-
-        ReporterRegistrar( std::string const& name ) {
-            getMutableRegistryHub().registerReporter( name, new ReporterFactory() );
-        }
-    };
-}
-
-#define INTERNAL_CATCH_REGISTER_LEGACY_REPORTER( name, reporterType ) \
-    namespace{ Catch::LegacyReporterRegistrar<reporterType> catch_internal_RegistrarFor##reporterType( name ); }
-#define INTERNAL_CATCH_REGISTER_REPORTER( name, reporterType ) \
-    namespace{ Catch::ReporterRegistrar<reporterType> catch_internal_RegistrarFor##reporterType( name ); }
-
-// #included from: ../internal/catch_xmlwriter.hpp
-#define TWOBLUECUBES_CATCH_XMLWRITER_HPP_INCLUDED
-
-#include <sstream>
-#include <string>
-#include <vector>
-
-namespace Catch {
-
-    class XmlWriter {
-    public:
-
-        class ScopedElement {
-        public:
-            ScopedElement( XmlWriter* writer )
-            :   m_writer( writer )
-            {}
-
-            ScopedElement( ScopedElement const& other )
-            :   m_writer( other.m_writer ){
-                other.m_writer = NULL;
-            }
-
-            ~ScopedElement() {
-                if( m_writer )
-                    m_writer->endElement();
-            }
-
-            ScopedElement& writeText( std::string const& text, bool indent = true ) {
-                m_writer->writeText( text, indent );
-                return *this;
-            }
-
-            template<typename T>
-            ScopedElement& writeAttribute( std::string const& name, T const& attribute ) {
-                m_writer->writeAttribute( name, attribute );
-                return *this;
-            }
-
-        private:
-            mutable XmlWriter* m_writer;
-        };
-
-        XmlWriter()
-        :   m_tagIsOpen( false ),
-            m_needsNewline( false ),
-            m_os( &Catch::cout() )
-        {}
-
-        XmlWriter( std::ostream& os )
-        :   m_tagIsOpen( false ),
-            m_needsNewline( false ),
-            m_os( &os )
-        {}
-
-        ~XmlWriter() {
-            while( !m_tags.empty() )
-                endElement();
-        }
-
-//#  ifndef CATCH_CPP11_OR_GREATER
-//        XmlWriter& operator = ( XmlWriter const& other ) {
-//            XmlWriter temp( other );
-//            swap( temp );
-//            return *this;
-//        }
-//#  else
-//        XmlWriter( XmlWriter const& )              = default;
-//        XmlWriter( XmlWriter && )                  = default;
-//        XmlWriter& operator = ( XmlWriter const& ) = default;
-//        XmlWriter& operator = ( XmlWriter && )     = default;
-//#  endif
-//
-//        void swap( XmlWriter& other ) {
-//            std::swap( m_tagIsOpen, other.m_tagIsOpen );
-//            std::swap( m_needsNewline, other.m_needsNewline );
-//            std::swap( m_tags, other.m_tags );
-//            std::swap( m_indent, other.m_indent );
-//            std::swap( m_os, other.m_os );
-//        }
-
-        XmlWriter& startElement( std::string const& name ) {
-            ensureTagClosed();
-            newlineIfNecessary();
-            stream() << m_indent << "<" << name;
-            m_tags.push_back( name );
-            m_indent += "  ";
-            m_tagIsOpen = true;
-            return *this;
-        }
-
-        ScopedElement scopedElement( std::string const& name ) {
-            ScopedElement scoped( this );
-            startElement( name );
-            return scoped;
-        }
-
-        XmlWriter& endElement() {
-            newlineIfNecessary();
-            m_indent = m_indent.substr( 0, m_indent.size()-2 );
-            if( m_tagIsOpen ) {
-                stream() << "/>\n";
-                m_tagIsOpen = false;
-            }
-            else {
-                stream() << m_indent << "</" << m_tags.back() << ">\n";
-            }
-            m_tags.pop_back();
-            return *this;
-        }
-
-        XmlWriter& writeAttribute( std::string const& name, std::string const& attribute ) {
-            if( !name.empty() && !attribute.empty() ) {
-                stream() << " " << name << "=\"";
-                writeEncodedText( attribute );
-                stream() << "\"";
-            }
-            return *this;
-        }
-
-        XmlWriter& writeAttribute( std::string const& name, bool attribute ) {
-            stream() << " " << name << "=\"" << ( attribute ? "true" : "false" ) << "\"";
-            return *this;
-        }
-
-        template<typename T>
-        XmlWriter& writeAttribute( std::string const& name, T const& attribute ) {
-            if( !name.empty() )
-                stream() << " " << name << "=\"" << attribute << "\"";
-            return *this;
-        }
-
-        XmlWriter& writeText( std::string const& text, bool indent = true ) {
-            if( !text.empty() ){
-                bool tagWasOpen = m_tagIsOpen;
-                ensureTagClosed();
-                if( tagWasOpen && indent )
-                    stream() << m_indent;
-                writeEncodedText( text );
-                m_needsNewline = true;
-            }
-            return *this;
-        }
-
-        XmlWriter& writeComment( std::string const& text ) {
-            ensureTagClosed();
-            stream() << m_indent << "<!--" << text << "-->";
-            m_needsNewline = true;
-            return *this;
-        }
-
-        XmlWriter& writeBlankLine() {
-            ensureTagClosed();
-            stream() << "\n";
-            return *this;
-        }
-
-        void setStream( std::ostream& os ) {
-            m_os = &os;
-        }
-
-    private:
-        XmlWriter( XmlWriter const& );
-        void operator=( XmlWriter const& );
-
-        std::ostream& stream() {
-            return *m_os;
-        }
-
-        void ensureTagClosed() {
-            if( m_tagIsOpen ) {
-                stream() << ">\n";
-                m_tagIsOpen = false;
-            }
-        }
-
-        void newlineIfNecessary() {
-            if( m_needsNewline ) {
-                stream() << "\n";
-                m_needsNewline = false;
-            }
-        }
-
-        void writeEncodedText( std::string const& text ) {
-            static const char* charsToEncode = "<&\"";
-            std::string mtext = text;
-            std::string::size_type pos = mtext.find_first_of( charsToEncode );
-            while( pos != std::string::npos ) {
-                stream() << mtext.substr( 0, pos );
-
-                switch( mtext[pos] ) {
-                    case '<':
-                        stream() << "&lt;";
-                        break;
-                    case '&':
-                        stream() << "&amp;";
-                        break;
-                    case '\"':
-                        stream() << "&quot;";
-                        break;
-                }
-                mtext = mtext.substr( pos+1 );
-                pos = mtext.find_first_of( charsToEncode );
-            }
-            stream() << mtext;
-        }
-
-        bool m_tagIsOpen;
-        bool m_needsNewline;
-        std::vector<std::string> m_tags;
-        std::string m_indent;
-        std::ostream* m_os;
-    };
-
-}
-namespace Catch {
-    class XmlReporter : public StreamingReporterBase {
-    public:
-        XmlReporter( ReporterConfig const& _config )
-        :   StreamingReporterBase( _config ),
-            m_sectionDepth( 0 )
-        {}
-
-        virtual ~XmlReporter();
-
-        static std::string getDescription() {
-            return "Reports test results as an XML document";
-        }
-
-    public: // StreamingReporterBase
-        virtual ReporterPreferences getPreferences() const {
-            ReporterPreferences prefs;
-            prefs.shouldRedirectStdOut = true;
-            return prefs;
-        }
-
-        virtual void noMatchingTestCases( std::string const& s ) {
-            StreamingReporterBase::noMatchingTestCases( s );
-        }
-
-        virtual void testRunStarting( TestRunInfo const& testInfo ) {
-            StreamingReporterBase::testRunStarting( testInfo );
-            m_xml.setStream( stream );
-            m_xml.startElement( "Catch" );
-            if( !m_config->name().empty() )
-                m_xml.writeAttribute( "name", m_config->name() );
-        }
-
-        virtual void testGroupStarting( GroupInfo const& groupInfo ) {
-            StreamingReporterBase::testGroupStarting( groupInfo );
-            m_xml.startElement( "Group" )
-                .writeAttribute( "name", groupInfo.name );
-        }
-
-        virtual void testCaseStarting( TestCaseInfo const& testInfo ) {
-            StreamingReporterBase::testCaseStarting(testInfo);
-            m_xml.startElement( "TestCase" ).writeAttribute( "name", trim( testInfo.name ) );
-
-            if ( m_config->showDurations() == ShowDurations::Always )
-                m_testCaseTimer.start();
-        }
-
-        virtual void sectionStarting( SectionInfo const& sectionInfo ) {
-            StreamingReporterBase::sectionStarting( sectionInfo );
-            if( m_sectionDepth++ > 0 ) {
-                m_xml.startElement( "Section" )
-                    .writeAttribute( "name", trim( sectionInfo.name ) )
-                    .writeAttribute( "description", sectionInfo.description );
-            }
-        }
-
-        virtual void assertionStarting( AssertionInfo const& ) { }
-
-        virtual bool assertionEnded( AssertionStats const& assertionStats ) {
-            const AssertionResult& assertionResult = assertionStats.assertionResult;
-
-            // Print any info messages in <Info> tags.
-            if( assertionStats.assertionResult.getResultType() != ResultWas::Ok ) {
-                for( std::vector<MessageInfo>::const_iterator it = assertionStats.infoMessages.begin(), itEnd = assertionStats.infoMessages.end();
-                        it != itEnd;
-                        ++it ) {
-                    if( it->type == ResultWas::Info ) {
-                        m_xml.scopedElement( "Info" )
-                            .writeText( it->message );
-                    } else if ( it->type == ResultWas::Warning ) {
-                        m_xml.scopedElement( "Warning" )
-                            .writeText( it->message );
-                    }
-                }
-            }
-
-            // Drop out if result was successful but we're not printing them.
-            if( !m_config->includeSuccessfulResults() && isOk(assertionResult.getResultType()) )
-                return true;
-
-            // Print the expression if there is one.
-            if( assertionResult.hasExpression() ) {
-                m_xml.startElement( "Expression" )
-                    .writeAttribute( "success", assertionResult.succeeded() )
-					.writeAttribute( "type", assertionResult.getTestMacroName() )
-                    .writeAttribute( "filename", assertionResult.getSourceInfo().file )
-                    .writeAttribute( "line", assertionResult.getSourceInfo().line );
-
-                m_xml.scopedElement( "Original" )
-                    .writeText( assertionResult.getExpression() );
-                m_xml.scopedElement( "Expanded" )
-                    .writeText( assertionResult.getExpandedExpression() );
-            }
-
-            // And... Print a result applicable to each result type.
-            switch( assertionResult.getResultType() ) {
-                case ResultWas::ThrewException:
-                    m_xml.scopedElement( "Exception" )
-                        .writeAttribute( "filename", assertionResult.getSourceInfo().file )
-                        .writeAttribute( "line", assertionResult.getSourceInfo().line )
-                        .writeText( assertionResult.getMessage() );
-                    break;
-                case ResultWas::FatalErrorCondition:
-                    m_xml.scopedElement( "Fatal Error Condition" )
-                        .writeAttribute( "filename", assertionResult.getSourceInfo().file )
-                        .writeAttribute( "line", assertionResult.getSourceInfo().line )
-                        .writeText( assertionResult.getMessage() );
-                    break;
-                case ResultWas::Info:
-                    m_xml.scopedElement( "Info" )
-                        .writeText( assertionResult.getMessage() );
-                    break;
-                case ResultWas::Warning:
-                    // Warning will already have been written
-                    break;
-                case ResultWas::ExplicitFailure:
-                    m_xml.scopedElement( "Failure" )
-                        .writeText( assertionResult.getMessage() );
-                    break;
-                default:
-                    break;
-            }
-
-            if( assertionResult.hasExpression() )
-                m_xml.endElement();
-
-            return true;
-        }
-
-        virtual void sectionEnded( SectionStats const& sectionStats ) {
-            StreamingReporterBase::sectionEnded( sectionStats );
-            if( --m_sectionDepth > 0 ) {
-                XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResults" );
-                e.writeAttribute( "successes", sectionStats.assertions.passed );
-                e.writeAttribute( "failures", sectionStats.assertions.failed );
-                e.writeAttribute( "expectedFailures", sectionStats.assertions.failedButOk );
-
-                if ( m_config->showDurations() == ShowDurations::Always )
-                    e.writeAttribute( "durationInSeconds", sectionStats.durationInSeconds );
-
-                m_xml.endElement();
-            }
-        }
-
-        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) {
-            StreamingReporterBase::testCaseEnded( testCaseStats );
-            XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResult" );
-            e.writeAttribute( "success", testCaseStats.totals.assertions.allOk() );
-
-            if ( m_config->showDurations() == ShowDurations::Always )
-                e.writeAttribute( "durationInSeconds", m_testCaseTimer.getElapsedSeconds() );
-
-            m_xml.endElement();
-        }
-
-        virtual void testGroupEnded( TestGroupStats const& testGroupStats ) {
-            StreamingReporterBase::testGroupEnded( testGroupStats );
-            // TODO: Check testGroupStats.aborting and act accordingly.
-            m_xml.scopedElement( "OverallResults" )
-                .writeAttribute( "successes", testGroupStats.totals.assertions.passed )
-                .writeAttribute( "failures", testGroupStats.totals.assertions.failed )
-                .writeAttribute( "expectedFailures", testGroupStats.totals.assertions.failedButOk );
-            m_xml.endElement();
-        }
-
-        virtual void testRunEnded( TestRunStats const& testRunStats ) {
-            StreamingReporterBase::testRunEnded( testRunStats );
-            m_xml.scopedElement( "OverallResults" )
-                .writeAttribute( "successes", testRunStats.totals.assertions.passed )
-                .writeAttribute( "failures", testRunStats.totals.assertions.failed )
-                .writeAttribute( "expectedFailures", testRunStats.totals.assertions.failedButOk );
-            m_xml.endElement();
-        }
-
-    private:
-        Timer m_testCaseTimer;
-        XmlWriter m_xml;
-        int m_sectionDepth;
-    };
-
-     INTERNAL_CATCH_REGISTER_REPORTER( "xml", XmlReporter )
-
-} // end namespace Catch
-
-// #included from: ../reporters/catch_reporter_junit.hpp
-#define TWOBLUECUBES_CATCH_REPORTER_JUNIT_HPP_INCLUDED
-
-#include <assert.h>
-
-namespace Catch {
-
-    class JunitReporter : public CumulativeReporterBase {
-    public:
-        JunitReporter( ReporterConfig const& _config )
-        :   CumulativeReporterBase( _config ),
-            xml( _config.stream() )
-        {}
-
-        ~JunitReporter();
-
-        static std::string getDescription() {
-            return "Reports test results in an XML format that looks like Ant's junitreport target";
-        }
-
-        virtual void noMatchingTestCases( std::string const& /*spec*/ ) {}
-
-        virtual ReporterPreferences getPreferences() const {
-            ReporterPreferences prefs;
-            prefs.shouldRedirectStdOut = true;
-            return prefs;
-        }
-
-        virtual void testRunStarting( TestRunInfo const& runInfo ) {
-            CumulativeReporterBase::testRunStarting( runInfo );
-            xml.startElement( "testsuites" );
-        }
-
-        virtual void testGroupStarting( GroupInfo const& groupInfo ) {
-            suiteTimer.start();
-            stdOutForSuite.str("");
-            stdErrForSuite.str("");
-            unexpectedExceptions = 0;
-            CumulativeReporterBase::testGroupStarting( groupInfo );
-        }
-
-        virtual bool assertionEnded( AssertionStats const& assertionStats ) {
-            if( assertionStats.assertionResult.getResultType() == ResultWas::ThrewException )
-                unexpectedExceptions++;
-            return CumulativeReporterBase::assertionEnded( assertionStats );
-        }
-
-        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) {
-            stdOutForSuite << testCaseStats.stdOut;
-            stdErrForSuite << testCaseStats.stdErr;
-            CumulativeReporterBase::testCaseEnded( testCaseStats );
-        }
-
-        virtual void testGroupEnded( TestGroupStats const& testGroupStats ) {
-            double suiteTime = suiteTimer.getElapsedSeconds();
-            CumulativeReporterBase::testGroupEnded( testGroupStats );
-            writeGroup( *m_testGroups.back(), suiteTime );
-        }
-
-        virtual void testRunEndedCumulative() {
-            xml.endElement();
-        }
-
-        void writeGroup( TestGroupNode const& groupNode, double suiteTime ) {
-            XmlWriter::ScopedElement e = xml.scopedElement( "testsuite" );
-            TestGroupStats const& stats = groupNode.value;
-            xml.writeAttribute( "name", stats.groupInfo.name );
-            xml.writeAttribute( "errors", unexpectedExceptions );
-            xml.writeAttribute( "failures", stats.totals.assertions.failed-unexpectedExceptions );
-            xml.writeAttribute( "tests", stats.totals.assertions.total() );
-            xml.writeAttribute( "hostname", "tbd" ); // !TBD
-            if( m_config->showDurations() == ShowDurations::Never )
-                xml.writeAttribute( "time", "" );
-            else
-                xml.writeAttribute( "time", suiteTime );
-            xml.writeAttribute( "timestamp", "tbd" ); // !TBD
-
-            // Write test cases
-            for( TestGroupNode::ChildNodes::const_iterator
-                    it = groupNode.children.begin(), itEnd = groupNode.children.end();
-                    it != itEnd;
-                    ++it )
-                writeTestCase( **it );
-
-            xml.scopedElement( "system-out" ).writeText( trim( stdOutForSuite.str() ), false );
-            xml.scopedElement( "system-err" ).writeText( trim( stdErrForSuite.str() ), false );
-        }
-
-        void writeTestCase( TestCaseNode const& testCaseNode ) {
-            TestCaseStats const& stats = testCaseNode.value;
-
-            // All test cases have exactly one section - which represents the
-            // test case itself. That section may have 0-n nested sections
-            assert( testCaseNode.children.size() == 1 );
-            SectionNode const& rootSection = *testCaseNode.children.front();
-
-            std::string className = stats.testInfo.className;
-
-            if( className.empty() ) {
-                if( rootSection.childSections.empty() )
-                    className = "global";
-            }
-            writeSection( className, "", rootSection );
-        }
-
-        void writeSection(  std::string const& className,
-                            std::string const& rootName,
-                            SectionNode const& sectionNode ) {
-            std::string name = trim( sectionNode.stats.sectionInfo.name );
-            if( !rootName.empty() )
-                name = rootName + "/" + name;
-
-            if( !sectionNode.assertions.empty() ||
-                !sectionNode.stdOut.empty() ||
-                !sectionNode.stdErr.empty() ) {
-                XmlWriter::ScopedElement e = xml.scopedElement( "testcase" );
-                if( className.empty() ) {
-                    xml.writeAttribute( "classname", name );
-                    xml.writeAttribute( "name", "root" );
-                }
-                else {
-                    xml.writeAttribute( "classname", className );
-                    xml.writeAttribute( "name", name );
-                }
-                xml.writeAttribute( "time", Catch::toString( sectionNode.stats.durationInSeconds ) );
-
-                writeAssertions( sectionNode );
-
-                if( !sectionNode.stdOut.empty() )
-                    xml.scopedElement( "system-out" ).writeText( trim( sectionNode.stdOut ), false );
-                if( !sectionNode.stdErr.empty() )
-                    xml.scopedElement( "system-err" ).writeText( trim( sectionNode.stdErr ), false );
-            }
-            for( SectionNode::ChildSections::const_iterator
-                    it = sectionNode.childSections.begin(),
-                    itEnd = sectionNode.childSections.end();
-                    it != itEnd;
-                    ++it )
-                if( className.empty() )
-                    writeSection( name, "", **it );
-                else
-                    writeSection( className, name, **it );
-        }
-
-        void writeAssertions( SectionNode const& sectionNode ) {
-            for( SectionNode::Assertions::const_iterator
-                    it = sectionNode.assertions.begin(), itEnd = sectionNode.assertions.end();
-                    it != itEnd;
-                    ++it )
-                writeAssertion( *it );
-        }
-        void writeAssertion( AssertionStats const& stats ) {
-            AssertionResult const& result = stats.assertionResult;
-            if( !result.isOk() ) {
-                std::string elementName;
-                switch( result.getResultType() ) {
-                    case ResultWas::ThrewException:
-                    case ResultWas::FatalErrorCondition:
-                        elementName = "error";
-                        break;
-                    case ResultWas::ExplicitFailure:
-                        elementName = "failure";
-                        break;
-                    case ResultWas::ExpressionFailed:
-                        elementName = "failure";
-                        break;
-                    case ResultWas::DidntThrowException:
-                        elementName = "failure";
-                        break;
-
-                    // We should never see these here:
-                    case ResultWas::Info:
-                    case ResultWas::Warning:
-                    case ResultWas::Ok:
-                    case ResultWas::Unknown:
-                    case ResultWas::FailureBit:
-                    case ResultWas::Exception:
-                        elementName = "internalError";
-                        break;
-                }
-
-                XmlWriter::ScopedElement e = xml.scopedElement( elementName );
-
-                xml.writeAttribute( "message", result.getExpandedExpression() );
-                xml.writeAttribute( "type", result.getTestMacroName() );
-
-                std::ostringstream oss;
-                if( !result.getMessage().empty() )
-                    oss << result.getMessage() << "\n";
-                for( std::vector<MessageInfo>::const_iterator
-                        it = stats.infoMessages.begin(),
-                        itEnd = stats.infoMessages.end();
-                            it != itEnd;
-                            ++it )
-                    if( it->type == ResultWas::Info )
-                        oss << it->message << "\n";
-
-                oss << "at " << result.getSourceInfo();
-                xml.writeText( oss.str(), false );
-            }
-        }
-
-        XmlWriter xml;
-        Timer suiteTimer;
-        std::ostringstream stdOutForSuite;
-        std::ostringstream stdErrForSuite;
-        unsigned int unexpectedExceptions;
-    };
-
-    INTERNAL_CATCH_REGISTER_REPORTER( "junit", JunitReporter )
-
-} // end namespace Catch
-
-// #included from: ../reporters/catch_reporter_console.hpp
-#define TWOBLUECUBES_CATCH_REPORTER_CONSOLE_HPP_INCLUDED
-
-namespace Catch {
-
-    struct ConsoleReporter : StreamingReporterBase {
-        ConsoleReporter( ReporterConfig const& _config )
-        :   StreamingReporterBase( _config ),
-            m_headerPrinted( false )
-        {}
-
-        virtual ~ConsoleReporter();
-        static std::string getDescription() {
-            return "Reports test results as plain lines of text";
-        }
-        virtual ReporterPreferences getPreferences() const {
-            ReporterPreferences prefs;
-            prefs.shouldRedirectStdOut = false;
-            return prefs;
-        }
-
-        virtual void noMatchingTestCases( std::string const& spec ) {
-            stream << "No test cases matched '" << spec << "'" << std::endl;
-        }
-
-        virtual void assertionStarting( AssertionInfo const& ) {
-        }
-
-        virtual bool assertionEnded( AssertionStats const& _assertionStats ) {
-            AssertionResult const& result = _assertionStats.assertionResult;
-
-            bool printInfoMessages = true;
-
-            // Drop out if result was successful and we're not printing those
-            if( !m_config->includeSuccessfulResults() && result.isOk() ) {
-                if( result.getResultType() != ResultWas::Warning )
-                    return false;
-                printInfoMessages = false;
-            }
-
-            lazyPrint();
-
-            AssertionPrinter printer( stream, _assertionStats, printInfoMessages );
-            printer.print();
-            stream << std::endl;
-            return true;
-        }
-
-        virtual void sectionStarting( SectionInfo const& _sectionInfo ) {
-            m_headerPrinted = false;
-            StreamingReporterBase::sectionStarting( _sectionInfo );
-        }
-        virtual void sectionEnded( SectionStats const& _sectionStats ) {
-            if( _sectionStats.missingAssertions ) {
-                lazyPrint();
-                Colour colour( Colour::ResultError );
-                if( m_sectionStack.size() > 1 )
-                    stream << "\nNo assertions in section";
-                else
-                    stream << "\nNo assertions in test case";
-                stream << " '" << _sectionStats.sectionInfo.name << "'\n" << std::endl;
-            }
-            if( m_headerPrinted ) {
-                if( m_config->showDurations() == ShowDurations::Always )
-                    stream << "Completed in " << _sectionStats.durationInSeconds << "s" << std::endl;
-                m_headerPrinted = false;
-            }
-            else {
-                if( m_config->showDurations() == ShowDurations::Always )
-                    stream << _sectionStats.sectionInfo.name << " completed in " << _sectionStats.durationInSeconds << "s" << std::endl;
-            }
-            StreamingReporterBase::sectionEnded( _sectionStats );
-        }
-
-        virtual void testCaseEnded( TestCaseStats const& _testCaseStats ) {
-            StreamingReporterBase::testCaseEnded( _testCaseStats );
-            m_headerPrinted = false;
-        }
-        virtual void testGroupEnded( TestGroupStats const& _testGroupStats ) {
-            if( currentGroupInfo.used ) {
-                printSummaryDivider();
-                stream << "Summary for group '" << _testGroupStats.groupInfo.name << "':\n";
-                printTotals( _testGroupStats.totals );
-                stream << "\n" << std::endl;
-            }
-            StreamingReporterBase::testGroupEnded( _testGroupStats );
-        }
-        virtual void testRunEnded( TestRunStats const& _testRunStats ) {
-            printTotalsDivider( _testRunStats.totals );
-            printTotals( _testRunStats.totals );
-            stream << std::endl;
-            StreamingReporterBase::testRunEnded( _testRunStats );
-        }
-
-    private:
-
-        class AssertionPrinter {
-            void operator= ( AssertionPrinter const& );
-        public:
-            AssertionPrinter( std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages )
-            :   stream( _stream ),
-                stats( _stats ),
-                result( _stats.assertionResult ),
-                colour( Colour::None ),
-                message( result.getMessage() ),
-                messages( _stats.infoMessages ),
-                printInfoMessages( _printInfoMessages )
-            {
-                switch( result.getResultType() ) {
-                    case ResultWas::Ok:
-                        colour = Colour::Success;
-                        passOrFail = "PASSED";
-                        //if( result.hasMessage() )
-                        if( _stats.infoMessages.size() == 1 )
-                            messageLabel = "with message";
-                        if( _stats.infoMessages.size() > 1 )
-                            messageLabel = "with messages";
-                        break;
-                    case ResultWas::ExpressionFailed:
-                        if( result.isOk() ) {
-                            colour = Colour::Success;
-                            passOrFail = "FAILED - but was ok";
-                        }
-                        else {
-                            colour = Colour::Error;
-                            passOrFail = "FAILED";
-                        }
-                        if( _stats.infoMessages.size() == 1 )
-                            messageLabel = "with message";
-                        if( _stats.infoMessages.size() > 1 )
-                            messageLabel = "with messages";
-                        break;
-                    case ResultWas::ThrewException:
-                        colour = Colour::Error;
-                        passOrFail = "FAILED";
-                        messageLabel = "due to unexpected exception with message";
-                        break;
-                    case ResultWas::FatalErrorCondition:
-                        colour = Colour::Error;
-                        passOrFail = "FAILED";
-                        messageLabel = "due to a fatal error condition";
-                        break;
-                    case ResultWas::DidntThrowException:
-                        colour = Colour::Error;
-                        passOrFail = "FAILED";
-                        messageLabel = "because no exception was thrown where one was expected";
-                        break;
-                    case ResultWas::Info:
-                        messageLabel = "info";
-                        break;
-                    case ResultWas::Warning:
-                        messageLabel = "warning";
-                        break;
-                    case ResultWas::ExplicitFailure:
-                        passOrFail = "FAILED";
-                        colour = Colour::Error;
-                        if( _stats.infoMessages.size() == 1 )
-                            messageLabel = "explicitly with message";
-                        if( _stats.infoMessages.size() > 1 )
-                            messageLabel = "explicitly with messages";
-                        break;
-                    // These cases are here to prevent compiler warnings
-                    case ResultWas::Unknown:
-                    case ResultWas::FailureBit:
-                    case ResultWas::Exception:
-                        passOrFail = "** internal error **";
-                        colour = Colour::Error;
-                        break;
-                }
-            }
-
-            void print() const {
-                printSourceInfo();
-                if( stats.totals.assertions.total() > 0 ) {
-                    if( result.isOk() )
-                        stream << "\n";
-                    printResultType();
-                    printOriginalExpression();
-                    printReconstructedExpression();
-                }
-                else {
-                    stream << "\n";
-                }
-                printMessage();
-            }
-
-        private:
-            void printResultType() const {
-                if( !passOrFail.empty() ) {
-                    Colour colourGuard( colour );
-                    stream << passOrFail << ":\n";
-                }
-            }
-            void printOriginalExpression() const {
-                if( result.hasExpression() ) {
-                    Colour colourGuard( Colour::OriginalExpression );
-                    stream  << "  ";
-                    stream << result.getExpressionInMacro();
-                    stream << "\n";
-                }
-            }
-            void printReconstructedExpression() const {
-                if( result.hasExpandedExpression() ) {
-                    stream << "with expansion:\n";
-                    Colour colourGuard( Colour::ReconstructedExpression );
-                    stream << Text( result.getExpandedExpression(), TextAttributes().setIndent(2) ) << "\n";
-                }
-            }
-            void printMessage() const {
-                if( !messageLabel.empty() )
-                    stream << messageLabel << ":" << "\n";
-                for( std::vector<MessageInfo>::const_iterator it = messages.begin(), itEnd = messages.end();
-                        it != itEnd;
-                        ++it ) {
-                    // If this assertion is a warning ignore any INFO messages
-                    if( printInfoMessages || it->type != ResultWas::Info )
-                        stream << Text( it->message, TextAttributes().setIndent(2) ) << "\n";
-                }
-            }
-            void printSourceInfo() const {
-                Colour colourGuard( Colour::FileName );
-                stream << result.getSourceInfo() << ": ";
-            }
-
-            std::ostream& stream;
-            AssertionStats const& stats;
-            AssertionResult const& result;
-            Colour::Code colour;
-            std::string passOrFail;
-            std::string messageLabel;
-            std::string message;
-            std::vector<MessageInfo> messages;
-            bool printInfoMessages;
-        };
-
-        void lazyPrint() {
-
-            if( !currentTestRunInfo.used )
-                lazyPrintRunInfo();
-            if( !currentGroupInfo.used )
-                lazyPrintGroupInfo();
-
-            if( !m_headerPrinted ) {
-                printTestCaseAndSectionHeader();
-                m_headerPrinted = true;
-            }
-        }
-        void lazyPrintRunInfo() {
-            stream  << "\n" << getLineOfChars<'~'>() << "\n";
-            Colour colour( Colour::SecondaryText );
-            stream  << currentTestRunInfo->name
-                    << " is a Catch v"  << libraryVersion.majorVersion << "."
-                    << libraryVersion.minorVersion << " b"
-                    << libraryVersion.buildNumber;
-            if( libraryVersion.branchName != std::string( "master" ) )
-                stream << " (" << libraryVersion.branchName << ")";
-            stream  << " host application.\n"
-                    << "Run with -? for options\n\n";
-
-            if( m_config->rngSeed() != 0 )
-                stream << "Randomness seeded to: " << m_config->rngSeed() << "\n\n";
-
-            currentTestRunInfo.used = true;
-        }
-        void lazyPrintGroupInfo() {
-            if( !currentGroupInfo->name.empty() && currentGroupInfo->groupsCounts > 1 ) {
-                printClosedHeader( "Group: " + currentGroupInfo->name );
-                currentGroupInfo.used = true;
-            }
-        }
-        void printTestCaseAndSectionHeader() {
-            assert( !m_sectionStack.empty() );
-            printOpenHeader( currentTestCaseInfo->name );
-
-            if( m_sectionStack.size() > 1 ) {
-                Colour colourGuard( Colour::Headers );
-
-                std::vector<SectionInfo>::const_iterator
-                    it = m_sectionStack.begin()+1, // Skip first section (test case)
-                    itEnd = m_sectionStack.end();
-                for( ; it != itEnd; ++it )
-                    printHeaderString( it->name, 2 );
-            }
-
-            SourceLineInfo lineInfo = m_sectionStack.front().lineInfo;
-
-            if( !lineInfo.empty() ){
-                stream << getLineOfChars<'-'>() << "\n";
-                Colour colourGuard( Colour::FileName );
-                stream << lineInfo << "\n";
-            }
-            stream << getLineOfChars<'.'>() << "\n" << std::endl;
-        }
-
-        void printClosedHeader( std::string const& _name ) {
-            printOpenHeader( _name );
-            stream << getLineOfChars<'.'>() << "\n";
-        }
-        void printOpenHeader( std::string const& _name ) {
-            stream  << getLineOfChars<'-'>() << "\n";
-            {
-                Colour colourGuard( Colour::Headers );
-                printHeaderString( _name );
-            }
-        }
-
-        // if string has a : in first line will set indent to follow it on
-        // subsequent lines
-        void printHeaderString( std::string const& _string, std::size_t indent = 0 ) {
-            std::size_t i = _string.find( ": " );
-            if( i != std::string::npos )
-                i+=2;
-            else
-                i = 0;
-            stream << Text( _string, TextAttributes()
-                                        .setIndent( indent+i)
-                                        .setInitialIndent( indent ) ) << "\n";
-        }
-
-        struct SummaryColumn {
-
-            SummaryColumn( std::string const& _label, Colour::Code _colour )
-            :   label( _label ),
-                colour( _colour )
-            {}
-            SummaryColumn addRow( std::size_t count ) {
-                std::ostringstream oss;
-                oss << count;
-                std::string row = oss.str();
-                for( std::vector<std::string>::iterator it = rows.begin(); it != rows.end(); ++it ) {
-                    while( it->size() < row.size() )
-                        *it = " " + *it;
-                    while( it->size() > row.size() )
-                        row = " " + row;
-                }
-                rows.push_back( row );
-                return *this;
-            }
-
-            std::string label;
-            Colour::Code colour;
-            std::vector<std::string> rows;
-
-        };
-
-        void printTotals( Totals const& totals ) {
-            if( totals.testCases.total() == 0 ) {
-                stream << Colour( Colour::Warning ) << "No tests ran\n";
-            }
-            else if( totals.assertions.total() > 0 && totals.assertions.allPassed() ) {
-                stream << Colour( Colour::ResultSuccess ) << "All tests passed";
-                stream << " ("
-                        << pluralise( totals.assertions.passed, "assertion" ) << " in "
-                        << pluralise( totals.testCases.passed, "test case" ) << ")"
-                        << "\n";
-            }
-            else {
-
-                std::vector<SummaryColumn> columns;
-                columns.push_back( SummaryColumn( "", Colour::None )
-                                        .addRow( totals.testCases.total() )
-                                        .addRow( totals.assertions.total() ) );
-                columns.push_back( SummaryColumn( "passed", Colour::Success )
-                                        .addRow( totals.testCases.passed )
-                                        .addRow( totals.assertions.passed ) );
-                columns.push_back( SummaryColumn( "failed", Colour::ResultError )
-                                        .addRow( totals.testCases.failed )
-                                        .addRow( totals.assertions.failed ) );
-                columns.push_back( SummaryColumn( "failed as expected", Colour::ResultExpectedFailure )
-                                        .addRow( totals.testCases.failedButOk )
-                                        .addRow( totals.assertions.failedButOk ) );
-
-                printSummaryRow( "test cases", columns, 0 );
-                printSummaryRow( "assertions", columns, 1 );
-            }
-        }
-        void printSummaryRow( std::string const& label, std::vector<SummaryColumn> const& cols, std::size_t row ) {
-            for( std::vector<SummaryColumn>::const_iterator it = cols.begin(); it != cols.end(); ++it ) {
-                std::string value = it->rows[row];
-                if( it->label.empty() ) {
-                    stream << label << ": ";
-                    if( value != "0" )
-                        stream << value;
-                    else
-                        stream << Colour( Colour::Warning ) << "- none -";
-                }
-                else if( value != "0" ) {
-                    stream  << Colour( Colour::LightGrey ) << " | ";
-                    stream  << Colour( it->colour )
-                            << value << " " << it->label;
-                }
-            }
-            stream << "\n";
-        }
-
-        static std::size_t makeRatio( std::size_t number, std::size_t total ) {
-            std::size_t ratio = total > 0 ? CATCH_CONFIG_CONSOLE_WIDTH * number/ total : 0;
-            return ( ratio == 0 && number > 0 ) ? 1 : ratio;
-        }
-        static std::size_t& findMax( std::size_t& i, std::size_t& j, std::size_t& k ) {
-            if( i > j && i > k )
-                return i;
-            else if( j > k )
-                return j;
-            else
-                return k;
-        }
-
-        void printTotalsDivider( Totals const& totals ) {
-            if( totals.testCases.total() > 0 ) {
-                std::size_t failedRatio = makeRatio( totals.testCases.failed, totals.testCases.total() );
-                std::size_t failedButOkRatio = makeRatio( totals.testCases.failedButOk, totals.testCases.total() );
-                std::size_t passedRatio = makeRatio( totals.testCases.passed, totals.testCases.total() );
-                while( failedRatio + failedButOkRatio + passedRatio < CATCH_CONFIG_CONSOLE_WIDTH-1 )
-                    findMax( failedRatio, failedButOkRatio, passedRatio )++;
-                while( failedRatio + failedButOkRatio + passedRatio > CATCH_CONFIG_CONSOLE_WIDTH-1 )
-                    findMax( failedRatio, failedButOkRatio, passedRatio )--;
-
-                stream << Colour( Colour::Error ) << std::string( failedRatio, '=' );
-                stream << Colour( Colour::ResultExpectedFailure ) << std::string( failedButOkRatio, '=' );
-                if( totals.testCases.allPassed() )
-                    stream << Colour( Colour::ResultSuccess ) << std::string( passedRatio, '=' );
-                else
-                    stream << Colour( Colour::Success ) << std::string( passedRatio, '=' );
-            }
-            else {
-                stream << Colour( Colour::Warning ) << std::string( CATCH_CONFIG_CONSOLE_WIDTH-1, '=' );
-            }
-            stream << "\n";
-        }
-        void printSummaryDivider() {
-            stream << getLineOfChars<'-'>() << "\n";
-        }
-
-    private:
-        bool m_headerPrinted;
-    };
-
-    INTERNAL_CATCH_REGISTER_REPORTER( "console", ConsoleReporter )
-
-} // end namespace Catch
-
-// #included from: ../reporters/catch_reporter_compact.hpp
-#define TWOBLUECUBES_CATCH_REPORTER_COMPACT_HPP_INCLUDED
-
-namespace Catch {
-
-    struct CompactReporter : StreamingReporterBase {
-
-        CompactReporter( ReporterConfig const& _config )
-        : StreamingReporterBase( _config )
-        {}
-
-        virtual ~CompactReporter();
-
-        static std::string getDescription() {
-            return "Reports test results on a single line, suitable for IDEs";
-        }
-
-        virtual ReporterPreferences getPreferences() const {
-            ReporterPreferences prefs;
-            prefs.shouldRedirectStdOut = false;
-            return prefs;
-        }
-
-        virtual void noMatchingTestCases( std::string const& spec ) {
-            stream << "No test cases matched '" << spec << "'" << std::endl;
-        }
-
-        virtual void assertionStarting( AssertionInfo const& ) {
-        }
-
-        virtual bool assertionEnded( AssertionStats const& _assertionStats ) {
-            AssertionResult const& result = _assertionStats.assertionResult;
-
-            bool printInfoMessages = true;
-
-            // Drop out if result was successful and we're not printing those
-            if( !m_config->includeSuccessfulResults() && result.isOk() ) {
-                if( result.getResultType() != ResultWas::Warning )
-                    return false;
-                printInfoMessages = false;
-            }
-
-            AssertionPrinter printer( stream, _assertionStats, printInfoMessages );
-            printer.print();
-
-            stream << std::endl;
-            return true;
-        }
-
-        virtual void testRunEnded( TestRunStats const& _testRunStats ) {
-            printTotals( _testRunStats.totals );
-            stream << "\n" << std::endl;
-            StreamingReporterBase::testRunEnded( _testRunStats );
-        }
-
-    private:
-        class AssertionPrinter {
-            void operator= ( AssertionPrinter const& );
-        public:
-            AssertionPrinter( std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages )
-            : stream( _stream )
-            , stats( _stats )
-            , result( _stats.assertionResult )
-            , messages( _stats.infoMessages )
-            , itMessage( _stats.infoMessages.begin() )
-            , printInfoMessages( _printInfoMessages )
-            {}
-
-            void print() {
-                printSourceInfo();
-
-                itMessage = messages.begin();
-
-                switch( result.getResultType() ) {
-                    case ResultWas::Ok:
-                        printResultType( Colour::ResultSuccess, passedString() );
-                        printOriginalExpression();
-                        printReconstructedExpression();
-                        if ( ! result.hasExpression() )
-                            printRemainingMessages( Colour::None );
-                        else
-                            printRemainingMessages();
-                        break;
-                    case ResultWas::ExpressionFailed:
-                        if( result.isOk() )
-                            printResultType( Colour::ResultSuccess, failedString() + std::string( " - but was ok" ) );
-                        else
-                            printResultType( Colour::Error, failedString() );
-                        printOriginalExpression();
-                        printReconstructedExpression();
-                        printRemainingMessages();
-                        break;
-                    case ResultWas::ThrewException:
-                        printResultType( Colour::Error, failedString() );
-                        printIssue( "unexpected exception with message:" );
-                        printMessage();
-                        printExpressionWas();
-                        printRemainingMessages();
-                        break;
-                    case ResultWas::FatalErrorCondition:
-                        printResultType( Colour::Error, failedString() );
-                        printIssue( "fatal error condition with message:" );
-                        printMessage();
-                        printExpressionWas();
-                        printRemainingMessages();
-                        break;
-                    case ResultWas::DidntThrowException:
-                        printResultType( Colour::Error, failedString() );
-                        printIssue( "expected exception, got none" );
-                        printExpressionWas();
-                        printRemainingMessages();
-                        break;
-                    case ResultWas::Info:
-                        printResultType( Colour::None, "info" );
-                        printMessage();
-                        printRemainingMessages();
-                        break;
-                    case ResultWas::Warning:
-                        printResultType( Colour::None, "warning" );
-                        printMessage();
-                        printRemainingMessages();
-                        break;
-                    case ResultWas::ExplicitFailure:
-                        printResultType( Colour::Error, failedString() );
-                        printIssue( "explicitly" );
-                        printRemainingMessages( Colour::None );
-                        break;
-                    // These cases are here to prevent compiler warnings
-                    case ResultWas::Unknown:
-                    case ResultWas::FailureBit:
-                    case ResultWas::Exception:
-                        printResultType( Colour::Error, "** internal error **" );
-                        break;
-                }
-            }
-
-        private:
-            // Colour::LightGrey
-
-            static Colour::Code dimColour() { return Colour::FileName; }
-
-#ifdef CATCH_PLATFORM_MAC
-            static const char* failedString() { return "FAILED"; }
-            static const char* passedString() { return "PASSED"; }
-#else
-            static const char* failedString() { return "failed"; }
-            static const char* passedString() { return "passed"; }
-#endif
-
-            void printSourceInfo() const {
-                Colour colourGuard( Colour::FileName );
-                stream << result.getSourceInfo() << ":";
-            }
-
-            void printResultType( Colour::Code colour, std::string passOrFail ) const {
-                if( !passOrFail.empty() ) {
-                    {
-                        Colour colourGuard( colour );
-                        stream << " " << passOrFail;
-                    }
-                    stream << ":";
-                }
-            }
-
-            void printIssue( std::string issue ) const {
-                stream << " " << issue;
-            }
-
-            void printExpressionWas() {
-                if( result.hasExpression() ) {
-                    stream << ";";
-                    {
-                        Colour colour( dimColour() );
-                        stream << " expression was:";
-                    }
-                    printOriginalExpression();
-                }
-            }
-
-            void printOriginalExpression() const {
-                if( result.hasExpression() ) {
-                    stream << " " << result.getExpression();
-                }
-            }
-
-            void printReconstructedExpression() const {
-                if( result.hasExpandedExpression() ) {
-                    {
-                        Colour colour( dimColour() );
-                        stream << " for: ";
-                    }
-                    stream << result.getExpandedExpression();
-                }
-            }
-
-            void printMessage() {
-                if ( itMessage != messages.end() ) {
-                    stream << " '" << itMessage->message << "'";
-                    ++itMessage;
-                }
-            }
-
-            void printRemainingMessages( Colour::Code colour = dimColour() ) {
-                if ( itMessage == messages.end() )
-                    return;
-
-                // using messages.end() directly yields compilation error:
-                std::vector<MessageInfo>::const_iterator itEnd = messages.end();
-                const std::size_t N = static_cast<std::size_t>( std::distance( itMessage, itEnd ) );
-
-                {
-                    Colour colourGuard( colour );
-                    stream << " with " << pluralise( N, "message" ) << ":";
-                }
-
-                for(; itMessage != itEnd; ) {
-                    // If this assertion is a warning ignore any INFO messages
-                    if( printInfoMessages || itMessage->type != ResultWas::Info ) {
-                        stream << " '" << itMessage->message << "'";
-                        if ( ++itMessage != itEnd ) {
-                            Colour colourGuard( dimColour() );
-                            stream << " and";
-                        }
-                    }
-                }
-            }
-
-        private:
-            std::ostream& stream;
-            AssertionStats const& stats;
-            AssertionResult const& result;
-            std::vector<MessageInfo> messages;
-            std::vector<MessageInfo>::const_iterator itMessage;
-            bool printInfoMessages;
-        };
-
-        // Colour, message variants:
-        // - white: No tests ran.
-        // -   red: Failed [both/all] N test cases, failed [both/all] M assertions.
-        // - white: Passed [both/all] N test cases (no assertions).
-        // -   red: Failed N tests cases, failed M assertions.
-        // - green: Passed [both/all] N tests cases with M assertions.
-
-        std::string bothOrAll( std::size_t count ) const {
-            return count == 1 ? "" : count == 2 ? "both " : "all " ;
-        }
-
-        void printTotals( const Totals& totals ) const {
-            if( totals.testCases.total() == 0 ) {
-                stream << "No tests ran.";
-            }
-            else if( totals.testCases.failed == totals.testCases.total() ) {
-                Colour colour( Colour::ResultError );
-                const std::string qualify_assertions_failed =
-                    totals.assertions.failed == totals.assertions.total() ?
-                        bothOrAll( totals.assertions.failed ) : "";
-                stream <<
-                    "Failed " << bothOrAll( totals.testCases.failed )
-                              << pluralise( totals.testCases.failed, "test case"  ) << ", "
-                    "failed " << qualify_assertions_failed <<
-                                 pluralise( totals.assertions.failed, "assertion" ) << ".";
-            }
-            else if( totals.assertions.total() == 0 ) {
-                stream <<
-                    "Passed " << bothOrAll( totals.testCases.total() )
-                              << pluralise( totals.testCases.total(), "test case" )
-                              << " (no assertions).";
-            }
-            else if( totals.assertions.failed ) {
-                Colour colour( Colour::ResultError );
-                stream <<
-                    "Failed " << pluralise( totals.testCases.failed, "test case"  ) << ", "
-                    "failed " << pluralise( totals.assertions.failed, "assertion" ) << ".";
-            }
-            else {
-                Colour colour( Colour::ResultSuccess );
-                stream <<
-                    "Passed " << bothOrAll( totals.testCases.passed )
-                              << pluralise( totals.testCases.passed, "test case"  ) <<
-                    " with "  << pluralise( totals.assertions.passed, "assertion" ) << ".";
-            }
-        }
-    };
-
-    INTERNAL_CATCH_REGISTER_REPORTER( "compact", CompactReporter )
-
-} // end namespace Catch
-
-namespace Catch {
-    NonCopyable::~NonCopyable() {}
-    IShared::~IShared() {}
-    StreamBufBase::~StreamBufBase() CATCH_NOEXCEPT {}
-    IContext::~IContext() {}
-    IResultCapture::~IResultCapture() {}
-    ITestCase::~ITestCase() {}
-    ITestCaseRegistry::~ITestCaseRegistry() {}
-    IRegistryHub::~IRegistryHub() {}
-    IMutableRegistryHub::~IMutableRegistryHub() {}
-    IExceptionTranslator::~IExceptionTranslator() {}
-    IExceptionTranslatorRegistry::~IExceptionTranslatorRegistry() {}
-    IReporter::~IReporter() {}
-    IReporterFactory::~IReporterFactory() {}
-    IReporterRegistry::~IReporterRegistry() {}
-    IStreamingReporter::~IStreamingReporter() {}
-    AssertionStats::~AssertionStats() {}
-    SectionStats::~SectionStats() {}
-    TestCaseStats::~TestCaseStats() {}
-    TestGroupStats::~TestGroupStats() {}
-    TestRunStats::~TestRunStats() {}
-    CumulativeReporterBase::SectionNode::~SectionNode() {}
-    CumulativeReporterBase::~CumulativeReporterBase() {}
-
-    StreamingReporterBase::~StreamingReporterBase() {}
-    ConsoleReporter::~ConsoleReporter() {}
-    CompactReporter::~CompactReporter() {}
-    IRunner::~IRunner() {}
-    IMutableContext::~IMutableContext() {}
-    IConfig::~IConfig() {}
-    XmlReporter::~XmlReporter() {}
-    JunitReporter::~JunitReporter() {}
-    TestRegistry::~TestRegistry() {}
-    FreeFunctionTestCase::~FreeFunctionTestCase() {}
-    IGeneratorInfo::~IGeneratorInfo() {}
-    IGeneratorsForTest::~IGeneratorsForTest() {}
-    TestSpec::Pattern::~Pattern() {}
-    TestSpec::NamePattern::~NamePattern() {}
-    TestSpec::TagPattern::~TagPattern() {}
-    TestSpec::ExcludedPattern::~ExcludedPattern() {}
-
-    Matchers::Impl::StdString::Equals::~Equals() {}
-    Matchers::Impl::StdString::Contains::~Contains() {}
-    Matchers::Impl::StdString::StartsWith::~StartsWith() {}
-    Matchers::Impl::StdString::EndsWith::~EndsWith() {}
-
-    void Config::dummy() {}
-}
-
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-
-#endif
-
-#ifdef CATCH_CONFIG_MAIN
-// #included from: internal/catch_default_main.hpp
-#define TWOBLUECUBES_CATCH_DEFAULT_MAIN_HPP_INCLUDED
-
-#ifndef __OBJC__
-
-// Standard C/C++ main entry point
-int main (int argc, char * const argv[]) {
-    return Catch::Session().run( argc, argv );
-}
-
-#else // __OBJC__
-
-// Objective-C entry point
-int main (int argc, char * const argv[]) {
-#if !CATCH_ARC_ENABLED
-    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
-#endif
-
-    Catch::registerTestMethods();
-    int result = Catch::Session().run( argc, (char* const*)argv );
-
-#if !CATCH_ARC_ENABLED
-    [pool drain];
-#endif
-
-    return result;
-}
-
-#endif // __OBJC__
-
-#endif
-
-#ifdef CLARA_CONFIG_MAIN_NOT_DEFINED
-#  undef CLARA_CONFIG_MAIN
-#endif
-
-//////
-
-// If this config identifier is defined then all CATCH macros are prefixed with CATCH_
-#ifdef CATCH_CONFIG_PREFIX_ALL
-
-#define CATCH_REQUIRE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::Normal, "CATCH_REQUIRE" )
-#define CATCH_REQUIRE_FALSE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, "CATCH_REQUIRE_FALSE" )
-
-#define CATCH_REQUIRE_THROWS( expr ) INTERNAL_CATCH_THROWS( expr, Catch::ResultDisposition::Normal, "CATCH_REQUIRE_THROWS" )
-#define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( expr, exceptionType, Catch::ResultDisposition::Normal, "CATCH_REQUIRE_THROWS_AS" )
-#define CATCH_REQUIRE_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( expr, Catch::ResultDisposition::Normal, "CATCH_REQUIRE_NOTHROW" )
-
-#define CATCH_CHECK( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK" )
-#define CATCH_CHECK_FALSE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, "CATCH_CHECK_FALSE" )
-#define CATCH_CHECKED_IF( expr ) INTERNAL_CATCH_IF( expr, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECKED_IF" )
-#define CATCH_CHECKED_ELSE( expr ) INTERNAL_CATCH_ELSE( expr, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECKED_ELSE" )
-#define CATCH_CHECK_NOFAIL( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, "CATCH_CHECK_NOFAIL" )
-
-#define CATCH_CHECK_THROWS( expr )  INTERNAL_CATCH_THROWS( expr, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK_THROWS" )
-#define CATCH_CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( expr, exceptionType, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK_THROWS_AS" )
-#define CATCH_CHECK_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( expr, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK_NOTHROW" )
-
-#define CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( arg, matcher, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK_THAT" )
-#define CATCH_REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( arg, matcher, Catch::ResultDisposition::Normal, "CATCH_REQUIRE_THAT" )
-
-#define CATCH_INFO( msg ) INTERNAL_CATCH_INFO( msg, "CATCH_INFO" )
-#define CATCH_WARN( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, "CATCH_WARN", msg )
-#define CATCH_SCOPED_INFO( msg ) INTERNAL_CATCH_INFO( msg, "CATCH_INFO" )
-#define CATCH_CAPTURE( msg ) INTERNAL_CATCH_INFO( #msg " := " << msg, "CATCH_CAPTURE" )
-#define CATCH_SCOPED_CAPTURE( msg ) INTERNAL_CATCH_INFO( #msg " := " << msg, "CATCH_CAPTURE" )
-
-#ifdef CATCH_CONFIG_VARIADIC_MACROS
-    #define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
-    #define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
-    #define CATCH_METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
-    #define CATCH_SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
-    #define CATCH_FAIL( ... ) INTERNAL_CATCH_MSG( Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, "CATCH_FAIL", __VA_ARGS__ )
-    #define CATCH_SUCCEED( ... ) INTERNAL_CATCH_MSG( Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, "CATCH_SUCCEED", __VA_ARGS__ )
-#else
-    #define CATCH_TEST_CASE( name, description ) INTERNAL_CATCH_TESTCASE( name, description )
-    #define CATCH_TEST_CASE_METHOD( className, name, description ) INTERNAL_CATCH_TEST_CASE_METHOD( className, name, description )
-    #define CATCH_METHOD_AS_TEST_CASE( method, name, description ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, name, description )
-    #define CATCH_SECTION( name, description ) INTERNAL_CATCH_SECTION( name, description )
-    #define CATCH_FAIL( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, "CATCH_FAIL", msg )
-    #define CATCH_SUCCEED( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, "CATCH_SUCCEED", msg )
-#endif
-#define CATCH_ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE( "", "" )
-
-#define CATCH_REGISTER_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_REPORTER( name, reporterType )
-#define CATCH_REGISTER_LEGACY_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_LEGACY_REPORTER( name, reporterType )
-
-#define CATCH_GENERATE( expr) INTERNAL_CATCH_GENERATE( expr )
-
-// "BDD-style" convenience wrappers
-#ifdef CATCH_CONFIG_VARIADIC_MACROS
-#define CATCH_SCENARIO( ... ) CATCH_TEST_CASE( "Scenario: " __VA_ARGS__ )
-#define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
-#else
-#define CATCH_SCENARIO( name, tags ) CATCH_TEST_CASE( "Scenario: " name, tags )
-#define CATCH_SCENARIO_METHOD( className, name, tags ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " name, tags )
-#endif
-#define CATCH_GIVEN( desc )    CATCH_SECTION( "Given: " desc, "" )
-#define CATCH_WHEN( desc )     CATCH_SECTION( " When: " desc, "" )
-#define CATCH_AND_WHEN( desc ) CATCH_SECTION( "  And: " desc, "" )
-#define CATCH_THEN( desc )     CATCH_SECTION( " Then: " desc, "" )
-#define CATCH_AND_THEN( desc ) CATCH_SECTION( "  And: " desc, "" )
-
-// If CATCH_CONFIG_PREFIX_ALL is not defined then the CATCH_ prefix is not required
-#else
-
-#define REQUIRE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::Normal, "REQUIRE" )
-#define REQUIRE_FALSE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, "REQUIRE_FALSE" )
-
-#define REQUIRE_THROWS( expr ) INTERNAL_CATCH_THROWS( expr, Catch::ResultDisposition::Normal, "REQUIRE_THROWS" )
-#define REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( expr, exceptionType, Catch::ResultDisposition::Normal, "REQUIRE_THROWS_AS" )
-#define REQUIRE_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( expr, Catch::ResultDisposition::Normal, "REQUIRE_NOTHROW" )
-
-#define CHECK( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure, "CHECK" )
-#define CHECK_FALSE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, "CHECK_FALSE" )
-#define CHECKED_IF( expr ) INTERNAL_CATCH_IF( expr, Catch::ResultDisposition::ContinueOnFailure, "CHECKED_IF" )
-#define CHECKED_ELSE( expr ) INTERNAL_CATCH_ELSE( expr, Catch::ResultDisposition::ContinueOnFailure, "CHECKED_ELSE" )
-#define CHECK_NOFAIL( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, "CHECK_NOFAIL" )
-
-#define CHECK_THROWS( expr )  INTERNAL_CATCH_THROWS( expr, Catch::ResultDisposition::ContinueOnFailure, "CHECK_THROWS" )
-#define CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( expr, exceptionType, Catch::ResultDisposition::ContinueOnFailure, "CHECK_THROWS_AS" )
-#define CHECK_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( expr, Catch::ResultDisposition::ContinueOnFailure, "CHECK_NOTHROW" )
-
-#define CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( arg, matcher, Catch::ResultDisposition::ContinueOnFailure, "CHECK_THAT" )
-#define REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( arg, matcher, Catch::ResultDisposition::Normal, "REQUIRE_THAT" )
-
-#define INFO( msg ) INTERNAL_CATCH_INFO( msg, "INFO" )
-#define WARN( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, "WARN", msg )
-#define SCOPED_INFO( msg ) INTERNAL_CATCH_INFO( msg, "INFO" )
-#define CAPTURE( msg ) INTERNAL_CATCH_INFO( #msg " := " << msg, "CAPTURE" )
-#define SCOPED_CAPTURE( msg ) INTERNAL_CATCH_INFO( #msg " := " << msg, "CAPTURE" )
-
-#ifdef CATCH_CONFIG_VARIADIC_MACROS
-    #define TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
-    #define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
-    #define METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
-    #define SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
-    #define FAIL( ... ) INTERNAL_CATCH_MSG( Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, "FAIL", __VA_ARGS__ )
-    #define SUCCEED( ... ) INTERNAL_CATCH_MSG( Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, "SUCCEED", __VA_ARGS__ )
-#else
-    #define TEST_CASE( name, description ) INTERNAL_CATCH_TESTCASE( name, description )
-    #define TEST_CASE_METHOD( className, name, description ) INTERNAL_CATCH_TEST_CASE_METHOD( className, name, description )
-    #define METHOD_AS_TEST_CASE( method, name, description ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, name, description )
-    #define SECTION( name, description ) INTERNAL_CATCH_SECTION( name, description )
-    #define FAIL( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, "FAIL", msg )
-    #define SUCCEED( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, "SUCCEED", msg )
-#endif
-#define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE( "", "" )
-
-#define REGISTER_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_REPORTER( name, reporterType )
-#define REGISTER_LEGACY_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_LEGACY_REPORTER( name, reporterType )
-
-#define GENERATE( expr) INTERNAL_CATCH_GENERATE( expr )
-
-#endif
-
-#define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature )
-
-// "BDD-style" convenience wrappers
-#ifdef CATCH_CONFIG_VARIADIC_MACROS
-#define SCENARIO( ... ) TEST_CASE( "Scenario: " __VA_ARGS__ )
-#define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
-#else
-#define SCENARIO( name, tags ) TEST_CASE( "Scenario: " name, tags )
-#define SCENARIO_METHOD( className, name, tags ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " name, tags )
-#endif
-#define GIVEN( desc )    SECTION( "   Given: " desc, "" )
-#define WHEN( desc )     SECTION( "    When: " desc, "" )
-#define AND_WHEN( desc ) SECTION( "And when: " desc, "" )
-#define THEN( desc )     SECTION( "    Then: " desc, "" )
-#define AND_THEN( desc ) SECTION( "     And: " desc, "" )
-
-using Catch::Detail::Approx;
-
-// #included from: internal/catch_reenable_warnings.h
-
-#define TWOBLUECUBES_CATCH_REENABLE_WARNINGS_H_INCLUDED
-
-#ifdef __clang__
-#pragma clang diagnostic pop
-#elif defined __GNUC__
-#pragma GCC diagnostic pop
-#endif
-
-#endif // TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
-
diff --git a/test/download_catch.sh b/test/download_catch.sh
new file mode 100755
index 00000000..b373a2c4
--- /dev/null
+++ b/test/download_catch.sh
@@ -0,0 +1,2 @@
+#!/usr/bin/env sh
+wget -c https://raw.githubusercontent.com/philsquared/Catch/develop/single_include/catch.hpp

From 36574a8d0fdfa88fb24003b246e11fcd9083b109 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 22 May 2015 12:14:17 -0700
Subject: [PATCH 1129/1866] Tests that range works as a forward iterator

---
 test/helpers.hpp    | 4 ++++
 test/test_range.cpp | 6 ++++--
 2 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/test/helpers.hpp b/test/helpers.hpp
index 7c36ca89..0be552b2 100644
--- a/test/helpers.hpp
+++ b/test/helpers.hpp
@@ -188,6 +188,10 @@ struct IsIterator <T, void_t<
         decltype(std::declval<const T&>() == std::declval<const T&>()) //  ==
     >> : std::true_type { };
 
+template <typename T>
+struct IsForwardIterator : std::integral_constant<bool,
+  IsIterator<T>::value && std::is_default_constructible<T>::value> { };
+
 }
 
 #endif
diff --git a/test/test_range.cpp b/test/test_range.cpp
index d5dc6d29..83e285fe 100644
--- a/test/test_range.cpp
+++ b/test/test_range.cpp
@@ -191,7 +191,9 @@ TEST_CASE("range: using doubles detects empty ranges", "[range]") {
     REQUIRE(std::begin(r2) == std::end(r2));
 }
 
-TEST_CASE("range: iterator meets requirements", "[range]") {
+TEST_CASE("range: iterator meets forward iterator requirements", "[range]") {
     auto r = range(5);
-    REQUIRE( itertest::IsIterator<decltype(std::begin(r))>::value );
+    auto r2 = range(5.0);
+    REQUIRE( itertest::IsForwardIterator<decltype(std::begin(r))>::value );
+    REQUIRE( itertest::IsForwardIterator<decltype(std::begin(r2))>::value );
 }

From 5e9d1c31117c7a08545662211899fbc1edd75e73 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 22 May 2015 12:16:39 -0700
Subject: [PATCH 1130/1866] makes range iterator a forward iterator

---
 range.hpp | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/range.hpp b/range.hpp
index 7a0017d3..960dba42 100644
--- a/range.hpp
+++ b/range.hpp
@@ -45,7 +45,7 @@ namespace iter {
         friend Range range<T, false>(T, T);
         friend Range range<T, false>(T, T, T);
         private:
-            const T start; 
+            const T start;
             const T stop;
             const T step;
 
@@ -63,7 +63,7 @@ namespace iter {
 
         public:
             class Iterator
-                : public std::iterator<std::input_iterator_tag, T>
+                : public std::iterator<std::forward_iterator_tag, T>
             {
                 private:
                     T value;
@@ -82,6 +82,8 @@ namespace iter {
                             && !(this->step < 0 && this->value <= other.value);
                     }
                 public:
+                    Iterator() =default;
+
                     Iterator(T val, T in_step)
                         : value{val},
                         step{in_step}
@@ -165,7 +167,7 @@ namespace iter {
             { }
         public:
             class Iterator
-                : public std::iterator<std::input_iterator_tag, T>
+                : public std::iterator<std::forward_iterator_tag, T>
             {
                 private:
                     T start;
@@ -174,6 +176,8 @@ namespace iter {
                     unsigned long steps_taken =0;
 
                 public:
+                    Iterator() =default;
+
                     Iterator(T in_start, T in_step)
                         : start{in_start},
                         value{in_start},

From cf1fa5965891e6a37c4c11b472dfa227603650b2 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 22 May 2015 14:37:16 -0700
Subject: [PATCH 1131/1866] adds more forward_iterator range tests

---
 test/test_range.cpp | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/test/test_range.cpp b/test/test_range.cpp
index 83e285fe..3927eadc 100644
--- a/test/test_range.cpp
+++ b/test/test_range.cpp
@@ -146,6 +146,22 @@ TEST_CASE("range: works with a variable start, stop, and step", "[range]") {
 
 }
 
+TEST_CASE("range: forward iterator checks", "[range]") {
+  auto r = range(10);
+  auto it1 = std::begin(r);
+  auto it2 = std::begin(r);
+  REQUIRE_FALSE( it1 != it2 );
+  REQUIRE( it1 == it2 );
+  ++it1;
+  REQUIRE( it1 != it2 );
+  ++it2;
+  REQUIRE( it1 == it2 );
+  auto it3 = it1++;
+  REQUIRE( it3 == it2 );
+  auto it4 = ++it3;
+  REQUIRE( it4 == it3 );
+}
+
 using FVec = const std::vector<double>;
 
 TEST_CASE("range: using doubles", "[range]") {

From 5adba3db5bbff69101b656feb05f5b1d345a07a6 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 22 May 2015 14:37:32 -0700
Subject: [PATCH 1132/1866] range can compare arbitrary iterators

---
 range.hpp | 61 +++++++++++++++++++++++++++++++++++++++----------------
 1 file changed, 44 insertions(+), 17 deletions(-)

diff --git a/range.hpp b/range.hpp
index 960dba42..c11b1bc7 100644
--- a/range.hpp
+++ b/range.hpp
@@ -18,6 +18,7 @@
 #include <exception>
 #include <type_traits>
 #include <iterator>
+#include <cassert>
 
 namespace iter {
 
@@ -68,25 +69,45 @@ namespace iter {
                 private:
                     T value;
                     T step;
+                    bool is_end;
 
                     // compare unsigned values
-                    bool not_equal_to(
-                            const Iterator& other, std::true_type ) const {
-                        return this->value < other.value;
+                    static bool not_equal_to_impl(
+                            const Iterator& iter, const Iterator& end_iter,
+                            std::true_type ) {
+                        assert(!iter.is_end);
+                        assert(end_iter.is_end);
+                        return iter.value < end_iter.value;
                     }
 
                     // compare signed values
-                    bool not_equal_to(
-                            const Iterator& other, std::false_type) const {
-                        return !(this->step > 0 && this->value >= other.value) 
-                            && !(this->step < 0 && this->value <= other.value);
+                    static bool not_equal_to_impl(
+                            const Iterator& iter, const Iterator& end_iter,
+                            std::false_type) {
+                        assert(!iter.is_end);
+                        assert(end_iter.is_end);
+                        return !(iter.step > 0 && iter.value >= end_iter.value)
+                            && !(iter.step < 0 && iter.value <= end_iter.value);
+                    }
+
+                    static bool not_equal_to_end(
+                            const Iterator& lhs, const Iterator& rhs) {
+                        if (rhs.is_end) {
+                            return not_equal_to_impl(
+                                    lhs, rhs, std::is_unsigned<T>{});
+                        } else {
+                            return not_equal_to_impl(
+                                    rhs, lhs, std::is_unsigned<T>{});
+                        }
                     }
+
                 public:
                     Iterator() =default;
 
-                    Iterator(T val, T in_step)
+                    Iterator(T val, T in_step, bool in_is_end)
                         : value{val},
-                        step{in_step}
+                        step{in_step},
+                        is_end{in_is_end}
                     { }
 
                     T operator*() const {
@@ -121,9 +142,15 @@ namespace iter {
                     // Another way to think about it is that the "end"
                     // iterator represents the range of values that are invalid
                     // So, if an iterator is not equal to that, it is valid
-                    bool operator!=(const Iterator& other) const { 
-                        return not_equal_to(
-                                other, typename std::is_unsigned<T>::type());
+                    bool operator!=(const Iterator& other) const {
+                        if (this->is_end && other.is_end) {
+                            return false;
+                        }
+
+                        if (!this->is_end && !other.is_end) {
+                            return this->value != other.value;
+                        }
+                        return not_equal_to_end(*this, other);
                     }
 
                     bool operator==(const Iterator& other) const {
@@ -132,25 +159,25 @@ namespace iter {
             };
 
             Iterator begin() const {
-                return {start, step};
+                return {start, step, false};
             }
 
-            Iterator end() const { 
-                return {stop, step};
+            Iterator end() const {
+                return {stop, step, true};
             }
     };
 
     // This specialization is used for floating point types.  Instead of
     // adding one "step" each time ++ is called on the iterator, the value
     // is recalculated as start + (steps_taken + step_size) to avoid
-    // accumulating floating point inaccuracies 
+    // accumulating floating point inaccuracies
     template <typename T>
     class Range<T, true> {
         friend Range range<T, true>(T);
         friend Range range<T, true>(T, T);
         friend Range range<T, true>(T, T, T);
         private:
-            const T start; 
+            const T start;
             const T stop;
             const T step;
 

From e30289f19435517a489ce972972428ca38545d2f Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 22 May 2015 17:24:19 -0700
Subject: [PATCH 1133/1866] adds more forward_iterator tests

---
 test/test_range.cpp | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/test/test_range.cpp b/test/test_range.cpp
index 3927eadc..11c651c8 100644
--- a/test/test_range.cpp
+++ b/test/test_range.cpp
@@ -148,6 +148,24 @@ TEST_CASE("range: works with a variable start, stop, and step", "[range]") {
 
 TEST_CASE("range: forward iterator checks", "[range]") {
   auto r = range(10);
+  REQUIRE( std::end(r) == std::end(r) );
+  auto it1 = std::begin(r);
+  auto it2 = std::begin(r);
+  REQUIRE_FALSE( it1 != it2 );
+  REQUIRE( it1 == it2 );
+  ++it1;
+  REQUIRE( it1 != it2 );
+  ++it2;
+  REQUIRE( it1 == it2 );
+  auto it3 = it1++;
+  REQUIRE( it3 == it2 );
+  auto it4 = ++it3;
+  REQUIRE( it4 == it3 );
+}
+
+TEST_CASE("range: forward iterator with double, checks", "[range]") {
+  auto r = range(10.0);
+  REQUIRE( std::end(r) == std::end(r) );
   auto it1 = std::begin(r);
   auto it2 = std::begin(r);
   REQUIRE_FALSE( it1 != it2 );

From 6565639b1a0880cdd93d3dcd13b37ecb71fe36b0 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 22 May 2015 17:25:18 -0700
Subject: [PATCH 1134/1866] Moves the float specialization into a helper class

Rather than fully specializing Range for floats, just specialize a small
part of the iterator.
---
 range.hpp | 219 ++++++++++++++++++++++++++++--------------------------
 1 file changed, 112 insertions(+), 107 deletions(-)

diff --git a/range.hpp b/range.hpp
index c11b1bc7..175d2604 100644
--- a/range.hpp
+++ b/range.hpp
@@ -22,6 +22,87 @@
 
 namespace iter {
 
+    template <typename T, bool IsFloat=std::is_floating_point<T>::value>
+    class RangeIterData;
+
+    // everything except floats
+    template <typename T>
+    class RangeIterData<T, false> {
+        private:
+            T value_{};
+            T step_{};
+        public:
+            RangeIterData() =default;
+            RangeIterData(T in_value, T in_step)
+                : value_{in_value},
+                step_{in_step}
+            { }
+
+            T value() const {
+                return this->value_;
+            }
+
+            T step() const {
+                return this->step_;
+            }
+
+            void inc() {
+                this->value_ += step_;
+            }
+
+            bool operator==(const RangeIterData& other) const {
+              return this->value_ == other.value_;
+            }
+
+            bool operator!=(const RangeIterData& other) const {
+              return !(*this == other);
+            }
+    };
+
+    // float data
+    template <typename T>
+    class RangeIterData<T, true> {
+        private:
+            T start_{};
+            T value_{};
+            T step_{};
+            unsigned long steps_taken{};
+        public:
+            RangeIterData() =default;
+            RangeIterData(T in_start, T in_step)
+                : start_{in_start},
+                value_{in_start},
+                step_{in_step}
+            { }
+
+            T value() const {
+                return this->value_;
+            }
+
+            T step() const {
+                return this->step_;
+            }
+
+            void inc() {
+                ++this->steps_taken;
+                value_ = this->start_ +
+                        (this->step_ * this->steps_taken);
+            }
+
+            bool operator==(const RangeIterData& other) const {
+                // if the difference between the two values is less than the
+                // step size, they are considered equal
+                T diff = this->value_ < other.value_ ?
+                    other.value_ - this->value_ : this->value_ - other.value_;
+                return diff < step_;
+            }
+
+            bool operator!=(const RangeIterData& other) const {
+              return !(*this == other);
+            }
+    };
+
+
     // Thrown when step 0 occurs
     class RangeException : public std::exception {
         const char *what() const noexcept override {
@@ -29,22 +110,22 @@ namespace iter {
         }
     };
 
-    template <typename T, bool IsFloat =false>
+    template <typename T>
     class Range;
 
-    template <typename T, bool IsFloat =std::is_floating_point<T>::value>
-    Range<T, IsFloat> range(T);
-    template <typename T, bool IsFloat =std::is_floating_point<T>::value>
-    Range<T, IsFloat> range(T, T);
-    template <typename T, bool IsFloat =std::is_floating_point<T>::value>
-    Range<T, IsFloat> range(T, T, T);
+    template <typename T>
+    Range<T> range(T);
+    template <typename T>
+    Range<T> range(T, T);
+    template <typename T>
+    Range<T> range(T, T, T);
 
     // General version for everything not a float
-    template <typename T, bool>
+    template <typename T>
     class Range {
-        friend Range range<T, false>(T);
-        friend Range range<T, false>(T, T);
-        friend Range range<T, false>(T, T, T);
+        friend Range range<T>(T);
+        friend Range range<T>(T, T);
+        friend Range range<T>(T, T, T);
         private:
             const T start;
             const T stop;
@@ -67,8 +148,7 @@ namespace iter {
                 : public std::iterator<std::forward_iterator_tag, T>
             {
                 private:
-                    T value;
-                    T step;
+                    RangeIterData<T> data;
                     bool is_end;
 
                     // compare unsigned values
@@ -77,7 +157,7 @@ namespace iter {
                             std::true_type ) {
                         assert(!iter.is_end);
                         assert(end_iter.is_end);
-                        return iter.value < end_iter.value;
+                        return iter.data.value() < end_iter.data.value();
                     }
 
                     // compare signed values
@@ -86,8 +166,10 @@ namespace iter {
                             std::false_type) {
                         assert(!iter.is_end);
                         assert(end_iter.is_end);
-                        return !(iter.step > 0 && iter.value >= end_iter.value)
-                            && !(iter.step < 0 && iter.value <= end_iter.value);
+                        return !(iter.data.step() > 0 && iter.data.value()
+                                 >= end_iter.data.value())
+                            && !(iter.data.step() < 0 && iter.data.value()
+                                 <= end_iter.data.value());
                     }
 
                     static bool not_equal_to_end(
@@ -104,18 +186,17 @@ namespace iter {
                 public:
                     Iterator() =default;
 
-                    Iterator(T val, T in_step, bool in_is_end)
-                        : value{val},
-                        step{in_step},
+                    Iterator(T in_value, T in_step, bool in_is_end)
+                        : data(in_value, in_step),
                         is_end{in_is_end}
                     { }
 
                     T operator*() const {
-                        return this->value;
+                        return this->data.value();
                     }
 
                     Iterator& operator++() {
-                        this->value += this->step;
+                        this->data.inc();
                         return *this;
                     }
 
@@ -142,13 +223,17 @@ namespace iter {
                     // Another way to think about it is that the "end"
                     // iterator represents the range of values that are invalid
                     // So, if an iterator is not equal to that, it is valid
+                    //
+                    // Two end iterators will compare equal
+                    //
+                    // Two non-end iterators will compare by their stored values
                     bool operator!=(const Iterator& other) const {
                         if (this->is_end && other.is_end) {
                             return false;
                         }
 
                         if (!this->is_end && !other.is_end) {
-                            return this->value != other.value;
+                            return this->data != other.data;
                         }
                         return not_equal_to_end(*this, other);
                     }
@@ -167,98 +252,18 @@ namespace iter {
             }
     };
 
-    // This specialization is used for floating point types.  Instead of
-    // adding one "step" each time ++ is called on the iterator, the value
-    // is recalculated as start + (steps_taken + step_size) to avoid
-    // accumulating floating point inaccuracies
     template <typename T>
-    class Range<T, true> {
-        friend Range range<T, true>(T);
-        friend Range range<T, true>(T, T);
-        friend Range range<T, true>(T, T, T);
-        private:
-            const T start;
-            const T stop;
-            const T step;
-
-            Range(T in_stop)
-                : start{0},
-                stop{in_stop},
-                step{1}
-            { }
-
-            Range(T in_start, T in_stop, T in_step =1)
-                : start{in_start},
-                stop{in_stop},
-                step{in_step}
-            { }
-        public:
-            class Iterator
-                : public std::iterator<std::forward_iterator_tag, T>
-            {
-                private:
-                    T start;
-                    T value;
-                    T step;
-                    unsigned long steps_taken =0;
-
-                public:
-                    Iterator() =default;
-
-                    Iterator(T in_start, T in_step)
-                        : start{in_start},
-                        value{in_start},
-                        step{in_step}
-                    { }
-
-                    bool operator!=(const Iterator& other) const {
-                        return !(this->step > 0 && this->value >= other.value) 
-                            && !(this->step < 0 && this->value <= other.value);
-                    }
-
-                    bool operator==(const Iterator& other) const {
-                        return !(*this != other);
-                    }
-
-                    T operator*() const {
-                        return this->value;
-                    }
-
-                    Iterator& operator++() {
-                        ++this->steps_taken;
-                        this->value = this->start +
-                            (this->step * this->steps_taken);
-                        return *this;
-                    }
-
-                    Iterator operator++(int) {
-                        auto ret = *this;
-                        ++*this;
-                        return ret;
-                    }
-            };
-
-            Iterator begin() const {
-                return {start, step};
-            }
-
-            Iterator end() const { 
-                return {stop, step};
-            }
-    };
-
-    template <typename T, bool IsFloat>
-    Range<T, IsFloat> range(T stop) {
+    Range<T> range(T stop) {
         return {stop};
     }
 
-    template <typename T, bool IsFloat>
-    Range<T, IsFloat> range(T start, T stop) {
+    template <typename T>
+    Range<T> range(T start, T stop) {
         return {start, stop};
     }
 
-    template <typename T, bool IsFloat>
-    Range<T, IsFloat> range(T start, T stop, T step) {
+    template <typename T>
+    Range<T> range(T start, T stop, T step) {
         if (step == 0) {
             throw RangeException{};
         }

From fa8dfdad71cc39c06b9d67cbf8d2c2a804d60e40 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 26 May 2015 11:31:36 -0700
Subject: [PATCH 1135/1866] range operator* returns reference instead of value

I believe this meets the ForwardIterator requirements.
---
 range.hpp | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/range.hpp b/range.hpp
index 175d2604..0bfd5051 100644
--- a/range.hpp
+++ b/range.hpp
@@ -38,7 +38,7 @@ namespace iter {
                 step_{in_step}
             { }
 
-            T value() const {
+            const T& value() const {
                 return this->value_;
             }
 
@@ -75,7 +75,7 @@ namespace iter {
                 step_{in_step}
             { }
 
-            T value() const {
+            const T& value() const {
                 return this->value_;
             }
 
@@ -145,7 +145,8 @@ namespace iter {
 
         public:
             class Iterator
-                : public std::iterator<std::forward_iterator_tag, T>
+                : public std::iterator<
+                  std::forward_iterator_tag, const T>
             {
                 private:
                     RangeIterData<T> data;
@@ -191,7 +192,7 @@ namespace iter {
                         is_end{in_is_end}
                     { }
 
-                    T operator*() const {
+                    const T& operator*() const {
                         return this->data.value();
                     }
 

From f14b4051a1cc81d50b566670de2d8689f601cd85 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 26 May 2015 11:36:43 -0700
Subject: [PATCH 1136/1866] ignores catch.hpp

---
 test/.gitignore | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/.gitignore b/test/.gitignore
index 68c1db22..b08f9d55 100644
--- a/test/.gitignore
+++ b/test/.gitignore
@@ -5,3 +5,4 @@ test_*
 .sconsign.dblite
 config.log
 .sconf_temp/
+catch.hpp

From 1209101060265fc848fab3a3fa681584e4d8b5a9 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 26 May 2015 12:24:39 -0700
Subject: [PATCH 1137/1866] replaces "naked new" in chain with make_unique

---
 chain.hpp | 28 ++++++++++++++++------------
 1 file changed, 16 insertions(+), 12 deletions(-)

diff --git a/chain.hpp b/chain.hpp
index 5b0a1086..bc4fd097 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -60,7 +60,7 @@ class Chained {
 
         constexpr static std::array<DerefFunc, sizeof...(Is)> derefers{{
             get_and_deref<Is>...}};
-        
+
         constexpr static std::array<IncFunc, sizeof...(Is)> incrementers{{
             get_and_increment<Is>...}};
 
@@ -68,7 +68,7 @@ class Chained {
             get_and_check_not_equal<Is>...}};
 
 
-        using TraitsValue = 
+        using TraitsValue =
             iterator_traits_deref<std::tuple_element_t<0, TupType>>;
     private:
         TupType tup;
@@ -188,8 +188,8 @@ constexpr std::array<
 
                    static std::unique_ptr<SubIter> clone_sub_pointer(
                            const SubIter* sub_iter) {
-                       return std::unique_ptr<SubIter>{ sub_iter ?
-                           new SubIter{*sub_iter} : nullptr};
+                     return sub_iter ?
+                         std::make_unique<SubIter>(*sub_iter) : nullptr;
                    }
 
                    bool sub_iters_differ(const Iterator& other) const {
@@ -211,9 +211,11 @@ constexpr std::array<
                        : top_level_iter{std::move(top_iter)},
                        top_level_end{std::move(top_end)},
                        sub_iter_p{!(top_iter != top_end) ?  // iter == end ?
-                           nullptr : new SubIter{std::begin(*top_iter)}},
+                           nullptr :
+                             std::make_unique<SubIter>(std::begin(*top_iter))},
                        sub_end_p{!(top_iter != top_end) ?  // iter == end ?
-                           nullptr : new SubIter{std::end(*top_iter)}}
+                           nullptr :
+                             std::make_unique<SubIter>(std::end(*top_iter))}
                    { }
 
                    Iterator(const Iterator& other)
@@ -245,13 +247,15 @@ constexpr std::array<
                        if (!(*this->sub_iter_p != *this->sub_end_p)) {
                            ++this->top_level_iter;
                            if (this->top_level_iter != this->top_level_end) {
-                               sub_iter_p.reset(
-                                       new SubIter{std::begin(*this->top_level_iter)});
-                               sub_end_p.reset(
-                                       new SubIter{std::end(*this->top_level_iter)});
+                               sub_iter_p =
+                                       std::make_unique<SubIter>(
+                                           std::begin(*this->top_level_iter));
+                               sub_end_p =
+                                       std::make_unique<SubIter>(
+                                           std::end(*this->top_level_iter));
                            } else {
-                               sub_iter_p.reset(nullptr);
-                               sub_end_p.reset(nullptr);
+                               sub_iter_p.reset();
+                               sub_end_p.reset();
                            }
                        }
                        return *this;

From 1d458f3aabca03224d3d1fae7acd8e8e2b26190b Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 26 May 2015 12:29:54 -0700
Subject: [PATCH 1138/1866] removes "naked new"s in powerset using make_shared

---
 powerset.hpp | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/powerset.hpp b/powerset.hpp
index 555be582..d3743cc4 100644
--- a/powerset.hpp
+++ b/powerset.hpp
@@ -39,7 +39,8 @@ namespace iter {
                     Iterator(Container& in_container, std::size_t sz)
                         : container_p{&in_container},
                         set_size{sz},
-                        comb{new CombinatorType(combinations(in_container, sz))},
+                        comb{std::make_shared<CombinatorType>(
+                            combinations(in_container, sz))},
                         comb_iter{std::begin(*comb)},
                         comb_end{std::end(*comb)}
                     { }
@@ -48,8 +49,9 @@ namespace iter {
                         ++this->comb_iter;
                         if (this->comb_iter == this->comb_end) {
                             ++this->set_size;
-                            this->comb.reset(new CombinatorType(combinations(
-                                            *this->container_p, this->set_size)));
+                            this->comb = std::make_shared<CombinatorType>(
+                                combinations(
+                                    *this->container_p, this->set_size));
                             this->comb_iter = std::begin(*this->comb);
                             this->comb_end = std::end(*this->comb);
                         }

From 7413ddb05d7105f8f4290c492c83df0d8905e688 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 26 May 2015 13:44:56 -0700
Subject: [PATCH 1139/1866] replaces "naked new"s in iterbase with make_unique

---
 iterbase.hpp | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/iterbase.hpp b/iterbase.hpp
index 7bf65d69..16679a4f 100644
--- a/iterbase.hpp
+++ b/iterbase.hpp
@@ -200,12 +200,13 @@ namespace iter {
             DerefHolder() = default;
 
             DerefHolder(const DerefHolder& other)
-                : item_p{other.item_p ? new TPlain(*other.item_p) : nullptr}
+                : item_p{other.item_p ?
+                  std::make_unique<TPlain>(*other.item_p) : nullptr}
             { }
 
             DerefHolder& operator=(const DerefHolder& other) {
-                this->item_p.reset(other.item_p
-                        ? new TPlain(*other.item_p) : nullptr);
+                this->item_p = other.item_p ?
+                        std::make_unique<TPlain>(*other.item_p) : nullptr;
                 return *this;
             }
 
@@ -224,7 +225,7 @@ namespace iter {
             }
 
             void reset(T&& item) {
-                item_p.reset(new TPlain(std::move(item)));
+                item_p = std::make_unique<TPlain>(std::move(item));
             }
 
             explicit operator bool() const {
@@ -236,8 +237,7 @@ namespace iter {
     // Specialization for when T is an lvalue ref.  Keep this in mind
     // wherever a T appears.
     template <typename T>
-    class DerefHolder<T,
-        typename std::enable_if<std::is_lvalue_reference<T>::value>::type>
+    class DerefHolder<T, std::enable_if_t<std::is_lvalue_reference<T>::value>>
     {
         private:
             static_assert(std::is_lvalue_reference<T>::value,

From dd6debf992c9fbcc4bbc40e63e4914f35a55960a Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 29 May 2015 13:59:29 -0700
Subject: [PATCH 1140/1866] describes library behavior

---
 README.md | 114 ++++++++++++++++++++++++++++++++++++++++++------------
 1 file changed, 89 insertions(+), 25 deletions(-)

diff --git a/README.md b/README.md
index e8895623..5c1c4540 100644
--- a/README.md
+++ b/README.md
@@ -1,30 +1,22 @@
 CPPItertools
 ============
 
-range-based for loop add-ons inspired by the Python builtins and itertools
+Range-based for loop add-ons inspired by the Python builtins and itertools
 library.  Like itertools and the Python3 builtins, this library uses lazy
 evaluation wherever possible.
 
 *Note*: Everthing is inside the `iter` namespace.
 
-#### Requirements
-This library is **header-only** and relies only on the C++ standard
-library. The only exception is `zip_longest` which uses `boost::optional`.
-`#include <cppitertools/itertools.hpp>` will include all of the provided
-tools except for `zip_longest` which must be included separately.  You may
-also include individual pieces with the relevant header
-(`#include <cppitertools/enumerate.hpp>` for example).
-
 #### Table of Contents
 [range](#range)<br />
 [enumerate](#enumerate)<br />
 [zip](#zip)<br />
-[zip_longest](#zip)<br />
+[zip\_longest](#zip)<br />
 [imap](#imap)<br />
 [filter](#filter)<br />
 [filterfalse](#filterfalse)<br />
-[unique_everseen](#unique_everseen)<br />
-[unique_justseen](#unique_justseen)<br />
+[unique\_everseen](#unique_everseen)<br />
+[unique\_justseen](#unique_justseen)<br />
 [takewhile](#takewhile)<br />
 [dropwhile](#dropwhile)<br />
 [cycle](#cycle)<br />
@@ -38,20 +30,87 @@ also include individual pieces with the relevant header
 [chain.from\_iterable](#chainfrom_iterable)<br />
 [reversed](#reversed)<br />
 [slice](#slice)<br />
-[sliding_window](#sliding_window)<br />
+[sliding\_window](#sliding_window)<br />
 [grouper](#grouper)<br />
 
 ##### Combinatoric fuctions
 [product](#product)<br />
 [combinations](#combinations)<br />
-[combinations_with_replacement](#combinations_with_replacement)<br />
+[combinations\_with\_replacement](#combinations_with_replacement)<br />
 [permutations](#permutations)<br />
 [powerset](#powerset)<br />
 
+#### Requirements
+This library is **header-only** and relies only on the C++ standard
+library. The only exception is `zip_longest` which uses `boost::optional`.
+`#include <cppitertools/itertools.hpp>` will include all of the provided
+tools except for `zip_longest` which must be included separately.  You may
+also include individual pieces with the relevant header
+(`#include <cppitertools/enumerate.hpp>` for example).
+
+#### Requirements of passed objects
+Most itertools will work with iterables using InputIterators and not copy
+or move any underlying elements.  The itertools that need ForwardIterators or
+have additional requirements are noted in this document. However, the cases
+should be fairly obvious: any time an element needs to appear multiple times
+(as in `combinations` or `cycle`) or be looked at more than once (specifically,
+`sorted`).
+This library takes every effort to rely on as little as possible from the
+underlying iterables, but if anything noteworthy is needed it is described
+in this document.
+
+#### Feedback
+If you find anything not working as you expect, not compiling when you believe
+it should, a divergence from the python itertools behavior, or any sort of
+error, please let me know. The preferable means would be to open an issue on
+github. If you want to talk about an issue that you don't feel would be
+appropriate as a github issue (or you just don't want to open one),
+You can email me directly with whatever code you have that describes the
+problem, I've been pretty responsive in the past. If I believe you are
+"misusing" the library I'll try to put the blame on myself for being unclear
+in this document and take the steps to clarify it.  So please, contact me with
+any concerns, I'm open to feedback.
+
+#### How (not) to use this library
+The library functions create and return objects that are properly templated on
+the iterable they are passed. These exact names of these types or
+precisely how they are templated is unspecified, you should rely on the
+functions described in this document.
+If you plan to use these functions in very simple, straight forward means as in
+the examples on this page, then you will be fine. If you feel like you need to
+open the header files, then I've probably under-described something, let me
+know.
+
+#### Handling of rvalues vs lvalues
+The rules are pretty simple, and the library can be largely used without
+knowledge of them.
+Let's take an example
+```c++
+std::vector<int> vec{2,4,6,8};
+for (auto&& p : enumerate(vec)) { /* ... */ }
+```
+In this case, `enumerate` will return an object that has bound a reference to
+`vec`. No copies are produced here, neither of `vec` nor of the elements it
+holds.
+
+If an rvalue was passed to enumerate, binding a reference would be unsafe.
+Consider:
+```c++
+for (auto&& p : enumerate(std::vector<int>{2,4,6,8})) { /* ... */ }
+```
+Instead, `enumerate` will return an object that has the temporary *moved* into
+it.  That is, the returned object will contain a `std::vector<int>` rather than
+just a reference to one. This may seem like a contrived example, but it matters
+when `enumerate` is passed the result of a function call like `enumerate(f())`,
+or, more obviously, something like `enumerate(zip(a, b))`.  The object returned
+from `zip` must be moved into the `enumerate` object. As a more specific
+result, itertools can be mixed and nested.
+
+
 range
 -----
 
-Uses an underlying iterator to acheive the same effect of the python range
+Uses an underlying iterator to achieve the same effect of the python range
 function.  `range` can be used in three different ways:
 
 Only the stopping point is provided.  Prints `0 1 2 3 4 5 6 7 8 9`
@@ -92,12 +151,17 @@ for(auto i : range(5.0, 10.0, 0.5)) {
 }
 ```
 
+*Implementation Note*: Typical ranges have their current value incremented by
+the step size repeatedly (`value += step`). Floating point range value are
+recomputed at each step to avoid accumulating floating point inaccuracies
+(`value = start + (step * steps_taken`). The result of the latter is a bit
+slower but more accurate.
+
 enumerate
 ---------
 
-Can be used with any class with an iterator.  Continually "yields" containers
-similar to pairs.  They are basic structs with a .index and a .element.  Usage
-appears as:
+Continually "yields" containers similar to pairs.  They are basic structs with a
+.index and a .element.  Usage appears as:
 
 ```c++
 vector<int> vec{2, 4, 6, 8};
@@ -154,7 +218,7 @@ for(auto&& i : filterfalse(vec)) {
 }
 
 ```
-unique_everseen
+unique\_everseen
 ---------------
 This is a filter adaptor that only generates values that have never been seen
 before. For this to work your object must be specialized for `std::hash`.
@@ -167,7 +231,7 @@ for (auto&& i : unique_everseen(v)) {
 }
 ```
 
-unique_justseen
+unique\_justseen
 --------------
 Another filter adaptor that only omits consecutive duplicates.
 
@@ -319,7 +383,7 @@ zip
 Takes an arbitrary number of ranges of different types and efficiently iterates
 over them in parallel (so an iterator to each container is incremented
 simultaneously).  When you dereference an iterator to "zipped" range you get a
-tuple of the elements the iterators were holding. 
+tuple of the elements the iterators were holding.
 
 Example usage:
 ```c++
@@ -337,7 +401,7 @@ for (auto&& e : zip(i,f,s,d)) {
 }
 ```
 
-zip_longest
+zip\_longest
 -----------
 Terminates on the longest sequence instead of the shortest.
 Repeatedly yields a tuple of `boost::optional<T>`s where `T` is the type
@@ -457,7 +521,7 @@ for (auto&& i : chain(empty,vec1,arr1)) {
 }
 ```
 
-chain.from_iterable
+chain.from\_iterable
 -------------------
 
 Similar to chain, but rather than taking a variadic number of iterables,
@@ -501,7 +565,7 @@ for (auto&& i : slice(a,0,15,3)) {
 }
 ```
 
-sliding_window
+sliding\_window
 -------------
 Takes a section from a range and increments the whole section.
 
@@ -583,7 +647,7 @@ for (auto&& i : combinations(v,3)) {
 }
 ```
 
-combinations_with_replacement
+combinations\_with\_replacement
 -----------------------------
 Like combinations, but with replacement of each element.  The
 below is printed by the loop that follows:

From 2131e2d967e8e4c9729ab9c70d411393877dc8ee Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 29 May 2015 14:05:51 -0700
Subject: [PATCH 1141/1866] adds forward iterator test checking persistence

---
 test/test_range.cpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/test/test_range.cpp b/test/test_range.cpp
index 11c651c8..6af09277 100644
--- a/test/test_range.cpp
+++ b/test/test_range.cpp
@@ -161,6 +161,11 @@ TEST_CASE("range: forward iterator checks", "[range]") {
   REQUIRE( it3 == it2 );
   auto it4 = ++it3;
   REQUIRE( it4 == it3 );
+
+  auto it5 = std::begin(r);
+  const auto& v = *it5;
+  ++it5;
+  REQUIRE( v != *it5 );
 }
 
 TEST_CASE("range: forward iterator with double, checks", "[range]") {

From a9ddd56bd43198a857b15389aa96e2e25b56e65f Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 29 May 2015 14:06:22 -0700
Subject: [PATCH 1142/1866] range operator*() returns T instead of const T&

this makes more sense.
const auto& v= *it;
++it; // this shouldn't change v
---
 range.hpp | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

diff --git a/range.hpp b/range.hpp
index 0bfd5051..8ac36aa9 100644
--- a/range.hpp
+++ b/range.hpp
@@ -38,7 +38,7 @@ namespace iter {
                 step_{in_step}
             { }
 
-            const T& value() const {
+            T value() const {
                 return this->value_;
             }
 
@@ -75,7 +75,7 @@ namespace iter {
                 step_{in_step}
             { }
 
-            const T& value() const {
+            T value() const {
                 return this->value_;
             }
 
@@ -144,9 +144,17 @@ namespace iter {
             { }
 
         public:
+            // the reference type here is T, which doesn't strictly follow all
+            // of the rules, but std::vector<bool>::iterator::reference isn't
+            // a reference type either, this isn't any worse
+
             class Iterator
                 : public std::iterator<
-                  std::forward_iterator_tag, const T>
+                  std::forward_iterator_tag,
+                  T,
+                  std::ptrdiff_t,
+                  T*,
+                  T>
             {
                 private:
                     RangeIterData<T> data;
@@ -192,7 +200,7 @@ namespace iter {
                         is_end{in_is_end}
                     { }
 
-                    const T& operator*() const {
+                    T operator*() const {
                         return this->data.value();
                     }
 

From 5dc24e107d3e0cf5c4311e69c0ac10e39b7805a7 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 29 May 2015 15:13:51 -0700
Subject: [PATCH 1143/1866] corrects include guard name

---
 unique_justseen.hpp | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/unique_justseen.hpp b/unique_justseen.hpp
index eaf81747..29d6362a 100644
--- a/unique_justseen.hpp
+++ b/unique_justseen.hpp
@@ -1,5 +1,5 @@
-#ifndef UNIQUE_JUSTSEEN_HPP
-#define UNIQUE_JUSTSEEN_HPP
+#ifndef ITER_UNIQUE_JUSTSEEN_HPP
+#define ITER_UNIQUE_JUSTSEEN_HPP
 
 #include "iterbase.hpp"
 #include "groupby.hpp"
@@ -9,7 +9,7 @@
 #include <iterator>
 #include <initializer_list>
 
-namespace iter 
+namespace iter
 {
     template <typename GroupByType>
     struct GroupFrontGetter{
@@ -48,5 +48,4 @@ namespace iter
     }
 }
 
-#endif //UNIQUE_JUSTSEEN_HPP
-    
+#endif

From 7d7e0d874978804a19c8e83b6128b718ef280b18 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 31 May 2015 15:25:23 -0700
Subject: [PATCH 1144/1866] adds arrow helper

for aiding in determining the type of and calling operator->
---
 iterbase.hpp | 66 +++++++++++++++++++++++++++++++++++++++++-----------
 1 file changed, 53 insertions(+), 13 deletions(-)

diff --git a/iterbase.hpp b/iterbase.hpp
index be7d71db..8715e320 100644
--- a/iterbase.hpp
+++ b/iterbase.hpp
@@ -16,6 +16,19 @@
 #include <cstddef>
 
 namespace iter {
+    template <typename T>
+    struct type_is {
+        using type = T;
+    };
+
+    // gcc CWG 1558
+    template <typename...>
+    struct void_t_help {
+        using type = void;
+    };
+    template <typename... Ts>
+    using void_t = typename void_t_help<Ts...>::type;
+
 
     // iterator_type<C> is the type of C's iterator
     template <typename Container>
@@ -51,6 +64,46 @@ namespace iter {
     using reverse_iterator_deref =
         decltype(*std::declval<reverse_iterator_type<Container>&>());
 
+    namespace detail {
+    template <typename T, typename =void>
+    struct ArrowHelper {
+        using type = void;
+    };
+
+    template <typename T>
+    struct ArrowHelper<T*, void> {
+        using type = T*;
+        constexpr type operator()(T* t) const noexcept {
+            return t;
+        }
+    };
+
+
+    template <typename T>
+    struct ArrowHelper<T, void_t<decltype(std::declval<T&>().operator->())>> {
+        using type = decltype(std::declval<T&>().operator->());
+        type operator()(T& t) const {
+            return t.operator->();
+        }
+    };
+
+    template <typename T>
+    using arrow = typename detail::ArrowHelper<T>::type;
+
+    }
+
+    // type of C::iterator::operator->, also works with pointers
+    // void if the iterator has no operator->
+    template <typename C>
+    using iterator_arrow = arrow<iterator_type<C>>;
+
+    // applys the -> operator to an object, if the object is a pointer,
+    // it returns the pointer
+    template <typename T>
+    arrow<T> apply_arrow(T& t) {
+        return detail::ArrowHelper<T>{}(t);
+    }
+
     template <typename, typename =void>
     struct is_random_access_iter : std::false_type { };
 
@@ -219,19 +272,6 @@ namespace iter {
             }
     };
 
-    template <typename T>
-    struct type_is {
-        using type = T;
-    };
-
-    // gcc CWG 1558
-    template <typename...>
-    struct void_t_help {
-        using type = void;
-    };
-    template <typename... Ts>
-    using void_t = typename void_t_help<Ts...>::type;
-
 }
 
 #endif

From 853a4584f782ad44bbac2bf89d9724f590777aa6 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 31 May 2015 15:26:06 -0700
Subject: [PATCH 1145/1866] tests cycle operator->

---
 test/test_cycle.cpp | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/test/test_cycle.cpp b/test/test_cycle.cpp
index 572e73d6..5b09ab25 100644
--- a/test/test_cycle.cpp
+++ b/test/test_cycle.cpp
@@ -56,3 +56,10 @@ TEST_CASE("cycle: iterator meets requirements", "[cycle]") {
     auto c = cycle(s);
     REQUIRE( itertest::IsIterator<decltype(std::begin(c))>::value );
 }
+
+TEST_CASE("cycle: arrow works", "[cycle]") {
+    std::vector<std::string> v = {"hello"};
+    auto c = cycle(v);
+    auto it = std::begin(c);
+    REQUIRE( it->size() == 5 );
+}

From 6817b9502c960b673ec0f8125fcca5ab45771612 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 31 May 2015 15:26:18 -0700
Subject: [PATCH 1146/1866] adds operator-> to cycle iter

---
 cycle.hpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/cycle.hpp b/cycle.hpp
index 5745340b..42b86117 100644
--- a/cycle.hpp
+++ b/cycle.hpp
@@ -53,6 +53,10 @@ namespace iter {
                     iterator_deref<Container> operator*() {
                         return *this->sub_iter;
                     }
+                    
+                    iterator_arrow<Container> operator->() {
+                        return apply_arrow(this->sub_iter);
+                    }
 
                     Iterator& operator++() { 
                         ++this->sub_iter;

From c1fbb50b25cc9b77335df5fdbeacdf58b4de4215 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 31 May 2015 21:10:42 -0700
Subject: [PATCH 1147/1866] adds detail:: on arrow

---
 iterbase.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/iterbase.hpp b/iterbase.hpp
index 8715e320..a5b80e51 100644
--- a/iterbase.hpp
+++ b/iterbase.hpp
@@ -95,12 +95,12 @@ namespace iter {
     // type of C::iterator::operator->, also works with pointers
     // void if the iterator has no operator->
     template <typename C>
-    using iterator_arrow = arrow<iterator_type<C>>;
+    using iterator_arrow = detail::arrow<iterator_type<C>>;
 
     // applys the -> operator to an object, if the object is a pointer,
     // it returns the pointer
     template <typename T>
-    arrow<T> apply_arrow(T& t) {
+    detail::arrow<T> apply_arrow(T& t) {
         return detail::ArrowHelper<T>{}(t);
     }
 

From f703c943e17689620670d135d444b236c40a5198 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 31 May 2015 21:30:05 -0700
Subject: [PATCH 1148/1866] tests that iterators have arrow operators

---
 test/helpers.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/helpers.hpp b/test/helpers.hpp
index 0be552b2..99cb404b 100644
--- a/test/helpers.hpp
+++ b/test/helpers.hpp
@@ -182,6 +182,7 @@ struct IsIterator <T, void_t<
         decltype(T(std::declval<const T&>())), // copyctor
         decltype(std::declval<T&>() = std::declval<const T&>()), // copy =
         decltype(*std::declval<T&>()), // operator*
+        decltype(std::declval<T&>().operator->()), // operator->
         decltype(++std::declval<T&>()), // prefix ++
         decltype(std::declval<T&>()++), // postfix ++
         decltype(std::declval<const T&>() != std::declval<const T&>()), //  !=

From bfaa56676d808abba1b5a75ac335a921e12230fe Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 31 May 2015 21:35:07 -0700
Subject: [PATCH 1149/1866] adds operator-> to accumulate

---
 accumulate.hpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/accumulate.hpp b/accumulate.hpp
index e0dbb137..c7d4aa7c 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -76,6 +76,10 @@ namespace iter {
                         return this->acc_val;
                     }
 
+                    const AccumVal* operator->() const {
+                        return &this->acc_val;
+                    }
+
                     Iterator& operator++() { 
                         ++this->sub_iter;
                         if (this->sub_iter != this->sub_end) {

From 30cd575c91dffdbec8e98735ed8b2570c06031cb Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 31 May 2015 21:42:38 -0700
Subject: [PATCH 1150/1866] tests accumulate arrow gives correct result

---
 test/test_accumulate.cpp | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/test/test_accumulate.cpp b/test/test_accumulate.cpp
index f8f2d3d7..00c9f469 100644
--- a/test/test_accumulate.cpp
+++ b/test/test_accumulate.cpp
@@ -63,6 +63,13 @@ TEST_CASE("accumulate: postfix ++", "[accumulate]") {
     REQUIRE( *it == 5 );
 }
 
+TEST_CASE("accumulate: operator->", "[accumulate]") {
+    Vec ns{7, 3};
+    auto a = accumulate(ns);
+    auto it = std::begin(a);
+    const int *p = it.operator->();
+    REQUIRE( *p == 7 );
+}
 
 TEST_CASE("accumulate: iterator meets requirements", "[accumulate]") {
     Vec ns{};

From b424251355c1bff43b5a02ee30ed13e50cfc451b Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 31 May 2015 21:49:06 -0700
Subject: [PATCH 1151/1866] tests combinations arrow

---
 test/test_combinations.cpp | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/test/test_combinations.cpp b/test/test_combinations.cpp
index dfdb0d0b..b01c2224 100644
--- a/test/test_combinations.cpp
+++ b/test/test_combinations.cpp
@@ -37,6 +37,14 @@ TEST_CASE("combinations: iterators can be compared", "[combinations]") {
     REQUIRE_FALSE( it == std::begin(c) );
 }
 
+TEST_CASE("combinations: operator->", "[combinations]") {
+    std::string s{"ABCD"};
+    auto c = combinations(s, 2);
+    auto it = std::begin(c);
+    REQUIRE( it->size() == 2 );
+}
+
+
 TEST_CASE("combinations: size too large gives no results", "[combinations]") {
     std::string s{"ABCD"};
     auto c = combinations(s, 5);

From 83bceda958f291661d2bee129b1ec3d2a3c575b0 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 31 May 2015 21:49:15 -0700
Subject: [PATCH 1152/1866] adds operator-> to combinations iter

---
 combinations.hpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/combinations.hpp b/combinations.hpp
index a2cfeda2..fc70c6ee 100644
--- a/combinations.hpp
+++ b/combinations.hpp
@@ -77,6 +77,10 @@ namespace iter {
                     return this->indices;
                 }
 
+                CombIteratorDeref* operator->() {
+                    return &this->indices;
+                }
+
 
                 Iterator& operator++() {
                     for (auto iter = indices.get().rbegin();

From efb883c0a159be8055cd4185ef873ee5bf851055 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 31 May 2015 21:56:24 -0700
Subject: [PATCH 1153/1866] tests comb_w_repl ->

---
 test/test_combinations_with_replacement.cpp | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/test/test_combinations_with_replacement.cpp b/test/test_combinations_with_replacement.cpp
index c58aec6d..e5e91f25 100644
--- a/test/test_combinations_with_replacement.cpp
+++ b/test/test_combinations_with_replacement.cpp
@@ -55,6 +55,14 @@ TEST_CASE("combinations_with_replacement: 0 size is empty",
     REQUIRE( std::begin(cwr) == std::end(cwr) );
 }
 
+TEST_CASE("combinations_with_replacement: operator->",
+        "[combinations_with_replacement]") {
+    std::string s{"ABCD"};
+    auto c = combinations_with_replacement(s, 2);
+    auto it = std::begin(c);
+    REQUIRE( it->size() == 2 );
+}
+
 TEST_CASE("combinations_with_replacement: binds to lvalues, moves rvalues",
         "[combinations_with_replacement]") {
     BasicIterable<char> bi{'x', 'y', 'z'};

From a8295ea686dedf311f15006b0579514203fed463 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 31 May 2015 21:56:46 -0700
Subject: [PATCH 1154/1866] adds comb_w_repl iter ->

---
 combinations.hpp                  | 2 +-
 combinations_with_replacement.hpp | 3 +++
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/combinations.hpp b/combinations.hpp
index fc70c6ee..2f52a7e5 100644
--- a/combinations.hpp
+++ b/combinations.hpp
@@ -77,7 +77,7 @@ namespace iter {
                     return this->indices;
                 }
 
-                CombIteratorDeref* operator->() {
+                CombIteratorDeref *operator->() {
                     return &this->indices;
                 }
 
diff --git a/combinations_with_replacement.hpp b/combinations_with_replacement.hpp
index 900e563e..0a1d11c6 100644
--- a/combinations_with_replacement.hpp
+++ b/combinations_with_replacement.hpp
@@ -70,6 +70,9 @@ namespace iter {
                        return this->indices;
                    }
 
+                   CombIteratorDeref *operator->() {
+                       return &this->indices;
+                   }
 
                    Iterator& operator++() {
                        for (auto iter = indices.get().rbegin();

From b3ad7859161cae662918f894dafce7657a6e0dd0 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 31 May 2015 22:00:13 -0700
Subject: [PATCH 1155/1866] tests compress operator->

---
 test/test_compress.cpp | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/test/test_compress.cpp b/test/test_compress.cpp
index 29a7c068..1152b60a 100644
--- a/test/test_compress.cpp
+++ b/test/test_compress.cpp
@@ -60,6 +60,15 @@ TEST_CASE("compress: all false", "[compress]") {
     REQUIRE( std::begin(c) == std::end(c) );
 }
 
+TEST_CASE("compress: operator->", "[compress") {
+    std::vector<std::string> svec = {"a", "abc", "abcde"};
+    std::vector<bool> bvec = {false, false, true};
+    auto c = compress(svec, bvec);
+    auto it = std::begin(c);
+    REQUIRE( it->size() == 5 );
+}
+
+
 TEST_CASE("compress: binds to lvalues, moves rvalues", "[compress]") {
     BasicIterable<char> bi{'x', 'y', 'z'};
     std::vector<bool> bl{true, true, true};

From c6c62f66f887118f2564757d5be9c07aa1339f22 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 31 May 2015 22:00:24 -0700
Subject: [PATCH 1156/1866] adds compress iter ->

---
 compress.hpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/compress.hpp b/compress.hpp
index 404f3047..cc79b930 100644
--- a/compress.hpp
+++ b/compress.hpp
@@ -105,6 +105,10 @@ namespace iter {
                         return *this->sub_iter;
                     }
 
+                    iterator_arrow<Container> operator->() {
+                        return apply_arrow(this->sub_iter);
+                    }
+
                     Iterator& operator++() { 
                         this->increment_iterators();
                         this->skip_failures();

From a65034a8fd8062ba5177fb2e2083a4b9f5f22547 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 1 Jun 2015 00:56:22 -0700
Subject: [PATCH 1157/1866] DerefHolder pull() behavior removed

I totally misunderstood one of the InputIterator requirements.  I guess
that at some point I read "single-pass" and thought it meant you were
only able to dereference the object one time.  I have to update
everything using pull() to use get() instead, which can be invoked more
than once.
---
 iterbase.hpp | 29 ++++++++++++++++-------------
 1 file changed, 16 insertions(+), 13 deletions(-)

diff --git a/iterbase.hpp b/iterbase.hpp
index be7d71db..f2dd287e 100644
--- a/iterbase.hpp
+++ b/iterbase.hpp
@@ -152,6 +152,9 @@ namespace iter {
             std::unique_ptr<TPlain> item_p;
 
         public:
+            using reference = TPlain&;
+            using pointer = TPlain*;
+
             DerefHolder() = default;
 
             DerefHolder(const DerefHolder& other)
@@ -168,14 +171,12 @@ namespace iter {
             DerefHolder& operator=(DerefHolder&&) = default;
             ~DerefHolder() = default;
 
-            TPlain& get() {
-                return *item_p;
+            reference get() {
+                return *this->item_p;
             }
 
-            T pull() {
-                // NOTE should I reset the unique_ptr to nullptr here
-                // since its held item is now invalid anyway?
-                return std::move(*item_p);
+            pointer get_ptr() {
+                return this->item_p.get();
             }
 
             void reset(T&& item) {
@@ -194,20 +195,22 @@ namespace iter {
     class DerefHolder<T,
         typename std::enable_if<std::is_lvalue_reference<T>::value>::type>
     {
-        private:
-            static_assert(std::is_lvalue_reference<T>::value,
-                    "lvalue specialization handling non-lvalue-ref type");
+        public:
+            using reference = T;
+            using pointer = typename std::remove_reference<T>::type*;
 
-            typename std::remove_reference<T>::type *item_p =nullptr;
+        private:
+            pointer item_p{};
+            
         public:
             DerefHolder() = default;
 
-            T get() {
+            reference get() {
                 return *this->item_p;
             }
 
-            T pull() {
-                return this->get();
+            pointer get_ptr() {
+                return this->item_p;
             }
 
             void reset(T item) {

From cc49a1d8ae1a8966710d1c901aaf77947fd2d269 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 1 Jun 2015 00:59:26 -0700
Subject: [PATCH 1158/1866] uses get() instead of pull()

---
 filter.hpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/filter.hpp b/filter.hpp
index 60a1be0d..11b4c65a 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -47,9 +47,10 @@ namespace iter {
                         iterator_traits_deref<Container>>
             {
                 protected:
+                    using Holder = DerefHolder<iterator_deref<Container>>;
                     iterator_type<Container> sub_iter;
                     iterator_type<Container> sub_end;
-                    DerefHolder<iterator_deref<Container>> item;
+                    Holder item;
                     FilterFunc *filter_func;
 
                     void inc_sub_iter() {
@@ -82,8 +83,8 @@ namespace iter {
                         this->skip_failures();
                     } 
 
-                    iterator_deref<Container> operator*() {
-                        return this->item.pull();
+                    typename Holder::reference operator*() {
+                        return this->item.get();
                     }
 
                     Iterator& operator++() { 

From 32644725ec42ba029517e18c08d704b42bfc48a9 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 1 Jun 2015 01:03:43 -0700
Subject: [PATCH 1159/1866] dropwhile uses get() instead of pull()

---
 dropwhile.hpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/dropwhile.hpp b/dropwhile.hpp
index d5c9947f..b9f048a0 100644
--- a/dropwhile.hpp
+++ b/dropwhile.hpp
@@ -43,9 +43,10 @@ namespace iter {
                     iterator_traits_deref<Container>>
             {
                 private:
+                    using Holder = DerefHolder<iterator_deref<Container>>;
                     iterator_type<Container> sub_iter;
                     iterator_type<Container> sub_end;
-                    DerefHolder<iterator_deref<Container>> item;
+                    Holder item;
                     FilterFunc *filter_func;
 
                     void inc_sub_iter() {
@@ -77,8 +78,8 @@ namespace iter {
                         this->skip_passes();
                     } 
 
-                    iterator_deref<Container> operator*() {
-                        return this->item.pull();
+                    typename Holder::reference operator*() {
+                        return this->item.get();
                     }
 
                     Iterator& operator++() { 

From 4470e2e8445cf370211305dab9105054d04bf194 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 1 Jun 2015 01:05:06 -0700
Subject: [PATCH 1160/1866] takewhile uses get() instead of pull()

---
 takewhile.hpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/takewhile.hpp b/takewhile.hpp
index 2c27c715..738502cf 100644
--- a/takewhile.hpp
+++ b/takewhile.hpp
@@ -46,9 +46,10 @@ namespace iter {
                     iterator_traits_deref<Container>>
             {
                 private:
+                    using Holder = DerefHolder<iterator_deref<Container>>;
                     iterator_type<Container> sub_iter;
                     iterator_type<Container> sub_end;
-                    DerefHolder<iterator_deref<Container>> item;
+                    Holder item;
                     FilterFunc *filter_func;
 
                     void inc_sub_iter() {
@@ -79,8 +80,8 @@ namespace iter {
                         this->check_current();
                     } 
 
-                    iterator_deref<Container> operator*() {
-                        return this->item.pull();
+                    typename Holder::reference operator*() {
+                        return this->item.get();
                     }
 
                     Iterator& operator++() { 

From 819d463cba7c53a8cde429b05089f8882beeb2cb Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 1 Jun 2015 01:44:46 -0700
Subject: [PATCH 1161/1866] groupby uses get() instead of pull()

---
 groupby.hpp | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/groupby.hpp b/groupby.hpp
index 488c93f3..5b4c316a 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -60,9 +60,10 @@ namespace iter {
                 : public std::iterator<std::input_iterator_tag, KeyGroupPair>
             {
                 private:
+                    using Holder = DerefHolder<iterator_deref<Container>>;
                     iterator_type<Container> sub_iter;
                     iterator_type<Container> sub_end;
-                    DerefHolder<iterator_deref<Container>> item;
+                    Holder item;
                     KeyFunc *key_func;
 
                 public:
@@ -79,7 +80,6 @@ namespace iter {
                     }
 
                     KeyGroupPair operator*() {
-                        // FIXME double deref
                         return {
                             (*this->key_func)(this->item.get()),
                             Group{*this, (*this->key_func)(this->item.get())}
@@ -117,11 +117,10 @@ namespace iter {
                         return !(this->sub_iter != this->sub_end);
                     }
 
-                    iterator_deref<Container> pull() {
-                        return this->item.pull();
+                    typename Holder::reference get() {
+                        return this->item.get();
                     }
 
-                    // FIXME double deref. Two deref holders?
                     key_func_ret next_key() {
                         return (*this->key_func)(this->item.get());
                     }
@@ -218,7 +217,7 @@ namespace iter {
                             }
 
                             iterator_deref<Container> operator*() {
-                                return this->group_p->owner.pull();
+                                return this->group_p->owner.get();
                             }
                     };
 

From 85be4d2d66edf23f681b76422c1ce7675026c945 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 1 Jun 2015 01:45:57 -0700
Subject: [PATCH 1162/1866] updates DerefHolder comments

---
 iterbase.hpp | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/iterbase.hpp b/iterbase.hpp
index f2dd287e..e0cbef61 100644
--- a/iterbase.hpp
+++ b/iterbase.hpp
@@ -135,11 +135,9 @@ namespace iter {
     // if the iterate dereferences to an lvalue references, a pointer to the
     //     element is stored
     // if it does not, a value is stored instead
-    // get() returns a reference to the held item in either case
-    // pull() should be used when the item is being "pulled out" of the
-    //     DerefHolder.  after pull() is called, neither it nor get() can be
-    //     safely called after
-    // reset() replaces the currently held item and may be called after pull()
+    // get() returns a reference to the held item
+    // get_ptr() returns a pointer to the held item
+    // reset() replaces the currently held item
 
     template <typename T, typename =void>
     class DerefHolder {

From ded97106cafd4a232425595458d129ca64c2a94e Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 1 Jun 2015 23:42:05 -0700
Subject: [PATCH 1163/1866] tests dropwhile operator->

---
 test/test_dropwhile.cpp | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/test/test_dropwhile.cpp b/test/test_dropwhile.cpp
index 7a4d7dee..c0b1707d 100644
--- a/test/test_dropwhile.cpp
+++ b/test/test_dropwhile.cpp
@@ -49,6 +49,14 @@ TEST_CASE("dropwhile: only drops from beginning", "[dropwhile]") {
     REQUIRE( v == vc );
 }
 
+TEST_CASE("dropwhile: operator->", "[dropwhile]") {
+    std::vector<std::string> vs = {"a", "ab", "abcdef", "abcdefghi"};
+    auto d = dropwhile(
+            [](const std::string& str) { return str.size() < 3; }, vs);
+    auto it = std::begin(d);
+    REQUIRE( it->size() == 6 );
+}
+
 namespace {
     int less_than_five(int i) {
         return i < 5;

From 6c1a084a1a684385f6b0271b4ccbc55016f42ca3 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 1 Jun 2015 23:42:17 -0700
Subject: [PATCH 1164/1866] adds dropwhile iter ->

---
 dropwhile.hpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/dropwhile.hpp b/dropwhile.hpp
index b9f048a0..7cdece67 100644
--- a/dropwhile.hpp
+++ b/dropwhile.hpp
@@ -82,6 +82,10 @@ namespace iter {
                         return this->item.get();
                     }
 
+                    typename Holder::pointer operator->() {
+                        return this->item.get_ptr();
+                    }
+
                     Iterator& operator++() { 
                         this->inc_sub_iter();
                         return *this;

From c799257bfb737467b200f89b8b3f3c6ed051bf2c Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 2 Jun 2015 01:09:39 -0700
Subject: [PATCH 1165/1866] adds arrow proxy to provide -> interface

---
 iterbase.hpp | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/iterbase.hpp b/iterbase.hpp
index 15541bc9..3baf7ba7 100644
--- a/iterbase.hpp
+++ b/iterbase.hpp
@@ -104,6 +104,24 @@ namespace iter {
         return detail::ArrowHelper<T>{}(t);
     }
 
+    // For iterators that have an operator* which returns a value
+    // they can return this type from their operator-> instead, which will
+    // wrap an object and allow it to be used with arrow
+    template <typename T>
+    class ArrowProxy {
+        private:
+            T obj;
+        public:
+            ArrowProxy(T&& in_obj)
+                : obj(std::move(in_obj))
+            { }
+
+            T *operator->() {
+                return &obj;
+            }
+    };
+
+
     template <typename, typename =void>
     struct is_random_access_iter : std::false_type { };
 

From 3b7687a990d16978c328dacf7c19b94513e5bc2b Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 2 Jun 2015 01:10:11 -0700
Subject: [PATCH 1166/1866] tests enumerate arrow

---
 test/test_enumerate.cpp | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/test/test_enumerate.cpp b/test/test_enumerate.cpp
index 1a899bc2..3f315d3e 100644
--- a/test/test_enumerate.cpp
+++ b/test/test_enumerate.cpp
@@ -100,6 +100,14 @@ TEST_CASE("moves rvalues into enumerable object", "[enumerate]") {
     (void)e;
 }
 
+TEST_CASE("enumerate: operator->", "[enumerate]") {
+    std::vector<int> ns = {50, 60, 70};
+    auto e = enumerate(ns);
+    auto it = std::begin(e);
+    REQUIRE( it->first == 0 );
+    REQUIRE( it->second == 50 );
+}
+
 TEST_CASE("Works with const iterable", "[enumerate]") {
     const std::string s{"ace"};
     auto e = enumerate(s);

From d8b29f6a402dbaeb7c3d106fae5c7683964d4f55 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 2 Jun 2015 01:10:27 -0700
Subject: [PATCH 1167/1866] adds enumerate iter ->

---
 enumerate.hpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/enumerate.hpp b/enumerate.hpp
index 2775232a..bb70755d 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -80,6 +80,10 @@ namespace iter {
                         return {this->index, *this->sub_iter};
                     }
 
+                    ArrowProxy<IterYield> operator->() {
+                        return {**this};
+                    }
+
                     Iterator& operator++() { 
                         ++this->sub_iter;
                         ++this->index;

From 90a865919b5fae98e94c2f6d057213b01e99910c Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Wed, 3 Jun 2015 01:27:59 -0700
Subject: [PATCH 1168/1866] tests filter arrow

---
 test/test_filter.cpp | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/test/test_filter.cpp b/test/test_filter.cpp
index 28d597d3..650925f9 100644
--- a/test/test_filter.cpp
+++ b/test/test_filter.cpp
@@ -95,6 +95,14 @@ TEST_CASE("filter: binds to lvalues, moves rvales", "[filter]") {
 }
 
 
+TEST_CASE("filter: operator->", "[filter]") {
+    std::vector<std::string> vs = {"ab", "abc", "abcdef"};
+    auto f = filter([](const std::string& str) {return str.size() > 4;}, vs);
+    auto it = std::begin(f);
+    REQUIRE( it->size() == 6 );
+}
+
+
 TEST_CASE("filter: all elements fail predicate", "[filter]") {
     Vec ns{10,20,30,40,50};
     auto f = filter(less_than_five, ns);

From c8eb23d4c1e81a57f93046e213d67852ec6755ad Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Wed, 3 Jun 2015 01:28:16 -0700
Subject: [PATCH 1169/1866] adds filter iter ->

---
 filter.hpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/filter.hpp b/filter.hpp
index 11b4c65a..12801ed3 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -87,6 +87,10 @@ namespace iter {
                         return this->item.get();
                     }
 
+                    typename Holder::pointer operator->() {
+                        return this->item.get_ptr();
+                    }
+
                     Iterator& operator++() { 
                         this->inc_sub_iter();
                         this->skip_failures();

From d5a49e1f91f3ef0c15c66b546867b44c69f84d15 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 5 Jun 2015 01:18:01 -0700
Subject: [PATCH 1170/1866] adds a bunch of groupby tests

arrow correctness and copy-constructing GroupBy::Iterator
---
 test/test_groupby.cpp | 46 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 46 insertions(+)

diff --git a/test/test_groupby.cpp b/test/test_groupby.cpp
index 06139d7b..eddb2728 100644
--- a/test/test_groupby.cpp
+++ b/test/test_groupby.cpp
@@ -162,6 +162,52 @@ TEST_CASE("groupby: doesn't double dereference", "[groupby]") {
     }
 }
 
+TEST_CASE("grouby: iterator doesn't need to be dereferenced before advanced",
+        "[groupby]") {
+    std::vector<int> ns = {2, 4, 7};
+    auto g = groupby(ns);
+    auto it = std::begin(g);
+    ++it;
+    REQUIRE( (*it).first == 4 );
+}
+
+TEST_CASE("groupby: iterator can be dereferenced multiple times", "[groupby]"){
+    std::vector<int> ns = {2, 4, 7};
+    auto g = groupby(ns);
+    auto it = std::begin(g);
+    auto k1 = (*it).first;
+    auto k2 = (*it).first;
+    REQUIRE( k1 == k2 );
+}
+
+
+TEST_CASE("groupby: copy constructed iterators behave as expected",
+        "[groupby]") {
+    std::vector<int> ns = {2, 3, 4, 5};
+    auto g = groupby(ns);
+    auto it = std::begin(g);
+    REQUIRE( it->first == 2 );
+    {
+        auto it2 = it;
+        REQUIRE( it2->first == 2);
+        ++it;
+        REQUIRE( it->first == 3 );
+        REQUIRE( *std::begin(it->second) == 3 );
+    }
+    REQUIRE( it->first == 3 );
+    REQUIRE( *std::begin(it->second) == 3 );
+}
+
+
+TEST_CASE("groupby: operator-> on both iterator types", "[groupby]") {
+    std::vector<std::string> ns = {"a", "abc"};
+    auto g = groupby(ns, std::mem_fn(&std::string::size));
+    auto it = std::begin(g);
+    REQUIRE( it->first == 1 );
+    auto it2 = std::begin(it->second);
+    REQUIRE( it2->size() == 1 );
+}
+
 TEST_CASE("groupby: iterator and groupiterator are correct", "[groupby]") {
     std::string s{"abc"};
     auto c = groupby(s);

From a943944ee453e1aa61166292ecc49f8ef1ac5cb5 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 5 Jun 2015 01:18:37 -0700
Subject: [PATCH 1171/1866] adds groupby iter copy ctor and operator->

---
 groupby.hpp | 66 +++++++++++++++++++++++++++++++++++++++++++++++------
 1 file changed, 59 insertions(+), 7 deletions(-)

diff --git a/groupby.hpp b/groupby.hpp
index 5b4c316a..e238373f 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -1,9 +1,12 @@
 #ifndef ITER_GROUP_BY_HPP_
 #define ITER_GROUP_BY_HPP_
 
+// this is easily the most functionally complex itertool
+
 #include "iterbase.hpp"
 
 #include <type_traits>
+#include <memory>
 #include <utility>
 #include <iterator>
 #include <initializer_list>
@@ -54,18 +57,20 @@ namespace iter {
         private:
             using KeyGroupPair =
                 std::pair<key_func_ret, Group>;
+            using Holder = DerefHolder<iterator_deref<Container>>;
         public:
 
             class Iterator 
                 : public std::iterator<std::input_iterator_tag, KeyGroupPair>
             {
                 private:
-                    using Holder = DerefHolder<iterator_deref<Container>>;
                     iterator_type<Container> sub_iter;
                     iterator_type<Container> sub_end;
                     Holder item;
                     KeyFunc *key_func;
 
+                    std::unique_ptr<KeyGroupPair> current_key_group_pair;
+
                 public:
                     Iterator(iterator_type<Container>&& si,
                               iterator_type<Container>&& end,
@@ -79,14 +84,43 @@ namespace iter {
                         }
                     }
 
-                    KeyGroupPair operator*() {
-                        return {
-                            (*this->key_func)(this->item.get()),
-                            Group{*this, (*this->key_func)(this->item.get())}
-                        };
+                    Iterator(const Iterator& other)
+                        : sub_iter{other.sub_iter},
+                        sub_end{other.sub_end},
+                        item{other.item},
+                        key_func{other.key_func}
+                    { }
+
+                    Iterator& operator=(const Iterator& other) {
+                        if (this == &other) return *this;
+                        this->sub_iter = other.sub_iter;
+                        this->sub_end = other.sub_end;
+                        this->item = other.item;
+                        this->key_func = other.key_func;
+                        this->current_key_group_pair.reset();
+                        return *this;
+                    }
+
+                    ~Iterator() =default;
+
+                    // NOTE the implicitly generated move constructor would
+                    // be wrong
+
+                    KeyGroupPair& operator*() {
+                        set_key_group_pair();
+                        return *this->current_key_group_pair;
+                    }
+
+                    KeyGroupPair *operator->() {
+                        set_key_group_pair();
+                        return this->current_key_group_pair.get();
                     }
 
                     Iterator& operator++() { 
+                        if (!this->current_key_group_pair) {
+                            this->set_key_group_pair();
+                        }
+                        this->current_key_group_pair.reset();
                         return *this;
                     }
 
@@ -121,9 +155,23 @@ namespace iter {
                         return this->item.get();
                     }
 
+                    typename Holder::pointer get_ptr() {
+                        return this->item.get_ptr();
+                    }
+
                     key_func_ret next_key() {
                         return (*this->key_func)(this->item.get());
                     }
+
+                    void set_key_group_pair() {
+                        if (!this->current_key_group_pair) {
+                            this->current_key_group_pair.reset(
+                                    new KeyGroupPair(
+                                        (*this->key_func)(this->item.get()),
+                                        Group{*this, this->next_key()}));
+                        }
+                    }
+
             };
 
 
@@ -162,7 +210,7 @@ namespace iter {
                     // move-constructible, non-copy-constructible,
                     // non-assignable
                     Group() = delete;
-                    Group(const Group&) = delete;
+                    Group(const Group&) = default;
                     Group& operator=(const Group&) = delete;
                     Group& operator=(Group&&) = delete;
 
@@ -219,6 +267,10 @@ namespace iter {
                             iterator_deref<Container> operator*() {
                                 return this->group_p->owner.get();
                             }
+
+                            typename Holder::pointer operator->() {
+                                return this->group_p->owner.get_ptr();
+                            }
                     };
 
                     GroupIterator begin() {

From e7746c33ecd16e03e37cf3b338790fb114283373 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 14 Jun 2015 18:06:18 -0700
Subject: [PATCH 1172/1866] adds -> to grouper iter

---
 grouper.hpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/grouper.hpp b/grouper.hpp
index c96a9f80..d3bebcdf 100644
--- a/grouper.hpp
+++ b/grouper.hpp
@@ -103,6 +103,10 @@ namespace iter {
                     DerefVec& operator*() {
                         return this->group;
                     }
+
+                    DerefVec *operator->() {
+                        return &this->group;
+                    }
             };
 
             Iterator begin() {

From 4c9eaf958a0f6ac37446fa416b7477fb96210d03 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 14 Jun 2015 18:24:39 -0700
Subject: [PATCH 1173/1866] tests imap iter ->

---
 test/test_imap.cpp | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/test/test_imap.cpp b/test/test_imap.cpp
index 71a70440..6911c0fa 100644
--- a/test/test_imap.cpp
+++ b/test/test_imap.cpp
@@ -84,6 +84,22 @@ TEST_CASE("imap: terminates on shortest squence", "[imap]") {
     }
 }
 
+TEST_CASE("imap: operator->", "[imap]") {
+    std::vector<std::string> vs = {"ab", "abcd", "abcdefg"};
+    {
+        auto m = imap([](std::string& s) { return s; }, vs);
+        auto it = std::begin(m);
+        REQUIRE( it->size() == 2 );
+    }
+
+    {
+        auto m = imap([](std::string& s) -> std::string& { return s; }, vs);
+        auto it = std::begin(m);
+        REQUIRE( it->size() == 2 );
+    }
+}
+
+
 TEST_CASE("imap: empty sequence gives nothing", "[imap]") {
     Vec v{};
     auto im = imap(plusone, v);

From ae1c891a347213c0954f628a6f23e3344f4014f6 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 14 Jun 2015 18:24:53 -0700
Subject: [PATCH 1174/1866] adds imap iter operator->

---
 imap.hpp | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/imap.hpp b/imap.hpp
index f4cf1279..cbe7174c 100644
--- a/imap.hpp
+++ b/imap.hpp
@@ -106,8 +106,8 @@ namespace iter {
                     ZippedIterType zipiter;
 
                 public:
-                    Iterator(MapFunc& in_map_func, ZippedIterType&& in_zipiter) :
-                        map_func(&in_map_func),
+                    Iterator(MapFunc& in_map_func, ZippedIterType&& in_zipiter)
+                        : map_func(&in_map_func),
                         zipiter(std::move(in_zipiter))
                     { } 
 
@@ -116,6 +116,10 @@ namespace iter {
                                 *this->map_func, *(this->zipiter));
                     }
 
+                    ArrowProxy<IMapIterDeref> operator->() {
+                        return {**this};
+                    }
+
                     Iterator& operator++() { 
                         ++this->zipiter;
                         return *this;

From 271a41c21f4f505650991c26d8eca4ca24c530c2 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 14 Jun 2015 18:40:53 -0700
Subject: [PATCH 1175/1866] adds permutations iter ->

---
 permutations.hpp | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/permutations.hpp b/permutations.hpp
index 547b6aef..4e53f259 100644
--- a/permutations.hpp
+++ b/permutations.hpp
@@ -57,7 +57,11 @@ namespace iter {
                     }
 
                     Permutable& operator*() {
-                        return working_set;
+                        return this->working_set;
+                    }
+
+                    Permutable *operator->() {
+                        return &this->working_set;
                     }
 
                     Iterator& operator++() {

From 3d2d622b701e9ebcee809b54745ba9df2e500f41 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 14 Jun 2015 18:44:07 -0700
Subject: [PATCH 1176/1866] adds powerset iter ->

---
 powerset.hpp | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

diff --git a/powerset.hpp b/powerset.hpp
index 5635cc4e..a87b73f2 100644
--- a/powerset.hpp
+++ b/powerset.hpp
@@ -29,7 +29,8 @@ namespace iter {
                       std::input_iterator_tag, CombinatorType>
             {
                 private:
-                    typename std::remove_reference<Container>::type *container_p;
+                    typename std::remove_reference<Container>::type *
+                        container_p;
                     std::size_t set_size;
                     std::shared_ptr<CombinatorType> comb;
                     iterator_type<CombinatorType> comb_iter;
@@ -39,7 +40,8 @@ namespace iter {
                     Iterator(Container& in_container, std::size_t sz)
                         : container_p{&in_container},
                         set_size{sz},
-                        comb{new CombinatorType(combinations(in_container, sz))},
+                        comb{new CombinatorType(
+                                combinations(in_container, sz))},
                         comb_iter{std::begin(*comb)},
                         comb_end{std::end(*comb)}
                     { }
@@ -49,7 +51,8 @@ namespace iter {
                         if (this->comb_iter == this->comb_end) {
                             ++this->set_size;
                             this->comb.reset(new CombinatorType(combinations(
-                                            *this->container_p, this->set_size)));
+                                            *this->container_p,
+                                            this->set_size)));
                             this->comb_iter = std::begin(*this->comb);
                             this->comb_end = std::end(*this->comb);
                         }
@@ -66,6 +69,10 @@ namespace iter {
                         return *this->comb_iter;
                     }
 
+                    iterator_arrow<CombinatorType> operator->() {
+                        apply_arrow(this->comb_iter);
+                    }
+
                     bool operator != (const Iterator& other) const {
                         return !(*this == other);
                     }

From 5d85e4c99f4cf9a17d0641c818b8d17535aa62fe Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 14 Jun 2015 18:49:10 -0700
Subject: [PATCH 1177/1866] adds product iter ->

---
 product.hpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/product.hpp b/product.hpp
index 72ef1b36..c0c90858 100644
--- a/product.hpp
+++ b/product.hpp
@@ -98,6 +98,10 @@ namespace iter {
                                     *this->iter},
                                 *this->rest_iter);
                     }
+
+                    ArrowProxy<ProdIterDeref> operator->() {
+                        return {**this};
+                    }
             };
 
             Iterator begin() {

From 180b87dda6f29cd4a292cc18ce2277f0768eaa5f Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 14 Jun 2015 18:53:24 -0700
Subject: [PATCH 1178/1866] adds range iter ->

though this doesn't make sense without a custom larger numeric type
---
 range.hpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/range.hpp b/range.hpp
index 8ac36aa9..abfed9ba 100644
--- a/range.hpp
+++ b/range.hpp
@@ -204,6 +204,12 @@ namespace iter {
                         return this->data.value();
                     }
 
+#if 0
+                    ArrowProxy<T> operator->() const {
+                        return {**this};
+                    }
+#endif
+
                     Iterator& operator++() {
                         this->data.inc();
                         return *this;

From 41ffc5e8bc7f62f7176a77eeac1bf0626ef91faf Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 14 Jun 2015 18:54:12 -0700
Subject: [PATCH 1179/1866] ArrowProxy can handle references as well

---
 iterbase.hpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/iterbase.hpp b/iterbase.hpp
index 3baf7ba7..1144c1ea 100644
--- a/iterbase.hpp
+++ b/iterbase.hpp
@@ -110,13 +110,14 @@ namespace iter {
     template <typename T>
     class ArrowProxy {
         private:
+            using TPlain = typename std::remove_reference<T>::type;
             T obj;
         public:
             ArrowProxy(T&& in_obj)
-                : obj(std::move(in_obj))
+                : obj(std::forward<T>(in_obj))
             { }
 
-            T *operator->() {
+            TPlain *operator->() {
                 return &obj;
             }
     };

From 421699dcdabf84c0795e4c23bbf054b8658f68f5 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 14 Jun 2015 18:55:52 -0700
Subject: [PATCH 1180/1866] adds repeat iter ->

---
 repeat.hpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/repeat.hpp b/repeat.hpp
index 03ecadce..5f3f8ccf 100644
--- a/repeat.hpp
+++ b/repeat.hpp
@@ -74,6 +74,10 @@ namespace iter {
                     T& operator*() {
                         return *this->elem;
                     }
+
+                    TPlain* operator->() {
+                        return this->elem;
+                    }
             };
 
             Iterator begin() {

From e19fb8ab96d6e7c83eb75c9616f2264141793761 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 14 Jun 2015 18:59:11 -0700
Subject: [PATCH 1181/1866] tests reversed iterator with array

---
 test/test_reversed.cpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/test/test_reversed.cpp b/test/test_reversed.cpp
index 389badd0..cade9326 100644
--- a/test/test_reversed.cpp
+++ b/test/test_reversed.cpp
@@ -65,4 +65,8 @@ TEST_CASE("reversed: iterator meets requirements", "[reversed]") {
     Vec v;
     auto r = reversed(v);
     REQUIRE( itertest::IsIterator<decltype(std::begin(r))>::value );
+
+    int a[1];
+    auto ra = reversed(a);
+    REQUIRE( itertest::IsIterator<decltype(std::begin(ra))>::value );
 }

From 3b2bde08d21dc9706996be3f078673942da05675 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 14 Jun 2015 18:59:27 -0700
Subject: [PATCH 1182/1866] adds reverse_iterator_arrow

---
 iterbase.hpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/iterbase.hpp b/iterbase.hpp
index 1144c1ea..2d3a6b1e 100644
--- a/iterbase.hpp
+++ b/iterbase.hpp
@@ -97,6 +97,9 @@ namespace iter {
     template <typename C>
     using iterator_arrow = detail::arrow<iterator_type<C>>;
 
+    template <typename C>
+    using reverse_iterator_arrow = detail::arrow<reverse_iterator_type<C>>;
+
     // applys the -> operator to an object, if the object is a pointer,
     // it returns the pointer
     template <typename T>

From 65a719856f695db1f654eaaecde5dfc4e07dddc7 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 14 Jun 2015 19:01:54 -0700
Subject: [PATCH 1183/1866] adds reversed iter -> and shortens array types

---
 reversed.hpp | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/reversed.hpp b/reversed.hpp
index 0e03b6c1..795cb7ea 100644
--- a/reversed.hpp
+++ b/reversed.hpp
@@ -40,6 +40,10 @@ namespace iter {
                         return *this->sub_iter;
                     }
 
+                    reverse_iterator_arrow<Container> operator->() {
+                        return apply_arrow(this->sub_iter);
+                    }
+
                     Iterator& operator++() { 
                         ++this->sub_iter;
                         return *this;
@@ -103,10 +107,14 @@ namespace iter {
                         : sub_iter{iter}
                     { } 
 
-                    iterator_deref<T[N]> operator*() {
+                    T& operator*() {
                         return *(this->sub_iter - 1);
                     }
 
+                    T *operator->() {
+                        return (this->sub_iter - 1);
+                    }
+
                     Iterator& operator++() { 
                         --this->sub_iter;
                         return *this;

From cf48d1a3f87eb8a93402b4644ca7e47e5dc56462 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 14 Jun 2015 19:03:53 -0700
Subject: [PATCH 1184/1866] adds slice iter ->

---
 slice.hpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/slice.hpp b/slice.hpp
index 2dfac39d..c97dfc0b 100644
--- a/slice.hpp
+++ b/slice.hpp
@@ -70,6 +70,10 @@ namespace iter {
                         return *this->sub_iter;
                     }
 
+                    iterator_arrow<Container> operator->() {
+                        return apply_arrow(this->sub_iter);
+                    }
+
                     Iterator& operator++() { 
                         dumb_advance(this->sub_iter, this->sub_end,this->step);
                         this->current += this->step;

From 0e5774026d18d33359ce934cc70e0becbc3f68a0 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 14 Jun 2015 19:08:01 -0700
Subject: [PATCH 1185/1866] makes Slice class constructor private

---
 slice.hpp | 44 +++++++++++++++++++++++++++++---------------
 1 file changed, 29 insertions(+), 15 deletions(-)

diff --git a/slice.hpp b/slice.hpp
index c97dfc0b..1880522d 100644
--- a/slice.hpp
+++ b/slice.hpp
@@ -10,15 +10,27 @@
 
 namespace iter {
 
-    //Forward declarations of Slice and slice
-    //template <typename Container, typename DifferenceType>
-    //class Slice;
+    template <typename Container, typename DifferenceType>
+    class Slice;
+
+    template <typename Container, typename DifferenceType>
+    Slice<Container, DifferenceType> slice(
+            Container&& container,
+            DifferenceType start, DifferenceType stop, DifferenceType step=1);
+
+    template <typename Container, typename DifferenceType>
+    Slice<Container, DifferenceType> slice(
+            Container&& container, DifferenceType stop);
+
+    template <typename T, typename DifferenceType>
+    Slice<std::initializer_list<T>, DifferenceType> slice(
+            std::initializer_list<T> il, DifferenceType start,
+            DifferenceType stop, DifferenceType step=1);
 
-    //template <typename T>
-    //Slice<std::initializer_list<T>> slice( std::initializer_list<T>);
+    template <typename T, typename DifferenceType>
+    Slice<std::initializer_list<T>, DifferenceType> slice(
+            std::initializer_list<T> il, DifferenceType stop);
 
-    //template <typename Container, typename DifferenceType>
-    //Slice<Container> slice(Container &&);
     template <typename Container, typename DifferenceType>
     class Slice {
         private:
@@ -27,12 +39,13 @@ namespace iter {
             DifferenceType stop;
             DifferenceType step;
 
-            // The only thing allowed to directly instantiate an Slice is
-            // the slice function
-            //friend Slice slice<Container, DifferenceType>(Container &&);
-            //template <typename T>
-            //friend Slice<std::initializer_list<T>> slice(std::initializer_list<T>);
-        public:
+            friend Slice slice<Container, DifferenceType>(
+                    Container&&, DifferenceType, DifferenceType,
+                    DifferenceType);
+
+            friend Slice slice<Container, DifferenceType>(
+                    Container&&, DifferenceType);
+
             Slice(Container&& in_container, DifferenceType in_start,
                   DifferenceType in_stop, DifferenceType in_step)
                 : container(std::forward<Container>(in_container)),
@@ -42,6 +55,7 @@ namespace iter {
             { }
 
 
+        public:
             class Iterator 
                 : public std::iterator<std::input_iterator_tag,
                     iterator_traits_deref<Container>>
@@ -117,7 +131,7 @@ namespace iter {
     template <typename Container, typename DifferenceType>
     Slice<Container, DifferenceType> slice(
             Container&& container,
-            DifferenceType start, DifferenceType stop, DifferenceType step=1) {
+            DifferenceType start, DifferenceType stop, DifferenceType step) {
         return {std::forward<Container>(container), start, stop, step};
     }
 
@@ -131,7 +145,7 @@ namespace iter {
     template <typename T, typename DifferenceType>
     Slice<std::initializer_list<T>, DifferenceType> slice(
             std::initializer_list<T> il, DifferenceType start,
-            DifferenceType stop, DifferenceType step=1) {
+            DifferenceType stop, DifferenceType step) {
         return {std::move(il), start, stop, step};
     }
 

From d0258b78a8d8619d888c48af999c4029b2c88765 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 14 Jun 2015 19:11:56 -0700
Subject: [PATCH 1186/1866] adds sliding_window iter ->

---
 sliding_window.hpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/sliding_window.hpp b/sliding_window.hpp
index 8d3526e0..36ab877e 100644
--- a/sliding_window.hpp
+++ b/sliding_window.hpp
@@ -74,6 +74,10 @@ namespace iter {
                         return this->window;
                     }
 
+                    DerefVec *operator->() {
+                        return this->window;
+                    }
+
                     Iterator& operator++() {
                         ++this->sub_iter;
                         this->window.get().pop_front();

From daaa8b653e9d3ff56fb35ffdad49180980d48aa7 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 14 Jun 2015 19:14:27 -0700
Subject: [PATCH 1187/1866] *actually* adds range iter ->

---
 range.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/range.hpp b/range.hpp
index abfed9ba..290d743c 100644
--- a/range.hpp
+++ b/range.hpp
@@ -15,6 +15,8 @@
 //
 // If a step of 0 is provided, a RangeException will be thrown
 
+#include "iterbase.hpp"
+
 #include <exception>
 #include <type_traits>
 #include <iterator>
@@ -204,11 +206,9 @@ namespace iter {
                         return this->data.value();
                     }
 
-#if 0
                     ArrowProxy<T> operator->() const {
                         return {**this};
                     }
-#endif
 
                     Iterator& operator++() {
                         this->data.inc();

From 8a503f74f675d15010af9c766072e9b171780415 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 14 Jun 2015 19:14:55 -0700
Subject: [PATCH 1188/1866] adds takewhile iter ->

---
 takewhile.hpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/takewhile.hpp b/takewhile.hpp
index 738502cf..6d514327 100644
--- a/takewhile.hpp
+++ b/takewhile.hpp
@@ -84,6 +84,10 @@ namespace iter {
                         return this->item.get();
                     }
 
+                    typename Holder::pointer operator->() {
+                        return this->item.get_ptr();
+                    }
+
                     Iterator& operator++() { 
                         this->inc_sub_iter();
                         this->check_current();

From 38b3f70275de09df509b2641ef9113af85ee6596 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 14 Jun 2015 19:25:30 -0700
Subject: [PATCH 1189/1866] adjusts unique_justseen for new groupby

---
 unique_justseen.hpp | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/unique_justseen.hpp b/unique_justseen.hpp
index 29d6362a..3eb39cc2 100644
--- a/unique_justseen.hpp
+++ b/unique_justseen.hpp
@@ -8,17 +8,13 @@
 #include <utility>
 #include <iterator>
 #include <initializer_list>
+#include <type_traits>
 
 namespace iter
 {
     template <typename GroupByType>
     struct GroupFrontGetter{
-        auto operator()(iterator_deref<GroupByType>&& gb) ->
-                decltype(*std::begin(gb.second)) {
-            return *std::begin(gb.second);
-        }
-
-        auto operator()(iterator_deref<GroupByType>& gb) ->
+        auto operator()(iterator_deref<GroupByType> gb) ->
                 decltype(*std::begin(gb.second)) {
             return *std::begin(gb.second);
         }

From 4e5713e3fac003a01701bf3ddcd37bd515fa4a88 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 14 Jun 2015 19:30:05 -0700
Subject: [PATCH 1190/1866] adds zip iter ->

---
 zip.hpp | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/zip.hpp b/zip.hpp
index ca3ed78b..59171e48 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -86,6 +86,11 @@ namespace iter {
                                     *this->iter},
                                 *this->rest_iter);
                     }
+
+                    auto operator->() -> ArrowProxy<decltype(**this)> {
+                        return {**this};
+                    }
+
             };
 
             Iterator begin() {
@@ -137,6 +142,10 @@ namespace iter {
                     std::tuple<> operator*() {
                         return std::tuple<>{};
                     }
+
+                    auto operator->() -> ArrowProxy<decltype(**this)> {
+                        return {**this};
+                    }
             };
 
             Iterator begin() {

From f81597aca53d7512cf3efcd11a562cc6c509a023 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 14 Jun 2015 19:33:06 -0700
Subject: [PATCH 1191/1866] adds zip_longest iter ->

---
 zip_longest.hpp | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/zip_longest.hpp b/zip_longest.hpp
index d1cc3e0f..937602df 100644
--- a/zip_longest.hpp
+++ b/zip_longest.hpp
@@ -99,6 +99,11 @@ namespace iter {
                                     *this->rest_iter);
                         }
                     }
+
+                    ArrowProxy<ZipIterDeref> operator->() {
+                        return {**this};
+                    }
+
             };
 
             Iterator begin() {
@@ -141,6 +146,10 @@ namespace iter {
                     constexpr std::tuple<> operator*() const {
                         return {};
                     }
+
+                    constexpr ArrowProxy<std::tuple<>> operator->() const {
+                        return {{}};
+                    }
             };
 
             constexpr Iterator begin() const {

From 2a6468c98c3f4cd5a7dc12488e548b567357e4b3 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 14 Jun 2015 19:35:20 -0700
Subject: [PATCH 1192/1866] adds operator-> to ValidIter (for test_helpers)

---
 test/test_helpers.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/test_helpers.cpp b/test/test_helpers.cpp
index 22d0a858..129a17d2 100644
--- a/test/test_helpers.cpp
+++ b/test/test_helpers.cpp
@@ -17,6 +17,7 @@ class ValidIter {
         bool operator==(const ValidIter&) const;
         bool operator!=(const ValidIter&) const;
         int operator*();
+        void* operator->();
 };
 
 }

From dda0c1912d0104e2dbcc4da3a00abb9e28a4a02a Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 14 Jun 2015 19:40:55 -0700
Subject: [PATCH 1193/1866] corrects chain.from_iterable Iter reqs test

---
 test/test_chain.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/test_chain.cpp b/test/test_chain.cpp
index c2a00fb0..46319d33 100644
--- a/test/test_chain.cpp
+++ b/test/test_chain.cpp
@@ -210,6 +210,6 @@ TEST_CASE("chain.from_iterable: empty", "[chain.from_iterable]") {
 TEST_CASE("chain.from_iterable: iterator meets requirements",
         "[chain.from_iterable]") {
     const std::vector<std::string> v{};
-    auto c = chain(v);
+    auto c = chain.from_iterable(v);
     REQUIRE( itertest::IsIterator<decltype(std::begin(c))>::value );
 }

From d5062d8a5fe33bcd1d845407dad10e72cea9dd2c Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 14 Jun 2015 19:41:23 -0700
Subject: [PATCH 1194/1866] adds chain operator->

---
 chain.hpp | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/chain.hpp b/chain.hpp
index 65e15a36..f150bd18 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -90,6 +90,13 @@ namespace iter {
                         return this->at_end ?
                             *this->rest_iter : *this->sub_iter;
                     }
+
+                    iterator_arrow<Container> operator->() {
+                        return this->at_end ?
+                            apply_arrow(this->rest_iter)
+                            : apply_arrow(this->sub_iter);
+                    }
+
             };
 
             Iterator begin() {
@@ -155,6 +162,10 @@ namespace iter {
                     iterator_deref<Container> operator*() {
                         return *this->sub_iter;
                     }
+
+                    iterator_arrow<Container> operator->() {
+                        return apply_arrow(this->sub_iter);
+                    }
             };
 
             Iterator begin() {

From 155865e694796c010c385b27bfea0b49e540fbbb Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 14 Jun 2015 19:42:43 -0700
Subject: [PATCH 1195/1866] adds chain.from_iterable iter ->

---
 chain.hpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/chain.hpp b/chain.hpp
index f150bd18..1db17ad0 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -292,6 +292,10 @@ namespace iter {
                    iterator_deref<iterator_deref<Container>> operator*() {
                        return **this->sub_iter_p;
                    }
+
+                   iterator_arrow<iterator_deref<Container>> operator->() {
+                       return apply_arrow(*this->sub_iter_p);
+                   }
            };
 
            Iterator begin() {

From a16a48b6d41e9d4c71f45ddac43f7d4621970974 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 19 Jun 2015 11:06:24 -0700
Subject: [PATCH 1196/1866] adds docs on who needs ForwardIterators

---
 README.md | 18 +++++++++++++++++-
 1 file changed, 17 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 5c1c4540..efc92891 100644
--- a/README.md
+++ b/README.md
@@ -272,6 +272,8 @@ for (auto&& i : dropwhile([] (int i) {return i < 5;}, ivec)) {
 
 cycle
 -----
+*Additional Requirements*: Input must have a ForwardIterator
+
 
 Repeatedly produces all values of an iterable.  The loop will be infinite, so a
 `break` or other control flow structure is necessary to exit.
@@ -487,6 +489,8 @@ for (auto&& i : compress(ivec, bvec) {
 
 sorted
 ------
+*Additional Requirements*: Input must have a ForwardIterator
+
 Allows iteration over a sequence in sorted order. `sorted` does
 **not** produce a new sequence, copy elements, or modify the original
 sequence.  It only provides a way to iterate over existing elements.
@@ -507,6 +511,8 @@ for (auto&& i : sorted(nums)) {
 
 chain
 -----
+*Additional Requirements*: The underlying iterators of all containers'
+`operator*` must have the *exact* same type
 
 This can chain any set of ranges together as long as their iterators
 dereference to the same type.
@@ -567,7 +573,11 @@ for (auto&& i : slice(a,0,15,3)) {
 
 sliding\_window
 -------------
-Takes a section from a range and increments the whole section.
+*Additional Requirements*: Input must have a ForwardIterator
+
+Takes a section from a range and increments the whole section.  If the
+window size is larger than the length of the input, the `sliding_window` will
+yield nothing (begin == end).
 
 Example:
 `[1, 2, 3, 4, 5, 6, 7, 8, 9]`
@@ -616,6 +626,7 @@ for (auto&& sec : grouper(v,4))
 
 product
 ------
+*Additional Requirements*: Input must have a ForwardIterator
 
 Generates the cartesian project of the given ranges put together
 
@@ -635,6 +646,7 @@ for (auto&& t : product(v1,v2,v3,v4)) {
 
 combinations
 -----------
+*Additional Requirements*: Input must have a ForwardIterator
 
 Generates n length unique sequences of the input range.
 
@@ -649,6 +661,8 @@ for (auto&& i : combinations(v,3)) {
 
 combinations\_with\_replacement
 -----------------------------
+*Additional Requirements*: Input must have a ForwardIterator
+
 Like combinations, but with replacement of each element.  The
 below is printed by the loop that follows:
 ```
@@ -668,6 +682,7 @@ for (auto&& v : combinations_with_replacement(s, 2)) {
 
 permutations
 -----------
+*Additional Requirements*: Input must have a ForwardIterator
 
 Generates all the permutations of a range using `std::next_permutation`.  The
 iterators of the sequence passed must have an `operator*() const`
@@ -685,6 +700,7 @@ for (auto&& vec : permutations(v)) {
 
 powerset
 -------
+*Additional Requirements*: Input must have a ForwardIterator
 
 Generates every possible subset of a set, runs in O(2^n).
 

From cb403144d3cbdb89760fac2fda8c3e5bfbdb1bb2 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 19 Jun 2015 11:09:41 -0700
Subject: [PATCH 1197/1866] removes doc'ing comments from enumerate

---
 enumerate.hpp | 21 +++++----------------
 1 file changed, 5 insertions(+), 16 deletions(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index 2775232a..a190fb7d 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -9,16 +9,6 @@
 #include <initializer_list>
 #include <type_traits>
 
-
-// enumerate functionality for python-style for-each enumerate loops
-// for (auto e : enumerate(vec)) {
-//     std::cout << e.index
-//               << ": "
-//               << e.element
-//               << '\n';
-// }
-
-
 namespace iter {
 
     //Forward declarations of Enumerable and enumerate
@@ -50,9 +40,9 @@ namespace iter {
             Enumerable(Container&& in_container)
                 : container(std::forward<Container>(in_container))
             { }
-            
+
         public:
-            // "yielded" by the Enumerable::Iterator.  Has a .index, and a 
+            // "yielded" by the Enumerable::Iterator.  Has a .index, and a
             // .element referencing the value yielded by the subiterator
             class IterYield : public BasePair {
                 public:
@@ -74,13 +64,13 @@ namespace iter {
                     Iterator(iterator_type<Container>&& si)
                         : sub_iter{std::move(si)},
                         index{0}
-                    { } 
+                    { }
 
                     IterYield operator*() {
                         return {this->index, *this->sub_iter};
                     }
 
-                    Iterator& operator++() { 
+                    Iterator& operator++() {
                         ++this->sub_iter;
                         ++this->index;
                         return *this;
@@ -116,11 +106,10 @@ namespace iter {
         return {std::forward<Container>(container)};
     }
 
-    // for initializer lists.  copy constructs the list into the Enumerable
     template <typename T>
     Enumerable<std::initializer_list<T>> enumerate(
             std::initializer_list<T> il)
-    {   
+    {
         return {std::move(il)};
     }
 }

From af8bc59055eb09ef756428ce6dafb1c00f89e956 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 21 Jun 2015 11:10:44 -0700
Subject: [PATCH 1198/1866] marks ArrowProxy constructor constexpr

---
 iterbase.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/iterbase.hpp b/iterbase.hpp
index 2d3a6b1e..cc195a0e 100644
--- a/iterbase.hpp
+++ b/iterbase.hpp
@@ -116,7 +116,7 @@ namespace iter {
             using TPlain = typename std::remove_reference<T>::type;
             T obj;
         public:
-            ArrowProxy(T&& in_obj)
+            constexpr ArrowProxy(T&& in_obj)
                 : obj(std::forward<T>(in_obj))
             { }
 

From 83c72a2687775547a60d6ef9b110a670d0ccf72c Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 25 Jun 2015 22:26:44 -0700
Subject: [PATCH 1199/1866] accumulate doesn't default construct intermediate

---
 accumulate.hpp | 39 +++++++++++++++++++++++++++++----------
 1 file changed, 29 insertions(+), 10 deletions(-)

diff --git a/accumulate.hpp b/accumulate.hpp
index c7d4aa7c..0a82ff46 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -8,6 +8,7 @@
 #include <initializer_list>
 #include <functional>
 #include <type_traits>
+#include <memory>
 
 namespace iter {
 
@@ -42,9 +43,6 @@ namespace iter {
                     typename std::result_of<AccumulateFunc(
                             iterator_deref<Container>,
                             iterator_deref<Container>)>::type>::type;
-            static_assert(
-                    std::is_default_constructible<AccumVal>::value,
-                    "Cannot accumulate a non-default constructible type");
 
             Accumulator(Container&& in_container,
                     AccumulateFunc in_accumulate_func)
@@ -60,31 +58,52 @@ namespace iter {
                     iterator_type<Container> sub_iter;
                     iterator_type<Container> sub_end;
                     AccumulateFunc accumulate_func;
-                    AccumVal acc_val;
+                    std::unique_ptr<AccumVal> acc_val;
                 public:
-                    Iterator (iterator_type<Container>&& iter,
+                    Iterator(iterator_type<Container>&& iter,
                             iterator_type<Container>&& end,
                             AccumulateFunc in_accumulate_func)
                         : sub_iter{std::move(iter)},
                         sub_end{std::move(end)},
                         accumulate_func(in_accumulate_func),
                         // only get first value if not an end iterator
-                        acc_val(!(iter != end) ? AccumVal{} : *iter)
+                        acc_val{!(iter != end) ? nullptr : new AccumVal(*iter)}
                     { } 
 
+                    Iterator(const Iterator& other)
+                        : sub_iter{other.sub_iter},
+                        sub_end{other.sub_end},
+                        accumulate_func{other.accumulate_func},
+                        acc_val{other.acc_val ?
+                                new AccumVal(*other.acc_val) : nullptr}
+                    { }
+
+                    Iterator& operator=(const Iterator& other) {
+                        if (this == &other) return *this;
+                        this->sub_iter = other.sub_iter;
+                        this->sub_end = other.sub_end;
+                        this->accumulate_func = other.accumulate_func;
+                        this->acc_val.reset(other.acc_val ?
+                                new AccumVal(*other.acc_val) : nullptr);
+                        return *this;
+                    }
+
+                    Iterator(Iterator&&) =default;
+                    Iterator& operator=(Iterator&&) =default;
+
                     const AccumVal& operator*() const {
-                        return this->acc_val;
+                        return *this->acc_val;
                     }
 
                     const AccumVal* operator->() const {
-                        return &this->acc_val;
+                        return this->acc_val.get();
                     }
 
                     Iterator& operator++() { 
                         ++this->sub_iter;
                         if (this->sub_iter != this->sub_end) {
-                            this->acc_val = accumulate_func(
-                                    this->acc_val, *this->sub_iter);
+                            *this->acc_val = accumulate_func(
+                                    *this->acc_val, *this->sub_iter);
                         }
                         return *this;
                     }

From 116e6d5ab37e8e22707f0203556d89a4aa81b0dc Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 25 Jun 2015 22:27:51 -0700
Subject: [PATCH 1200/1866] tests accumulate with lambda iters are assignable

---
 test/test_accumulate.cpp | 19 ++++++++++++++++++-
 1 file changed, 18 insertions(+), 1 deletion(-)

diff --git a/test/test_accumulate.cpp b/test/test_accumulate.cpp
index 00c9f469..1a4e9413 100644
--- a/test/test_accumulate.cpp
+++ b/test/test_accumulate.cpp
@@ -37,6 +37,21 @@ TEST_CASE("accumulate: with initializer_list works", "[accumulate]") {
     REQUIRE( v == vc );
 }
 
+struct Integer {
+    const int value;
+    constexpr Integer(int i) : value{i} { }
+    constexpr Integer operator+(Integer other) const noexcept {
+        return {this->value + other.value};
+    }
+};
+
+TEST_CASE("accumulate: intermidate type need not be default constructible",
+        "[accumulate]") {
+    std::vector<Integer> v = {{2}, {3}, {10}};
+    auto a = accumulate(v, std::plus<Integer>{});
+    auto it = std::begin(a);
+}
+
 TEST_CASE("accumulate: binds reference when it should", "[accumulate]") {
     BasicIterable<int> bi{1, 2};
     accumulate(bi);
@@ -73,6 +88,8 @@ TEST_CASE("accumulate: operator->", "[accumulate]") {
 
 TEST_CASE("accumulate: iterator meets requirements", "[accumulate]") {
     Vec ns{};
-    auto a = accumulate(ns);
+    auto a = accumulate(ns, [](int a, int b) { return a + b; });
+    auto it = std::begin(a);
+    it = std::begin(a);
     REQUIRE( itertest::IsIterator<decltype(std::begin(a))>::value );
 }

From cd477bf3cc7a4c132cbc0b00e818a6859196fa7d Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 25 Jun 2015 22:28:29 -0700
Subject: [PATCH 1201/1866] makes accumulate iters with lambda assignable

---
 accumulate.hpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/accumulate.hpp b/accumulate.hpp
index 0a82ff46..bc006abf 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -57,7 +57,7 @@ namespace iter {
                 private:
                     iterator_type<Container> sub_iter;
                     iterator_type<Container> sub_end;
-                    AccumulateFunc accumulate_func;
+                    AccumulateFunc *accumulate_func;
                     std::unique_ptr<AccumVal> acc_val;
                 public:
                     Iterator(iterator_type<Container>&& iter,
@@ -65,7 +65,7 @@ namespace iter {
                             AccumulateFunc in_accumulate_func)
                         : sub_iter{std::move(iter)},
                         sub_end{std::move(end)},
-                        accumulate_func(in_accumulate_func),
+                        accumulate_func(&in_accumulate_func),
                         // only get first value if not an end iterator
                         acc_val{!(iter != end) ? nullptr : new AccumVal(*iter)}
                     { } 
@@ -102,7 +102,7 @@ namespace iter {
                     Iterator& operator++() { 
                         ++this->sub_iter;
                         if (this->sub_iter != this->sub_end) {
-                            *this->acc_val = accumulate_func(
+                            *this->acc_val = (*accumulate_func)(
                                     *this->acc_val, *this->sub_iter);
                         }
                         return *this;

From ca9e87db48cfce758f0305364997e056ee8c530e Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 29 Jun 2015 21:00:32 -0700
Subject: [PATCH 1202/1866] changes range to have an empty range when step=0

this seems like the best choice if I'm not gonna throw, and I'd prefer
not to throw, it seems heavyweight for the problem.  I doubt this will
be a real issue anyway. I can't personally remember ever needing to deal
with a step of 0 in python in any way, I had to go see how it behaved
when I originally wrote this range, actually.
---
 test/test_range.cpp | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/test/test_range.cpp b/test/test_range.cpp
index 6af09277..daaed8a5 100644
--- a/test/test_range.cpp
+++ b/test/test_range.cpp
@@ -89,8 +89,11 @@ TEST_CASE("range: stops short when step > stop-start", "[range]") {
     REQUIRE( v.size() == 1 );
 }
 
-TEST_CASE("No 0 step ranges allowed", "[range]") {
-    REQUIRE_THROWS(range(0, 1, 0));
+TEST_CASE("Step size of 0 gives an empty range", "[range]") {
+    auto r = range(0, 10, 0);
+    REQUIRE( std::begin(r) == std::end(r) );
+    auto r2 = range(0, -10, 0);
+    REQUIRE( std::begin(r2) == std::end(r2) );
 }
 
 TEST_CASE("range: works with a variable start, stop, and step", "[range]") {

From 05c9a4fe288778dea4004d9b48e87e0555dff07a Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 29 Jun 2015 21:03:45 -0700
Subject: [PATCH 1203/1866] modifies range to meet the new test

---
 range.hpp | 25 +------------------------
 1 file changed, 1 insertion(+), 24 deletions(-)

diff --git a/range.hpp b/range.hpp
index 290d743c..289ef52c 100644
--- a/range.hpp
+++ b/range.hpp
@@ -1,20 +1,6 @@
 #ifndef ITER_RANGE_H_
 #define ITER_RANGE_H_
 
-// range() for range-based loops with start, stop, and step.
-//
-// Acceptable forms are:
-// for (auto i : range(stop)) { ... } // start = 0, step = 1
-// for (auto i : range(start, stop)) { ... } // step = 1
-// for (auto i : range(start, stop, step)) { ... }
-//
-// The start may be greater than the stop if the range is negative
-// The range will effectively be empty if:
-//   1) step is positive and start > stop
-//   2) step is negative and start < stop
-//
-// If a step of 0 is provided, a RangeException will be thrown
-
 #include "iterbase.hpp"
 
 #include <exception>
@@ -105,13 +91,6 @@ namespace iter {
     };
 
 
-    // Thrown when step 0 occurs
-    class RangeException : public std::exception {
-        const char *what() const noexcept override {
-            return "range step must be non-zero";
-        }
-    };
-
     template <typename T>
     class Range;
 
@@ -279,9 +258,7 @@ namespace iter {
 
     template <typename T>
     Range<T> range(T start, T stop, T step) {
-        if (step == 0) {
-            throw RangeException{};
-        }
+        if (step == T(0)) return {0};
         return {start, stop, step};
     }
 }

From c1445afc47c1acd0f5cb70ad582aedbb73954765 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 29 Jun 2015 21:04:00 -0700
Subject: [PATCH 1204/1866] documents range(x, y, 0) behavior

---
 README.md | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/README.md b/README.md
index efc92891..02a6ba6e 100644
--- a/README.md
+++ b/README.md
@@ -141,6 +141,14 @@ for (auto i : range(2, -3, -1)) {
 }
 ```
 
+A step size of 0 results in an empty range (Python's raises an exception).
+The following prints nothing
+```c++
+for (auto i : range(0, 10, 0)) {
+    cout << i << '\n';
+}
+```
+
 In addition to normal integer range operations, doubles and
 other numeric types are supported through the template
 

From 47164c34c5d66892f44231a421964a88212498da Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 29 Jun 2015 21:10:21 -0700
Subject: [PATCH 1205/1866] tests that ranges can be created constexpr

---
 test/test_range.cpp | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/test/test_range.cpp b/test/test_range.cpp
index daaed8a5..f9b29010 100644
--- a/test/test_range.cpp
+++ b/test/test_range.cpp
@@ -89,13 +89,19 @@ TEST_CASE("range: stops short when step > stop-start", "[range]") {
     REQUIRE( v.size() == 1 );
 }
 
-TEST_CASE("Step size of 0 gives an empty range", "[range]") {
+TEST_CASE("range: step size of 0 gives an empty range", "[range]") {
     auto r = range(0, 10, 0);
     REQUIRE( std::begin(r) == std::end(r) );
     auto r2 = range(0, -10, 0);
     REQUIRE( std::begin(r2) == std::end(r2) );
 }
 
+TEST_CASE("range: can create constexpr ranges", "[range]") {
+    constexpr auto r = range(10); (void)r;
+    constexpr auto r2 = range(4, 10); (void)r2;
+    constexpr auto r3 = range(4, 10, 2); (void)r3;
+}
+
 TEST_CASE("range: works with a variable start, stop, and step", "[range]") {
     constexpr int a = 10;
     constexpr int b = 100;

From 33490c1b57acb9f7bdf9c2f18d920a3554703b9a Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 29 Jun 2015 21:10:26 -0700
Subject: [PATCH 1206/1866] ranges can be created as constexpr

---
 range.hpp | 19 +++++++++----------
 1 file changed, 9 insertions(+), 10 deletions(-)

diff --git a/range.hpp b/range.hpp
index 289ef52c..85cb4965 100644
--- a/range.hpp
+++ b/range.hpp
@@ -95,11 +95,11 @@ namespace iter {
     class Range;
 
     template <typename T>
-    Range<T> range(T);
+    constexpr Range<T> range(T);
     template <typename T>
-    Range<T> range(T, T);
+    constexpr Range<T> range(T, T);
     template <typename T>
-    Range<T> range(T, T, T);
+    constexpr Range<T> range(T, T, T);
 
     // General version for everything not a float
     template <typename T>
@@ -112,13 +112,13 @@ namespace iter {
             const T stop;
             const T step;
 
-            Range(T in_stop)
+            constexpr Range(T in_stop)
                 : start{0},
                 stop{in_stop},
                 step{1}
             { }
 
-            Range(T in_start, T in_stop, T in_step =1)
+            constexpr Range(T in_start, T in_stop, T in_step =1)
                 : start{in_start},
                 stop{in_stop},
                 step{in_step}
@@ -247,19 +247,18 @@ namespace iter {
     };
 
     template <typename T>
-    Range<T> range(T stop) {
+    constexpr Range<T> range(T stop) {
         return {stop};
     }
 
     template <typename T>
-    Range<T> range(T start, T stop) {
+    constexpr Range<T> range(T start, T stop) {
         return {start, stop};
     }
 
     template <typename T>
-    Range<T> range(T start, T stop, T step) {
-        if (step == T(0)) return {0};
-        return {start, stop, step};
+    constexpr Range<T> range(T start, T stop, T step) {
+        return step == T(0) ? Range<T>{0} : Range<T>{start, stop, step};
     }
 }
 

From ce00107424214e0e57b126563e5f4e76f178470b Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 29 Jun 2015 21:19:59 -0700
Subject: [PATCH 1207/1866] adds more constexprs to range

This will be extended with C++14 constexpr functions.  I could mangle a
lot here with ternaries to make them work with constexpr, but without ++
it doesn't really help.
---
 range.hpp | 42 +++++++++++++++++++++---------------------
 1 file changed, 21 insertions(+), 21 deletions(-)

diff --git a/range.hpp b/range.hpp
index 85cb4965..1d0928b2 100644
--- a/range.hpp
+++ b/range.hpp
@@ -20,17 +20,17 @@ namespace iter {
             T value_{};
             T step_{};
         public:
-            RangeIterData() =default;
-            RangeIterData(T in_value, T in_step)
+            constexpr RangeIterData() =default;
+            constexpr RangeIterData(T in_value, T in_step)
                 : value_{in_value},
                 step_{in_step}
             { }
 
-            T value() const {
+            constexpr T value() const {
                 return this->value_;
             }
 
-            T step() const {
+            constexpr T step() const {
                 return this->step_;
             }
 
@@ -38,11 +38,11 @@ namespace iter {
                 this->value_ += step_;
             }
 
-            bool operator==(const RangeIterData& other) const {
+            constexpr bool operator==(const RangeIterData& other) const {
               return this->value_ == other.value_;
             }
 
-            bool operator!=(const RangeIterData& other) const {
+            constexpr bool operator!=(const RangeIterData& other) const {
               return !(*this == other);
             }
     };
@@ -56,18 +56,18 @@ namespace iter {
             T step_{};
             unsigned long steps_taken{};
         public:
-            RangeIterData() =default;
-            RangeIterData(T in_start, T in_step)
+            constexpr RangeIterData() =default;
+            constexpr RangeIterData(T in_start, T in_step)
                 : start_{in_start},
                 value_{in_start},
                 step_{in_step}
             { }
 
-            T value() const {
+            constexpr T value() const {
                 return this->value_;
             }
 
-            T step() const {
+            constexpr T step() const {
                 return this->step_;
             }
 
@@ -77,15 +77,15 @@ namespace iter {
                         (this->step_ * this->steps_taken);
             }
 
-            bool operator==(const RangeIterData& other) const {
+            constexpr bool operator==(const RangeIterData& other) const {
                 // if the difference between the two values is less than the
                 // step size, they are considered equal
-                T diff = this->value_ < other.value_ ?
-                    other.value_ - this->value_ : this->value_ - other.value_;
-                return diff < step_;
+                return (this->value_ < other.value_ ?
+                    other.value_ - this->value_ :
+                    this->value_ - other.value_) < this->step_;
             }
 
-            bool operator!=(const RangeIterData& other) const {
+            constexpr bool operator!=(const RangeIterData& other) const {
               return !(*this == other);
             }
     };
@@ -174,18 +174,18 @@ namespace iter {
                     }
 
                 public:
-                    Iterator() =default;
+                    constexpr Iterator() =default;
 
-                    Iterator(T in_value, T in_step, bool in_is_end)
+                    constexpr Iterator(T in_value, T in_step, bool in_is_end)
                         : data(in_value, in_step),
                         is_end{in_is_end}
                     { }
 
-                    T operator*() const {
+                    constexpr T operator*() const {
                         return this->data.value();
                     }
 
-                    ArrowProxy<T> operator->() const {
+                    constexpr ArrowProxy<T> operator->() const {
                         return {**this};
                     }
 
@@ -237,11 +237,11 @@ namespace iter {
                     }
             };
 
-            Iterator begin() const {
+            constexpr Iterator begin() const {
                 return {start, step, false};
             }
 
-            Iterator end() const {
+            constexpr Iterator end() const {
                 return {stop, step, true};
             }
     };

From 494f56eb660e80fe9d3fb4cba8e6fc21c0cfd0cd Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 29 Jun 2015 21:22:30 -0700
Subject: [PATCH 1208/1866] tests creating a constexpr iterator

---
 test/test_range.cpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/test/test_range.cpp b/test/test_range.cpp
index f9b29010..d2c21617 100644
--- a/test/test_range.cpp
+++ b/test/test_range.cpp
@@ -100,6 +100,10 @@ TEST_CASE("range: can create constexpr ranges", "[range]") {
     constexpr auto r = range(10); (void)r;
     constexpr auto r2 = range(4, 10); (void)r2;
     constexpr auto r3 = range(4, 10, 2); (void)r3;
+
+    constexpr auto it = r2.begin(); // std::begin isn't constexpr
+    constexpr auto i = *it;
+    static_assert(i == 4, "range's begin has the wrong value");
 }
 
 TEST_CASE("range: works with a variable start, stop, and step", "[range]") {

From f6606acf734ed29dce8acd8dbe0615cbb1786664 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 29 Jun 2015 21:24:21 -0700
Subject: [PATCH 1209/1866] tests range iters constexpr-ness

---
 test/test_range.cpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/test/test_range.cpp b/test/test_range.cpp
index d2c21617..887cee8b 100644
--- a/test/test_range.cpp
+++ b/test/test_range.cpp
@@ -104,6 +104,11 @@ TEST_CASE("range: can create constexpr ranges", "[range]") {
     constexpr auto it = r2.begin(); // std::begin isn't constexpr
     constexpr auto i = *it;
     static_assert(i == 4, "range's begin has the wrong value");
+
+    constexpr auto rf = range(10.0);
+    constexpr auto itf = rf.begin();
+    constexpr auto f = *itf;
+    static_assert(f == 0.0, "range's begin has tho wrong value (float)");
 }
 
 TEST_CASE("range: works with a variable start, stop, and step", "[range]") {

From 144ff04e052604c2dc813a75d0b4a152ae598070 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 29 Jun 2015 22:16:40 -0700
Subject: [PATCH 1210/1866] adds constexpr to count()

---
 count.hpp | 16 ++++++++++------
 1 file changed, 10 insertions(+), 6 deletions(-)

diff --git a/count.hpp b/count.hpp
index c4e62087..c12263e0 100644
--- a/count.hpp
+++ b/count.hpp
@@ -8,15 +8,19 @@
 namespace iter {
 
     template <typename T>
-    auto count(T start, T step) -> decltype(range(start, start, start)) {
-        // if step is < 0, set the stop to numeric min, otherwise numeric max
-        T stop = step < T(0) ? std::numeric_limits<T>::min() :
-                            std::numeric_limits<T>::max();
-        return range(start, stop, step);
+    constexpr auto count(T start, T step)
+            -> decltype(range(start, start, start)) {
+        // if step is < 0, stop is numeric min, otherwise numeric max
+        return range(
+                start,
+                step < T(0) ? std::numeric_limits<T>::min() :
+                    std::numeric_limits<T>::max(),
+                step);
     }
 
     template <typename T =long>
-    auto count(T start =T(0)) -> decltype(range(start, start)) {
+    constexpr auto count(T start =T(0))
+            -> decltype(range(start, start)) {
         return count(start, T(1));
     }
 }

From 22b3c7d5c036bdac240a4ef23f1b8893bc3dccaa Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 29 Jun 2015 22:16:44 -0700
Subject: [PATCH 1211/1866] tests count with constexpr

---
 test/test_count.cpp | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/test/test_count.cpp b/test/test_count.cpp
index 12b1347b..0b861bbf 100644
--- a/test/test_count.cpp
+++ b/test/test_count.cpp
@@ -53,6 +53,16 @@ TEST_CASE("count: with step > 1", "[count]") {
     REQUIRE( v == vc );
 }
 
+TEST_CASE("count: can bo constexpr", "[count]") {
+    constexpr auto c = count();
+    constexpr auto c2 = count(5); (void)c2;
+    constexpr auto c3 = count(5, 2); (void)c3;
+
+    constexpr auto it = c.begin();
+    constexpr auto i = *it;
+    static_assert(i == 0, "count begin not correct value");
+}
+
 TEST_CASE("count: iterator meets requirements", "[count]") {
     auto c = count();
     REQUIRE( itertest::IsIterator<decltype(std::begin(c))>::value );

From 7f500b18bf4f62919d1c2dc3e915a82211f4e79f Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 29 Jun 2015 22:30:16 -0700
Subject: [PATCH 1212/1866] noexcept like a boss

---
 range.hpp | 77 +++++++++++++++++++++++++++++--------------------------
 1 file changed, 41 insertions(+), 36 deletions(-)

diff --git a/range.hpp b/range.hpp
index 1d0928b2..f412a93b 100644
--- a/range.hpp
+++ b/range.hpp
@@ -20,29 +20,31 @@ namespace iter {
             T value_{};
             T step_{};
         public:
-            constexpr RangeIterData() =default;
-            constexpr RangeIterData(T in_value, T in_step)
+            constexpr RangeIterData() noexcept =default;
+            constexpr RangeIterData(T in_value, T in_step) noexcept
                 : value_{in_value},
                 step_{in_step}
             { }
 
-            constexpr T value() const {
+            constexpr T value() const noexcept {
                 return this->value_;
             }
 
-            constexpr T step() const {
+            constexpr T step() const noexcept {
                 return this->step_;
             }
 
-            void inc() {
+            void inc() noexcept {
                 this->value_ += step_;
             }
 
-            constexpr bool operator==(const RangeIterData& other) const {
+            constexpr bool operator==(const RangeIterData& other)
+                const noexcept {
               return this->value_ == other.value_;
             }
 
-            constexpr bool operator!=(const RangeIterData& other) const {
+            constexpr bool operator!=(const RangeIterData& other)
+                const noexcept {
               return !(*this == other);
             }
     };
@@ -56,28 +58,29 @@ namespace iter {
             T step_{};
             unsigned long steps_taken{};
         public:
-            constexpr RangeIterData() =default;
-            constexpr RangeIterData(T in_start, T in_step)
+            constexpr RangeIterData() noexcept =default;
+            constexpr RangeIterData(T in_start, T in_step) noexcept
                 : start_{in_start},
                 value_{in_start},
                 step_{in_step}
             { }
 
-            constexpr T value() const {
+            constexpr T value() const noexcept {
                 return this->value_;
             }
 
-            constexpr T step() const {
+            constexpr T step() const noexcept {
                 return this->step_;
             }
 
-            void inc() {
+            void inc() noexcept {
                 ++this->steps_taken;
                 value_ = this->start_ +
                         (this->step_ * this->steps_taken);
             }
 
-            constexpr bool operator==(const RangeIterData& other) const {
+            constexpr bool operator==(const RangeIterData& other)
+                    const noexcept {
                 // if the difference between the two values is less than the
                 // step size, they are considered equal
                 return (this->value_ < other.value_ ?
@@ -85,8 +88,9 @@ namespace iter {
                     this->value_ - other.value_) < this->step_;
             }
 
-            constexpr bool operator!=(const RangeIterData& other) const {
-              return !(*this == other);
+            constexpr bool operator!=(const RangeIterData& other)
+                  const noexcept {
+                return !(*this == other);
             }
     };
 
@@ -95,11 +99,11 @@ namespace iter {
     class Range;
 
     template <typename T>
-    constexpr Range<T> range(T);
+    constexpr Range<T> range(T) noexcept;
     template <typename T>
-    constexpr Range<T> range(T, T);
+    constexpr Range<T> range(T, T) noexcept;
     template <typename T>
-    constexpr Range<T> range(T, T, T);
+    constexpr Range<T> range(T, T, T) noexcept;
 
     // General version for everything not a float
     template <typename T>
@@ -112,13 +116,13 @@ namespace iter {
             const T stop;
             const T step;
 
-            constexpr Range(T in_stop)
+            constexpr Range(T in_stop) noexcept
                 : start{0},
                 stop{in_stop},
                 step{1}
             { }
 
-            constexpr Range(T in_start, T in_stop, T in_step =1)
+            constexpr Range(T in_start, T in_stop, T in_step =1) noexcept
                 : start{in_start},
                 stop{in_stop},
                 step{in_step}
@@ -144,7 +148,7 @@ namespace iter {
                     // compare unsigned values
                     static bool not_equal_to_impl(
                             const Iterator& iter, const Iterator& end_iter,
-                            std::true_type ) {
+                            std::true_type ) noexcept {
                         assert(!iter.is_end);
                         assert(end_iter.is_end);
                         return iter.data.value() < end_iter.data.value();
@@ -153,7 +157,7 @@ namespace iter {
                     // compare signed values
                     static bool not_equal_to_impl(
                             const Iterator& iter, const Iterator& end_iter,
-                            std::false_type) {
+                            std::false_type) noexcept {
                         assert(!iter.is_end);
                         assert(end_iter.is_end);
                         return !(iter.data.step() > 0 && iter.data.value()
@@ -162,8 +166,8 @@ namespace iter {
                                  <= end_iter.data.value());
                     }
 
-                    static bool not_equal_to_end(
-                            const Iterator& lhs, const Iterator& rhs) {
+                    static bool not_equal_to_end(const Iterator& lhs,
+                            const Iterator& rhs) noexcept{
                         if (rhs.is_end) {
                             return not_equal_to_impl(
                                     lhs, rhs, std::is_unsigned<T>{});
@@ -174,27 +178,28 @@ namespace iter {
                     }
 
                 public:
-                    constexpr Iterator() =default;
+                    constexpr Iterator() noexcept =default;
 
                     constexpr Iterator(T in_value, T in_step, bool in_is_end)
+                        noexcept
                         : data(in_value, in_step),
                         is_end{in_is_end}
                     { }
 
-                    constexpr T operator*() const {
+                    constexpr T operator*() const noexcept {
                         return this->data.value();
                     }
 
-                    constexpr ArrowProxy<T> operator->() const {
+                    constexpr ArrowProxy<T> operator->() const noexcept {
                         return {**this};
                     }
 
-                    Iterator& operator++() {
+                    Iterator& operator++() noexcept {
                         this->data.inc();
                         return *this;
                     }
 
-                    Iterator operator++(int) {
+                    Iterator operator++(int) noexcept {
                         auto ret = *this;
                         ++*this;
                         return ret;
@@ -221,7 +226,7 @@ namespace iter {
                     // Two end iterators will compare equal
                     //
                     // Two non-end iterators will compare by their stored values
-                    bool operator!=(const Iterator& other) const {
+                    bool operator!=(const Iterator& other) const noexcept {
                         if (this->is_end && other.is_end) {
                             return false;
                         }
@@ -232,32 +237,32 @@ namespace iter {
                         return not_equal_to_end(*this, other);
                     }
 
-                    bool operator==(const Iterator& other) const {
+                    bool operator==(const Iterator& other) const noexcept {
                         return !(*this != other);
                     }
             };
 
-            constexpr Iterator begin() const {
+            constexpr Iterator begin() const noexcept {
                 return {start, step, false};
             }
 
-            constexpr Iterator end() const {
+            constexpr Iterator end() const noexcept {
                 return {stop, step, true};
             }
     };
 
     template <typename T>
-    constexpr Range<T> range(T stop) {
+    constexpr Range<T> range(T stop) noexcept {
         return {stop};
     }
 
     template <typename T>
-    constexpr Range<T> range(T start, T stop) {
+    constexpr Range<T> range(T start, T stop) noexcept {
         return {start, stop};
     }
 
     template <typename T>
-    constexpr Range<T> range(T start, T stop, T step) {
+    constexpr Range<T> range(T start, T stop, T step) noexcept {
         return step == T(0) ? Range<T>{0} : Range<T>{start, stop, step};
     }
 }

From 8a87992272d085f4da547c810848760635d88e26 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 29 Jun 2015 22:52:40 -0700
Subject: [PATCH 1213/1866] noexcept like a boss

---
 count.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/count.hpp b/count.hpp
index c12263e0..eec82f4e 100644
--- a/count.hpp
+++ b/count.hpp
@@ -8,7 +8,7 @@
 namespace iter {
 
     template <typename T>
-    constexpr auto count(T start, T step)
+    constexpr auto count(T start, T step) noexcept
             -> decltype(range(start, start, start)) {
         // if step is < 0, stop is numeric min, otherwise numeric max
         return range(
@@ -19,7 +19,7 @@ namespace iter {
     }
 
     template <typename T =long>
-    constexpr auto count(T start =T(0))
+    constexpr auto count(T start =T(0)) noexcept
             -> decltype(range(start, start)) {
         return count(start, T(1));
     }

From cd8eb30924d31aea824638e8b8295155934c66db Mon Sep 17 00:00:00 2001
From: Jiri Hoogland <jiri.hoogland@gmail.com>
Date: Fri, 10 Jul 2015 22:46:04 -0400
Subject: [PATCH 1214/1866] Fix OSX build

---
 examples/groupby_examples.cpp | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/examples/groupby_examples.cpp b/examples/groupby_examples.cpp
index e4ae4048..c18f9a4c 100644
--- a/examples/groupby_examples.cpp
+++ b/examples/groupby_examples.cpp
@@ -5,9 +5,14 @@
 #include <string>
 #include <functional>
 
+// fix OSX compilation
+static int string_length(const std::string & str)
+{
+    return str.length();
+}
 
 int main() {
-    auto len = std::mem_fn(&std::string::length);
+    auto len = string_length;
     std::vector<std::string> vec = {
         "hi", "ab", "ho",
         "abc", "def",

From 47b6494f918bc3889dc74c8515b3eda1a329119d Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 12 Jul 2015 12:20:03 -0700
Subject: [PATCH 1215/1866] tests that repeat can be constexpr

---
 test/test_repeat.cpp | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/test/test_repeat.cpp b/test/test_repeat.cpp
index 59d0256d..3cb9e45f 100644
--- a/test/test_repeat.cpp
+++ b/test/test_repeat.cpp
@@ -24,6 +24,24 @@ TEST_CASE("repeat: one argument keeps giving value back", "[repeat]") {
     REQUIRE( *it == 'a' );
 }
 
+TEST_CASE("repeat: can be used as constexpr", "[repeat]") {
+    static constexpr char c = 'a';
+    {
+        constexpr auto r = repeat(c);
+        constexpr auto i = r.begin();
+        constexpr char c2 = *i;
+        static_assert(c == c2, "repeat value not as expected");
+        constexpr auto i2 = ++i; (void)i2;
+    }
+
+    {
+        constexpr auto r = repeat(c, 2);
+        constexpr auto i = r.begin();
+        constexpr char c2 = *i;
+        static_assert( c2 == c, "repeat value not as expected");
+    }
+}
+
 TEST_CASE("repeat: two argument repeats a number of times", "[repeat]") {
     auto r = repeat('a', 3);
     std::string s(std::begin(r), std::end(r));

From d315cee4498746b169d65e7a60410799f8626469 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 12 Jul 2015 12:21:55 -0700
Subject: [PATCH 1216/1866] adds constexpr spec to repeat

---
 repeat.hpp | 124 +++++++++++++++++++++++++++++++++++++----------------
 1 file changed, 86 insertions(+), 38 deletions(-)

diff --git a/repeat.hpp b/repeat.hpp
index 5f3f8ccf..b2449baf 100644
--- a/repeat.hpp
+++ b/repeat.hpp
@@ -6,54 +6,40 @@
 #include <utility>
 
 namespace iter {
-
-    // must be negative
-    constexpr int INFINITE_REPEAT = -1;
-
-    template <typename T>
-    class Repeater;
-
     template <typename T>
-    Repeater<T> repeat(T&&);
+    class RepeaterWithCount ;
 
     template <typename T>
-    Repeater<T> repeat(T&&, int);
+    constexpr RepeaterWithCount<T> repeat(T&&, int);
 
     template <typename T>
-    class Repeater {
-        friend Repeater repeat<T>(T&&);
-        friend Repeater repeat<T>(T&&, int);
+    class RepeaterWithCount {
+        friend RepeaterWithCount repeat<T>(T&&, int);
         private:
-            using TPlain = typename std::remove_reference<T>::type;
             T elem;
             int count;
 
-            Repeater(T e, int c)
+            constexpr RepeaterWithCount(T e, int c)
                 : elem(std::forward<T>(e)),
                 count{c}
             { }
-        public:
 
+            using TPlain = typename std::remove_reference<T>::type;
+        public:
             class Iterator
-                : public std::iterator<std::input_iterator_tag, TPlain>
+                : public std::iterator<std::input_iterator_tag, const TPlain>
             {
                 private:
-                    TPlain* elem;
+                    const TPlain *elem;
                     int count;
                 public:
-                    Iterator(TPlain* e, int c)
+                    constexpr Iterator(const TPlain* e, int c)
                         : elem{e},
                         count{c}
                     { }
 
-                    // count down to 0
-                    // INFINITE_REPEAT will be negative, and in that case
-                    // the value is never decremented, it will always compare
-                    // != to an end iterator
                     Iterator& operator++() {
-                        if (this->count > 0) {
-                            --this->count;
-                        }
+                        --this->count;
                         return *this;
                     }
 
@@ -63,43 +49,105 @@ namespace iter {
                         return ret;
                     }
 
-                    bool operator!=(const Iterator& other) const {
+                    constexpr bool operator!=(const Iterator& other) const {
                         return !(*this == other);
                     }
 
-                    bool operator==(const Iterator& other) const {
+                    constexpr bool operator==(const Iterator& other) const {
                         return this->count == other.count;
                     }
 
-                    T& operator*() {
+                    constexpr const TPlain& operator*() const {
                         return *this->elem;
                     }
 
-                    TPlain* operator->() {
+                    constexpr const TPlain* operator->() const {
                         return this->elem;
                     }
             };
 
-            Iterator begin() {
+            constexpr Iterator begin() {
                 return {&this->elem, this->count};
             }
 
-            Iterator end() {
+            constexpr Iterator end() {
                 return {&this->elem, 0};
             }
 
     };
-
-    template <typename T>
-    Repeater<T> repeat(T&& e) {
-        return {std::forward<T>(e), INFINITE_REPEAT};
-    }
         
     template <typename T>
-    Repeater<T> repeat(T&& e, int count) {
-        // if count is negative, pass 0 instead
+    constexpr RepeaterWithCount<T> repeat(T&& e, int count) {
         return {std::forward<T>(e), count < 0 ? 0 : count};
     }
+
+    template <typename T>
+    class Repeater;
+
+    template <typename T>
+    constexpr Repeater<T> repeat(T&&);
+
+    template <typename T>
+    class Repeater{
+        friend Repeater repeat<T>(T&&);
+        private:
+            using TPlain = typename std::remove_reference<T>::type;
+            T elem;
+
+            constexpr Repeater(T e)
+                : elem(std::forward<T>(e))
+            { }
+        public:
+            class Iterator
+                : public std::iterator<std::input_iterator_tag, const TPlain>
+            {
+                private:
+                    const TPlain *elem;
+
+                public:
+                    constexpr Iterator(const TPlain* e)
+                        : elem{e}
+                    { }
+
+                    constexpr const Iterator& operator++() const {
+                        return *this;
+                    }
+
+                    constexpr Iterator operator++(int) const {
+                        return *this;
+                    }
+
+                    constexpr bool operator!=(const Iterator&) const {
+                        return true;
+                    }
+
+                    constexpr bool operator==(const Iterator&) const {
+                        return false;
+                    }
+
+                    constexpr const TPlain& operator*() const {
+                        return *this->elem;
+                    }
+
+                    constexpr const TPlain* operator->() const {
+                        return this->elem;
+                    }
+            };
+
+
+            constexpr Iterator begin() {
+                return {&this->elem};
+            }
+
+            constexpr Iterator end() {
+                return {nullptr};
+            }
+    };
+
+    template <typename T>
+    constexpr Repeater<T> repeat(T&& e) {
+        return {std::forward<T>(e)};
+    }
 }
 
 #endif

From 443effb559293a81c94367402d361edc0d59534a Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining@google.com>
Date: Tue, 18 Aug 2015 15:22:28 -0700
Subject: [PATCH 1217/1866] uses first_type instead of decltype(first)

---
 enumerate.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index 535b510f..e5df1ca9 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -47,8 +47,8 @@ namespace iter {
             class IterYield : public BasePair {
                 public:
                     using BasePair::BasePair;
-                    decltype(BasePair::first)& index = BasePair::first;
-                    decltype(BasePair::second)& element = BasePair::second;
+                    typename BasePair::first_type& index = BasePair::first;
+                    typename BasePair::second_type& element = BasePair::second;
             };
 
             //  Holds an iterator of the contained type and a size_t for the

From 1bc2f2a56ccafabce6b7218bb5f18a0f80e853b3 Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Wed, 19 Aug 2015 13:26:40 -0700
Subject: [PATCH 1218/1866] removes explicit zip<>::iterator constructors

---
 zip.hpp | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/zip.hpp b/zip.hpp
index 59171e48..d8cf5457 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -114,10 +114,6 @@ namespace iter {
                 public:
                     constexpr static const bool is_base_iter = true;
 
-                    Iterator() { }
-                    Iterator(const Iterator&) { }
-                    Iterator& operator=(const Iterator&) { return *this; }
-
                     Iterator& operator++() {
                         return *this;
                     }

From a6c2593e9e2b2359dfee414b28ff7408561419e4 Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Wed, 19 Aug 2015 21:54:34 -0700
Subject: [PATCH 1219/1866] adds clang-format config

---
 .clang-format | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 .clang-format

diff --git a/.clang-format b/.clang-format
new file mode 100644
index 00000000..b5f272f2
--- /dev/null
+++ b/.clang-format
@@ -0,0 +1,11 @@
+---
+Language:        Cpp
+BasedOnStyle:  Google
+AlignAfterOpenBracket: false
+AllowShortFunctionsOnASingleLine: Empty
+AllowShortLoopsOnASingleLine: false
+BreakBeforeBinaryOperators: NonAssignment
+DerivePointerAlignment: false
+NamespaceIndentation: All
+...
+

From 22a2e784586dcf3a99ea58816b99b452730a92da Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Wed, 19 Aug 2015 21:57:45 -0700
Subject: [PATCH 1220/1866] total reformat

Things were messy, I have clang-format, I'm using it.
---
 accumulate.hpp                    | 291 +++++++-------
 chain.hpp                         | 583 ++++++++++++++--------------
 combinations.hpp                  | 259 ++++++-------
 combinations_with_replacement.hpp | 229 ++++++-----
 compress.hpp                      | 290 +++++++-------
 count.hpp                         |  29 +-
 cycle.hpp                         | 164 ++++----
 dropwhile.hpp                     | 226 ++++++-----
 enumerate.hpp                     | 185 +++++----
 filter.hpp                        | 292 +++++++-------
 filterfalse.hpp                   | 165 ++++----
 groupby.hpp                       | 609 ++++++++++++++----------------
 grouper.hpp                       | 211 +++++------
 imap.hpp                          | 246 ++++++------
 iteratoriterator.hpp              | 513 ++++++++++++-------------
 iterbase.hpp                      | 474 +++++++++++------------
 itertools.hpp                     |   2 -
 permutations.hpp                  | 176 ++++-----
 powerset.hpp                      | 162 ++++----
 product.hpp                       | 293 +++++++-------
 range.hpp                         | 470 +++++++++++------------
 repeat.hpp                        | 262 +++++++------
 reversed.hpp                      | 259 ++++++-------
 slice.hpp                         | 267 +++++++------
 sliding_window.hpp                | 194 +++++-----
 sorted.hpp                        | 118 +++---
 takewhile.hpp                     | 232 ++++++------
 unique_everseen.hpp               |  75 ++--
 unique_justseen.hpp               |  53 ++-
 zip.hpp                           | 271 +++++++------
 zip_longest.hpp                   | 281 +++++++-------
 31 files changed, 3732 insertions(+), 4149 deletions(-)

diff --git a/accumulate.hpp b/accumulate.hpp
index bc006abf..672212f6 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -12,166 +12,147 @@
 
 namespace iter {
 
-    //Forward declarations of Accumulator and accumulate
-    template <typename Container, typename AccumulateFunc>
-    class Accumulator;
-
-    template <typename Container, typename AccumulateFunc>
-    Accumulator<Container, AccumulateFunc> accumulate(
-            Container&&, AccumulateFunc);
-
-    template <typename T, typename AccumulateFunc>
-    Accumulator<std::initializer_list<T>, AccumulateFunc> accumulate(
-            std::initializer_list<T>, AccumulateFunc);
-
-    template <typename Container, typename AccumulateFunc>
-    class Accumulator {
-        private:
-            Container container;
-            AccumulateFunc accumulate_func;
-
-            friend Accumulator accumulate<Container, AccumulateFunc>(
-                    Container&&, AccumulateFunc);
-
-            template <typename T, typename AF>
-            friend Accumulator<std::initializer_list<T>, AF> accumulate(
-                    std::initializer_list<T>, AF);
-
-            // AccumVal must be default constructible
-            using AccumVal =
-                typename std::remove_reference<
-                    typename std::result_of<AccumulateFunc(
-                            iterator_deref<Container>,
-                            iterator_deref<Container>)>::type>::type;
-
-            Accumulator(Container&& in_container,
-                    AccumulateFunc in_accumulate_func)
-                : container(std::forward<Container>(in_container)),
-                accumulate_func(in_accumulate_func)
-            { }
-        public:
-
-            class Iterator 
-                : public std::iterator<std::input_iterator_tag, AccumVal>
-            {
-                private:
-                    iterator_type<Container> sub_iter;
-                    iterator_type<Container> sub_end;
-                    AccumulateFunc *accumulate_func;
-                    std::unique_ptr<AccumVal> acc_val;
-                public:
-                    Iterator(iterator_type<Container>&& iter,
-                            iterator_type<Container>&& end,
-                            AccumulateFunc in_accumulate_func)
-                        : sub_iter{std::move(iter)},
-                        sub_end{std::move(end)},
-                        accumulate_func(&in_accumulate_func),
-                        // only get first value if not an end iterator
-                        acc_val{!(iter != end) ? nullptr : new AccumVal(*iter)}
-                    { } 
-
-                    Iterator(const Iterator& other)
-                        : sub_iter{other.sub_iter},
-                        sub_end{other.sub_end},
-                        accumulate_func{other.accumulate_func},
-                        acc_val{other.acc_val ?
-                                new AccumVal(*other.acc_val) : nullptr}
-                    { }
-
-                    Iterator& operator=(const Iterator& other) {
-                        if (this == &other) return *this;
-                        this->sub_iter = other.sub_iter;
-                        this->sub_end = other.sub_end;
-                        this->accumulate_func = other.accumulate_func;
-                        this->acc_val.reset(other.acc_val ?
-                                new AccumVal(*other.acc_val) : nullptr);
-                        return *this;
-                    }
-
-                    Iterator(Iterator&&) =default;
-                    Iterator& operator=(Iterator&&) =default;
-
-                    const AccumVal& operator*() const {
-                        return *this->acc_val;
-                    }
-
-                    const AccumVal* operator->() const {
-                        return this->acc_val.get();
-                    }
-
-                    Iterator& operator++() { 
-                        ++this->sub_iter;
-                        if (this->sub_iter != this->sub_end) {
-                            *this->acc_val = (*accumulate_func)(
-                                    *this->acc_val, *this->sub_iter);
-                        }
-                        return *this;
-                    }
-
-                    Iterator operator++(int) {
-                        auto ret = *this;
-                        ++*this;
-                        return ret;
-                    }
-
-                    bool operator!=(const Iterator& other) const {
-                        return this->sub_iter != other.sub_iter;
-                    }
-
-                    bool operator==(const Iterator& other) const {
-                        return !(*this != other);
-                    }
-            };
-
-            Iterator begin() {
-                return {std::begin(this->container),
-                        std::end(this->container),
-                        this->accumulate_func};
-            }
-
-            Iterator end() {
-                return {std::end(this->container),
-                        std::end(this->container),
-                        this->accumulate_func};
-            }
-
+  // Forward declarations of Accumulator and accumulate
+  template <typename Container, typename AccumulateFunc>
+  class Accumulator;
+
+  template <typename Container, typename AccumulateFunc>
+  Accumulator<Container, AccumulateFunc> accumulate(
+      Container&&, AccumulateFunc);
+
+  template <typename T, typename AccumulateFunc>
+  Accumulator<std::initializer_list<T>, AccumulateFunc> accumulate(
+      std::initializer_list<T>, AccumulateFunc);
+
+  template <typename Container, typename AccumulateFunc>
+  class Accumulator {
+   private:
+    Container container;
+    AccumulateFunc accumulate_func;
+
+    friend Accumulator accumulate<Container, AccumulateFunc>(
+        Container&&, AccumulateFunc);
+
+    template <typename T, typename AF>
+    friend Accumulator<std::initializer_list<T>, AF> accumulate(
+        std::initializer_list<T>, AF);
+
+    // AccumVal must be default constructible
+    using AccumVal =
+        typename std::remove_reference<typename std::result_of<AccumulateFunc(
+            iterator_deref<Container>, iterator_deref<Container>)>::type>::type;
+
+    Accumulator(Container&& in_container, AccumulateFunc in_accumulate_func)
+        : container(std::forward<Container>(in_container)),
+          accumulate_func(in_accumulate_func) {}
+
+   public:
+    class Iterator : public std::iterator<std::input_iterator_tag, AccumVal> {
+     private:
+      iterator_type<Container> sub_iter;
+      iterator_type<Container> sub_end;
+      AccumulateFunc* accumulate_func;
+      std::unique_ptr<AccumVal> acc_val;
+
+     public:
+      Iterator(iterator_type<Container>&& iter, iterator_type<Container>&& end,
+          AccumulateFunc in_accumulate_func)
+          : sub_iter{std::move(iter)},
+            sub_end{std::move(end)},
+            accumulate_func(&in_accumulate_func),
+            // only get first value if not an end iterator
+            acc_val{!(iter != end) ? nullptr : new AccumVal(*iter)} {}
+
+      Iterator(const Iterator& other)
+          : sub_iter{other.sub_iter},
+            sub_end{other.sub_end},
+            accumulate_func{other.accumulate_func},
+            acc_val{other.acc_val ? new AccumVal(*other.acc_val) : nullptr} {}
+
+      Iterator& operator=(const Iterator& other) {
+        if (this == &other) return *this;
+        this->sub_iter = other.sub_iter;
+        this->sub_end = other.sub_end;
+        this->accumulate_func = other.accumulate_func;
+        this->acc_val.reset(
+            other.acc_val ? new AccumVal(*other.acc_val) : nullptr);
+        return *this;
+      }
+
+      Iterator(Iterator&&) = default;
+      Iterator& operator=(Iterator&&) = default;
+
+      const AccumVal& operator*() const {
+        return *this->acc_val;
+      }
+
+      const AccumVal* operator->() const {
+        return this->acc_val.get();
+      }
+
+      Iterator& operator++() {
+        ++this->sub_iter;
+        if (this->sub_iter != this->sub_end) {
+          *this->acc_val = (*accumulate_func)(*this->acc_val, *this->sub_iter);
+        }
+        return *this;
+      }
+
+      Iterator operator++(int) {
+        auto ret = *this;
+        ++*this;
+        return ret;
+      }
+
+      bool operator!=(const Iterator& other) const {
+        return this->sub_iter != other.sub_iter;
+      }
+
+      bool operator==(const Iterator& other) const {
+        return !(*this != other);
+      }
     };
 
-    // Helper function to instantiate an Accumulator
-    template <typename Container, typename AccumulateFunc>
-    Accumulator<Container, AccumulateFunc> accumulate(
-            Container&& container,
-            AccumulateFunc accumulate_func)
-    {
-        return {std::forward<Container>(container), accumulate_func};
-    }
-
-    template <typename Container>
-    auto accumulate(Container&& container) -> 
-        decltype(accumulate(std::forward<Container>(container),
-                    std::plus<typename std::remove_reference<
-                        iterator_deref<Container>>::type>{}))
-    {
-        return accumulate(std::forward<Container>(container),
-                    std::plus<typename std::remove_reference<
-                        iterator_deref<Container>>::type>{});
+    Iterator begin() {
+      return {std::begin(this->container), std::end(this->container),
+          this->accumulate_func};
     }
 
-    template <typename T, typename AccumulateFunc>
-    Accumulator<std::initializer_list<T>, AccumulateFunc> accumulate(
-            std::initializer_list<T> il,
-            AccumulateFunc accumulate_func)
-    {
-        return {std::move(il), accumulate_func};
+    Iterator end() {
+      return {std::end(this->container), std::end(this->container),
+          this->accumulate_func};
     }
-
-    template <typename T>
-    auto accumulate(std::initializer_list<T> il) ->
-        decltype(accumulate(std::move(il), std::plus<T>{}))
-    {
-        return accumulate(std::move(il), std::plus<T>{});
-    }
-
+  };
+
+  // Helper function to instantiate an Accumulator
+  template <typename Container, typename AccumulateFunc>
+  Accumulator<Container, AccumulateFunc> accumulate(
+      Container&& container, AccumulateFunc accumulate_func) {
+    return {std::forward<Container>(container), accumulate_func};
+  }
+
+  template <typename Container>
+  auto accumulate(Container&& container) -> decltype(accumulate(
+      std::forward<Container>(container),
+      std::plus<
+          typename std::remove_reference<iterator_deref<Container>>::type>{})) {
+    return accumulate(
+        std::forward<Container>(container),
+        std::plus<
+            typename std::remove_reference<iterator_deref<Container>>::type>{});
+  }
+
+  template <typename T, typename AccumulateFunc>
+  Accumulator<std::initializer_list<T>, AccumulateFunc> accumulate(
+      std::initializer_list<T> il, AccumulateFunc accumulate_func) {
+    return {std::move(il), accumulate_func};
+  }
+
+  template <typename T>
+  auto accumulate(std::initializer_list<T> il)
+      -> decltype(accumulate(std::move(il), std::plus<T>{})) {
+    return accumulate(std::move(il), std::plus<T>{});
+  }
 }
 
 #endif
diff --git a/chain.hpp b/chain.hpp
index 1db17ad0..c2a7db9a 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -10,324 +10,293 @@
 #include <type_traits>
 
 namespace iter {
-    // rather than a chain function, use a callable object to support
-    // from_iterable
-    class ChainMaker;
-
-    template <typename Container, typename... RestContainers>
-    class Chained {
-        static_assert(
-                are_same<iterator_deref<Container>,
-                    iterator_deref<RestContainers>...>::value,
-                "All chained iterables must have iterators that "
-                "dereference to the same type, including cv-qualifiers "
-                "and references.");
-
-        friend class ChainMaker;
-        template <typename C, typename... RC>
-        friend class Chained;
-        
-        private:
-            Container container;
-            Chained<RestContainers...> rest_chained;
-            Chained(Container&& in_container, RestContainers&&... rest)
-                : container(std::forward<Container>(in_container)),
-                rest_chained{std::forward<RestContainers>(rest)...}
-            { }
-
-        public:
-            class Iterator
-                : public std::iterator<
-                      std::input_iterator_tag,
-                      iterator_traits_deref<Container>>
-            {
-                private:
-                    using RestIter =
-                        typename Chained<RestContainers...>::Iterator;
-                    iterator_type<Container> sub_iter;
-                    iterator_type<Container> sub_end;
-                    RestIter rest_iter;
-                    bool at_end;
-
-                public:
-                    Iterator(iterator_type<Container>&& s_begin,
-                            iterator_type<Container>&& s_end,
-                            RestIter&& in_rest_iter)
-                        : sub_iter{std::move(s_begin)},
-                        sub_end{std::move(s_end)},
-                        rest_iter{std::move(in_rest_iter)},
-                        at_end{!(sub_iter != sub_end)}
-                    { }
-                    
-                    Iterator& operator++() {
-                        if (this->at_end) {
-                            ++this->rest_iter;
-                        } else {
-                            ++this->sub_iter;
-                            if (!(this->sub_iter != this->sub_end)) {
-                                this->at_end = true;
-                            }
-                        }
-                        return *this;
-                    }
-
-                    Iterator operator++(int) {
-                        auto ret = *this;
-                        ++*this;
-                        return ret;
-                    }
-
-                    bool operator!=(const Iterator& other) const {
-                        return this->sub_iter != other.sub_iter ||
-                            this->rest_iter != other.rest_iter;
-                    }
-
-                    bool operator==(const Iterator& other) const {
-                        return !(*this != other);
-                    }
-
-                    iterator_deref<Container> operator*() {
-                        return this->at_end ?
-                            *this->rest_iter : *this->sub_iter;
-                    }
-
-                    iterator_arrow<Container> operator->() {
-                        return this->at_end ?
-                            apply_arrow(this->rest_iter)
+  // rather than a chain function, use a callable object to support
+  // from_iterable
+  class ChainMaker;
+
+  template <typename Container, typename... RestContainers>
+  class Chained {
+    static_assert(are_same<iterator_deref<Container>,
+                      iterator_deref<RestContainers>...>::value,
+        "All chained iterables must have iterators that "
+        "dereference to the same type, including cv-qualifiers "
+        "and references.");
+
+    friend class ChainMaker;
+    template <typename C, typename... RC>
+    friend class Chained;
+
+   private:
+    Container container;
+    Chained<RestContainers...> rest_chained;
+    Chained(Container&& in_container, RestContainers&&... rest)
+        : container(std::forward<Container>(in_container)),
+          rest_chained{std::forward<RestContainers>(rest)...} {}
+
+   public:
+    class Iterator : public std::iterator<std::input_iterator_tag,
+                         iterator_traits_deref<Container>> {
+     private:
+      using RestIter = typename Chained<RestContainers...>::Iterator;
+      iterator_type<Container> sub_iter;
+      iterator_type<Container> sub_end;
+      RestIter rest_iter;
+      bool at_end;
+
+     public:
+      Iterator(iterator_type<Container>&& s_begin,
+          iterator_type<Container>&& s_end, RestIter&& in_rest_iter)
+          : sub_iter{std::move(s_begin)},
+            sub_end{std::move(s_end)},
+            rest_iter{std::move(in_rest_iter)},
+            at_end{!(sub_iter != sub_end)} {}
+
+      Iterator& operator++() {
+        if (this->at_end) {
+          ++this->rest_iter;
+        } else {
+          ++this->sub_iter;
+          if (!(this->sub_iter != this->sub_end)) {
+            this->at_end = true;
+          }
+        }
+        return *this;
+      }
+
+      Iterator operator++(int) {
+        auto ret = *this;
+        ++*this;
+        return ret;
+      }
+
+      bool operator!=(const Iterator& other) const {
+        return this->sub_iter != other.sub_iter
+               || this->rest_iter != other.rest_iter;
+      }
+
+      bool operator==(const Iterator& other) const {
+        return !(*this != other);
+      }
+
+      iterator_deref<Container> operator*() {
+        return this->at_end ? *this->rest_iter : *this->sub_iter;
+      }
+
+      iterator_arrow<Container> operator->() {
+        return this->at_end ? apply_arrow(this->rest_iter)
                             : apply_arrow(this->sub_iter);
-                    }
-
-            };
+      }
+    };
 
-            Iterator begin() {
-                return {std::begin(this->container),
-                    std::end(this->container),
-                    std::begin(this->rest_chained)};
-            }
+    Iterator begin() {
+      return {std::begin(this->container), std::end(this->container),
+          std::begin(this->rest_chained)};
+    }
 
-            Iterator end() {
-                return {std::end(this->container),
-                    std::end(this->container),
-                    std::end(this->rest_chained)};
-            }
-    };
-    template <typename Container>
-    class Chained<Container> {
-        friend class ChainMaker;
-        template <typename C, typename... RC>
-        friend class Chained;
-
-        private:
-            Container container;
-            Chained(Container&& in_container)
-                : container(std::forward<Container>(in_container))
-            { }
-
-        public:
-            class Iterator
-                : public std::iterator<
-                      std::input_iterator_tag,
-                      iterator_traits_deref<Container>>
-            {
-                private:
-                    iterator_type<Container> sub_iter;
-                    iterator_type<Container> sub_end;
-
-                public:
-                    Iterator(const iterator_type<Container>& s_begin,
-                            const iterator_type<Container>& s_end)
-                        : sub_iter{s_begin},
-                        sub_end{s_end}
-                    { }
-                    
-                    Iterator& operator++() {
-                        ++this->sub_iter;
-                        return *this;
-                    }
-
-                    Iterator operator++(int) {
-                        auto ret = *this;
-                        ++*this;
-                        return ret;
-                    }
-
-                    bool operator!=(const Iterator& other) const {
-                        return this->sub_iter != other.sub_iter;
-                    }
-
-                    bool operator==(const Iterator& other) const {
-                        return !(*this != other);
-                    }
-
-                    iterator_deref<Container> operator*() {
-                        return *this->sub_iter;
-                    }
-
-                    iterator_arrow<Container> operator->() {
-                        return apply_arrow(this->sub_iter);
-                    }
-            };
-
-            Iterator begin() {
-                return {std::begin(this->container),
-                    std::end(this->container)};
-            }
-
-            Iterator end() {
-                return {std::end(this->container),
-                    std::end(this->container)};
-            }
+    Iterator end() {
+      return {std::end(this->container), std::end(this->container),
+          std::end(this->rest_chained)};
+    }
+  };
+  template <typename Container>
+  class Chained<Container> {
+    friend class ChainMaker;
+    template <typename C, typename... RC>
+    friend class Chained;
+
+   private:
+    Container container;
+    Chained(Container&& in_container)
+        : container(std::forward<Container>(in_container)) {}
+
+   public:
+    class Iterator : public std::iterator<std::input_iterator_tag,
+                         iterator_traits_deref<Container>> {
+     private:
+      iterator_type<Container> sub_iter;
+      iterator_type<Container> sub_end;
+
+     public:
+      Iterator(const iterator_type<Container>& s_begin,
+          const iterator_type<Container>& s_end)
+          : sub_iter{s_begin}, sub_end{s_end} {}
+
+      Iterator& operator++() {
+        ++this->sub_iter;
+        return *this;
+      }
+
+      Iterator operator++(int) {
+        auto ret = *this;
+        ++*this;
+        return ret;
+      }
+
+      bool operator!=(const Iterator& other) const {
+        return this->sub_iter != other.sub_iter;
+      }
+
+      bool operator==(const Iterator& other) const {
+        return !(*this != other);
+      }
+
+      iterator_deref<Container> operator*() {
+        return *this->sub_iter;
+      }
+
+      iterator_arrow<Container> operator->() {
+        return apply_arrow(this->sub_iter);
+      }
     };
 
-    template <typename Container>
-    class ChainedFromIterable {
-        private:
-            Container container;
-            friend class ChainMaker;
-            ChainedFromIterable(Container&& in_container)
-                : container(std::forward<Container>(in_container))
-            { }
-
-        public:
-            class Iterator
-                :public std::iterator<std::input_iterator_tag,
-                    iterator_traits_deref<iterator_deref<Container>>>
-            {
-                private:
-                    using SubContainer = iterator_deref<Container>;
-                    using SubIter = iterator_type<SubContainer>;
-
-                   iterator_type<Container> top_level_iter;
-                   iterator_type<Container> top_level_end;
-                   std::unique_ptr<SubIter> sub_iter_p;
-                   std::unique_ptr<SubIter> sub_end_p;
-
-                   static std::unique_ptr<SubIter> clone_sub_pointer(
-                           const SubIter* sub_iter) {
-                       return std::unique_ptr<SubIter>{ sub_iter ?
-                           new SubIter{*sub_iter} : nullptr};
-                   }
-
-                   bool sub_iters_differ(const Iterator& other) const {
-                       if (this->sub_iter_p == other.sub_iter_p) {
-                           return false;
-                       }
-                       if (this->sub_iter_p == nullptr
-                               || other.sub_iter_p == nullptr) {
-                           // since the first check tests if they're the same,
-                           // this will return if only one is nullptr
-                           return true;
-                       }
-                       return *this->sub_iter_p != *other.sub_iter_p;
-                   }
-
-                public:
-                   Iterator(iterator_type<Container>&& top_iter,
-                           iterator_type<Container>&& top_end)
-                       : top_level_iter{std::move(top_iter)},
-                       top_level_end{std::move(top_end)},
-                       sub_iter_p{!(top_iter != top_end) ?  // iter == end ?
-                           nullptr : new SubIter{std::begin(*top_iter)}},
-                       sub_end_p{!(top_iter != top_end) ?  // iter == end ?
-                           nullptr : new SubIter{std::end(*top_iter)}}
-                   { }
-
-                   Iterator(const Iterator& other)
-                       : top_level_iter{other.top_level_iter},
-                       top_level_end{other.top_level_end},
-                       sub_iter_p{clone_sub_pointer(other.sub_iter_p.get())},
-                       sub_end_p{clone_sub_pointer(other.sub_end_p.get())}
-                   { }
-
-                   Iterator& operator=(const Iterator& other) {
-                       if (this == &other) return *this;
-
-                       this->top_level_iter = other.top_level_iter;
-                       this->top_level_end = other.top_level_end;
-                       this->sub_iter_p =
-                               clone_sub_pointer(other.sub_iter_p.get());
-                       this->sub_end_p =
-                               clone_sub_pointer(other.sub_end_p.get());
-
-                       return *this;
-                   }
-
-                   Iterator(Iterator&&) = default;
-                   Iterator& operator=(Iterator&&) = default;
-                   ~Iterator() = default;
-
-                   Iterator& operator++() {
-                       ++*this->sub_iter_p;
-                       if (!(*this->sub_iter_p != *this->sub_end_p)) {
-                           ++this->top_level_iter;
-                           if (this->top_level_iter != this->top_level_end) {
-                               sub_iter_p.reset(
-                                       new SubIter{std::begin(*this->top_level_iter)});
-                               sub_end_p.reset(
-                                       new SubIter{std::end(*this->top_level_iter)});
-                           } else {
-                               sub_iter_p.reset(nullptr);
-                               sub_end_p.reset(nullptr);
-                           }
-                       }
-                       return *this;
-                   }
-
-
-                   Iterator operator++(int) {
-                       auto ret = *this;
-                       ++*this;
-                       return ret;
-                   }
-
-                   bool operator!=(const Iterator& other) const {
-                       return this->top_level_iter != other.top_level_iter
-                            || this->sub_iters_differ(other);
-                   }
-
-                   bool operator==(const Iterator& other) const {
-                       return !(*this != other);
-                   }
-
-                   iterator_deref<iterator_deref<Container>> operator*() {
-                       return **this->sub_iter_p;
-                   }
-
-                   iterator_arrow<iterator_deref<Container>> operator->() {
-                       return apply_arrow(*this->sub_iter_p);
-                   }
-           };
-
-           Iterator begin() {
-               return {std::begin(this->container), std::end(this->container)};
-           }
-
-           Iterator end() {
-               return {std::end(this->container), std::end(this->container)};
-           }
+    Iterator begin() {
+      return {std::begin(this->container), std::end(this->container)};
+    }
+
+    Iterator end() {
+      return {std::end(this->container), std::end(this->container)};
+    }
+  };
+
+  template <typename Container>
+  class ChainedFromIterable {
+   private:
+    Container container;
+    friend class ChainMaker;
+    ChainedFromIterable(Container&& in_container)
+        : container(std::forward<Container>(in_container)) {}
+
+   public:
+    class Iterator : public std::iterator<std::input_iterator_tag,
+                         iterator_traits_deref<iterator_deref<Container>>> {
+     private:
+      using SubContainer = iterator_deref<Container>;
+      using SubIter = iterator_type<SubContainer>;
+
+      iterator_type<Container> top_level_iter;
+      iterator_type<Container> top_level_end;
+      std::unique_ptr<SubIter> sub_iter_p;
+      std::unique_ptr<SubIter> sub_end_p;
+
+      static std::unique_ptr<SubIter> clone_sub_pointer(
+          const SubIter* sub_iter) {
+        return std::unique_ptr<SubIter>{
+            sub_iter ? new SubIter{*sub_iter} : nullptr};
+      }
+
+      bool sub_iters_differ(const Iterator& other) const {
+        if (this->sub_iter_p == other.sub_iter_p) {
+          return false;
+        }
+        if (this->sub_iter_p == nullptr || other.sub_iter_p == nullptr) {
+          // since the first check tests if they're the same,
+          // this will return if only one is nullptr
+          return true;
+        }
+        return *this->sub_iter_p != *other.sub_iter_p;
+      }
+
+     public:
+      Iterator(iterator_type<Container>&& top_iter,
+          iterator_type<Container>&& top_end)
+          : top_level_iter{std::move(top_iter)},
+            top_level_end{std::move(top_end)},
+            sub_iter_p{!(top_iter != top_end)
+                           ?  // iter == end ?
+                           nullptr
+                           : new SubIter{std::begin(*top_iter)}},
+            sub_end_p{!(top_iter != top_end)
+                          ?  // iter == end ?
+                          nullptr
+                          : new SubIter{std::end(*top_iter)}} {}
+
+      Iterator(const Iterator& other)
+          : top_level_iter{other.top_level_iter},
+            top_level_end{other.top_level_end},
+            sub_iter_p{clone_sub_pointer(other.sub_iter_p.get())},
+            sub_end_p{clone_sub_pointer(other.sub_end_p.get())} {}
+
+      Iterator& operator=(const Iterator& other) {
+        if (this == &other) return *this;
+
+        this->top_level_iter = other.top_level_iter;
+        this->top_level_end = other.top_level_end;
+        this->sub_iter_p = clone_sub_pointer(other.sub_iter_p.get());
+        this->sub_end_p = clone_sub_pointer(other.sub_end_p.get());
+
+        return *this;
+      }
+
+      Iterator(Iterator&&) = default;
+      Iterator& operator=(Iterator&&) = default;
+      ~Iterator() = default;
+
+      Iterator& operator++() {
+        ++*this->sub_iter_p;
+        if (!(*this->sub_iter_p != *this->sub_end_p)) {
+          ++this->top_level_iter;
+          if (this->top_level_iter != this->top_level_end) {
+            sub_iter_p.reset(new SubIter{std::begin(*this->top_level_iter)});
+            sub_end_p.reset(new SubIter{std::end(*this->top_level_iter)});
+          } else {
+            sub_iter_p.reset(nullptr);
+            sub_end_p.reset(nullptr);
+          }
+        }
+        return *this;
+      }
+
+      Iterator operator++(int) {
+        auto ret = *this;
+        ++*this;
+        return ret;
+      }
+
+      bool operator!=(const Iterator& other) const {
+        return this->top_level_iter != other.top_level_iter
+               || this->sub_iters_differ(other);
+      }
+
+      bool operator==(const Iterator& other) const {
+        return !(*this != other);
+      }
+
+      iterator_deref<iterator_deref<Container>> operator*() {
+        return **this->sub_iter_p;
+      }
+
+      iterator_arrow<iterator_deref<Container>> operator->() {
+        return apply_arrow(*this->sub_iter_p);
+      }
     };
 
+    Iterator begin() {
+      return {std::begin(this->container), std::end(this->container)};
+    }
 
-    class ChainMaker {
-        public:
-            // expose regular call operator to provide usual chain()
-            template <typename... Containers>
-            Chained<Containers...> operator()(Containers&&... cs) const {
-                return {std::forward<Containers>(cs)...};
-            }
-
-            // chain.from_iterable
-            template <typename Container>
-            ChainedFromIterable<Container> from_iterable(
-                    Container&& container) const {
-                return {std::forward<Container>(container)};
-            }
-    };
+    Iterator end() {
+      return {std::end(this->container), std::end(this->container)};
+    }
+  };
+
+  class ChainMaker {
+   public:
+    // expose regular call operator to provide usual chain()
+    template <typename... Containers>
+    Chained<Containers...> operator()(Containers&&... cs) const {
+      return {std::forward<Containers>(cs)...};
+    }
 
-    namespace {
-        constexpr auto chain = ChainMaker{};
+    // chain.from_iterable
+    template <typename Container>
+    ChainedFromIterable<Container> from_iterable(Container&& container) const {
+      return {std::forward<Container>(container)};
     }
+  };
 
+  namespace {
+    constexpr auto chain = ChainMaker{};
+  }
 }
 
 #endif
diff --git a/combinations.hpp b/combinations.hpp
index 2f52a7e5..74b93829 100644
--- a/combinations.hpp
+++ b/combinations.hpp
@@ -10,150 +10,139 @@
 #include <initializer_list>
 
 namespace iter {
-    template <typename Container>
-    class Combinator;
+  template <typename Container>
+  class Combinator;
 
-    template <typename Container>
-    Combinator<Container> combinations(Container&&, std::size_t);
+  template <typename Container>
+  Combinator<Container> combinations(Container&&, std::size_t);
 
+  template <typename T>
+  Combinator<std::initializer_list<T>> combinations(
+      std::initializer_list<T>, std::size_t);
+
+  template <typename Container>
+  class Combinator {
+   private:
+    Container container;
+    std::size_t length;
+
+    friend Combinator combinations<Container>(Container&&, std::size_t);
     template <typename T>
-    Combinator<std::initializer_list<T>> combinations(
-            std::initializer_list<T>, std::size_t);
-
-    template <typename Container>
-    class Combinator {
-        private:
-            Container container;
-            std::size_t length;
-
-            friend Combinator combinations<Container>(Container&&,std::size_t);
-            template <typename T>
-            friend Combinator<std::initializer_list<T>> combinations(
-                    std::initializer_list<T>, std::size_t);
-
-            Combinator(Container&& in_container, std::size_t in_length)
-                : container(std::forward<Container>(in_container)),
-                length{in_length}
-            { }
-
-            using IndexVector = std::vector<iterator_type<Container>>;
-            using CombIteratorDeref = IterIterWrapper<IndexVector>;
-
-        public:
-
-        class Iterator :
-            public std::iterator<std::input_iterator_tag, CombIteratorDeref>
-        {
-            private:
-                constexpr static const int COMPLETE = -1;
-                typename std::remove_reference<Container>::type *container_p;
-                CombIteratorDeref indices;
-                int steps{};
-
-            public:
-                Iterator(Container& in_container, std::size_t n)
-                    : container_p{&in_container},
-                    indices{n}
-                {
-                    if (n == 0) {
-                        this->steps = COMPLETE;
-                        return;
-                    }
-                    size_t inc = 0;
-                    for (auto& iter : this->indices.get()) {
-                        auto it = std::begin(*this->container_p);
-                        dumb_advance(it, std::end(*this->container_p), inc);
-                        if (it != std::end(*this->container_p)) {
-                            iter = it;
-                            ++inc;
-                        } else {
-                            this->steps = COMPLETE;
-                            break;
-                        }
-                    }
-                }
-
-                CombIteratorDeref& operator*() {
-                    return this->indices;
-                }
-
-                CombIteratorDeref *operator->() {
-                    return &this->indices;
-                }
-
-
-                Iterator& operator++() {
-                    for (auto iter = indices.get().rbegin();
-                            iter != indices.get().rend();
-                            ++iter) {
-                        ++(*iter);
-
-                        //what we have to check here is if the distance between
-                        //the index and the end of indices is >= the distance
-                        //between the item and end of item
-                        auto dist = std::distance(
-                                this->indices.get().rbegin(),iter);
-
-                        if (!(dumb_next(*iter, dist) !=
-                                std::end(*this->container_p))) {
-                            if ( (iter + 1) != indices.get().rend()) {
-                                size_t inc = 1;
-                                for (auto down = iter;
-                                        down != indices.get().rbegin()-1;
-                                        --down) {
-                                    (*down) = dumb_next(*(iter + 1), 1 + inc);
-                                    ++inc;
-                                }
-                            } else {
-                                this->steps = COMPLETE;
-                                break;
-                            }
-                        } else {
-                            break; 
-                        }
-                        //we break because none of the rest of the items need
-                        //to be incremented
-                    }
-                    if (this->steps != COMPLETE) {
-                        ++this->steps;
-                    }
-                    return *this;
-                }
-
-                Iterator operator++(int) {
-                    auto ret = *this;
-                    ++*this;
-                    return ret;
-                }
-
-                bool operator!=(const Iterator& other) const {
-                    return !(*this == other);
-                }
-
-                bool operator==(const Iterator& other) const {
-                    return this->steps == other.steps;
-                }
-        };
-
-        Iterator begin() {
-            return {this->container, this->length};
+    friend Combinator<std::initializer_list<T>> combinations(
+        std::initializer_list<T>, std::size_t);
+
+    Combinator(Container&& in_container, std::size_t in_length)
+        : container(std::forward<Container>(in_container)), length{in_length} {}
+
+    using IndexVector = std::vector<iterator_type<Container>>;
+    using CombIteratorDeref = IterIterWrapper<IndexVector>;
+
+   public:
+    class Iterator
+        : public std::iterator<std::input_iterator_tag, CombIteratorDeref> {
+     private:
+      constexpr static const int COMPLETE = -1;
+      typename std::remove_reference<Container>::type* container_p;
+      CombIteratorDeref indices;
+      int steps{};
+
+     public:
+      Iterator(Container& in_container, std::size_t n)
+          : container_p{&in_container}, indices{n} {
+        if (n == 0) {
+          this->steps = COMPLETE;
+          return;
+        }
+        size_t inc = 0;
+        for (auto& iter : this->indices.get()) {
+          auto it = std::begin(*this->container_p);
+          dumb_advance(it, std::end(*this->container_p), inc);
+          if (it != std::end(*this->container_p)) {
+            iter = it;
+            ++inc;
+          } else {
+            this->steps = COMPLETE;
+            break;
+          }
         }
-        
-        Iterator end() {
-            return {this->container, 0};
+      }
+
+      CombIteratorDeref& operator*() {
+        return this->indices;
+      }
+
+      CombIteratorDeref* operator->() {
+        return &this->indices;
+      }
+
+      Iterator& operator++() {
+        for (auto iter = indices.get().rbegin(); iter != indices.get().rend();
+             ++iter) {
+          ++(*iter);
+
+          // what we have to check here is if the distance between
+          // the index and the end of indices is >= the distance
+          // between the item and end of item
+          auto dist = std::distance(this->indices.get().rbegin(), iter);
+
+          if (!(dumb_next(*iter, dist) != std::end(*this->container_p))) {
+            if ((iter + 1) != indices.get().rend()) {
+              size_t inc = 1;
+              for (auto down = iter; down != indices.get().rbegin() - 1;
+                   --down) {
+                (*down) = dumb_next(*(iter + 1), 1 + inc);
+                ++inc;
+              }
+            } else {
+              this->steps = COMPLETE;
+              break;
+            }
+          } else {
+            break;
+          }
+          // we break because none of the rest of the items need
+          // to be incremented
         }
+        if (this->steps != COMPLETE) {
+          ++this->steps;
+        }
+        return *this;
+      }
+
+      Iterator operator++(int) {
+        auto ret = *this;
+        ++*this;
+        return ret;
+      }
+
+      bool operator!=(const Iterator& other) const {
+        return !(*this == other);
+      }
+
+      bool operator==(const Iterator& other) const {
+        return this->steps == other.steps;
+      }
     };
 
-    template <typename Container>
-    Combinator<Container> combinations(
-            Container&& container, std::size_t length) {
-        return {std::forward<Container>(container), length};
+    Iterator begin() {
+      return {this->container, this->length};
     }
 
-    template <typename T>
-    Combinator<std::initializer_list<T>> combinations(
-            std::initializer_list<T> il, std::size_t length) {
-        return {std::move(il), length};
+    Iterator end() {
+      return {this->container, 0};
     }
+  };
+
+  template <typename Container>
+  Combinator<Container> combinations(
+      Container&& container, std::size_t length) {
+    return {std::forward<Container>(container), length};
+  }
+
+  template <typename T>
+  Combinator<std::initializer_list<T>> combinations(
+      std::initializer_list<T> il, std::size_t length) {
+    return {std::move(il), length};
+  }
 }
 #endif
diff --git a/combinations_with_replacement.hpp b/combinations_with_replacement.hpp
index 0a1d11c6..d579d8ef 100644
--- a/combinations_with_replacement.hpp
+++ b/combinations_with_replacement.hpp
@@ -11,135 +11,122 @@
 
 namespace iter {
 
-    template <typename Container>
-    class CombinatorWithReplacement;
+  template <typename Container>
+  class CombinatorWithReplacement;
 
-    template <typename Container>
-    CombinatorWithReplacement<Container> combinations_with_replacement(
-            Container&&, std::size_t);
+  template <typename Container>
+  CombinatorWithReplacement<Container> combinations_with_replacement(
+      Container&&, std::size_t);
 
+  template <typename T>
+  CombinatorWithReplacement<std::initializer_list<T>>
+      combinations_with_replacement(std::initializer_list<T>, std::size_t);
+
+  template <typename Container>
+  class CombinatorWithReplacement {
+   private:
+    Container container;
+    std::size_t length;
+
+    friend CombinatorWithReplacement combinations_with_replacement<Container>(
+        Container&&, std::size_t);
     template <typename T>
-    CombinatorWithReplacement<std::initializer_list<T>>
-    combinations_with_replacement(
-            std::initializer_list<T>, std::size_t);
-
-    template <typename Container>
-    class CombinatorWithReplacement {
-        private:
-            Container container;
-            std::size_t length;
-
-            friend CombinatorWithReplacement
-                combinations_with_replacement<Container>(
-                        Container&& ,std::size_t);
-            template <typename T>
-            friend CombinatorWithReplacement<std::initializer_list<T>>
-            combinations_with_replacement(
-                    std::initializer_list<T>, std::size_t);
-
-           CombinatorWithReplacement(Container&& in_container, std::size_t n)
-               : container(std::forward<Container>(in_container)),
-               length{n}
-           { }
-
-            using IndexVector = std::vector<iterator_type<Container>>;
-            using CombIteratorDeref = IterIterWrapper<IndexVector>;
-
-        public:
-            class Iterator :
-                public std::iterator<std::input_iterator_tag,
-                    CombIteratorDeref>
-            {
-               private:
-                   constexpr static const int COMPLETE = -1;
-                   typename std::remove_reference<Container>::type *container_p;
-                   CombIteratorDeref indices;
-                   int steps;
-
-               public:
-                   Iterator(Container& in_container, std::size_t n)
-                       : container_p{&in_container},
-                       indices(n, std::begin(in_container)),
-                       steps{(std::begin(in_container)
-                               != std::end(in_container)
-                               && n)
-                           ? 0 : COMPLETE}
-                   { }
-
-                   CombIteratorDeref& operator*() {
-                       return this->indices;
-                   }
-
-                   CombIteratorDeref *operator->() {
-                       return &this->indices;
-                   }
-
-                   Iterator& operator++() {
-                       for (auto iter = indices.get().rbegin();
-                               iter != indices.get().rend();
-                               ++iter) {
-                           ++(*iter);
-                           if (!(*iter != std::end(*this->container_p))) {
-                               if ( (iter + 1) != indices.get().rend()) {
-                                   for (auto down = iter;
-                                           down != indices.get().rbegin()-1;
-                                           --down) {
-                                       (*down) = dumb_next(*(iter + 1)); 
-                                   }
-                               } else {
-                                   this->steps = COMPLETE;
-                                   break;
-                               }
-                           } else {
-                               //we break because none of the rest of the items
-                               //need to be incremented
-                               break; 
-                           }
-                       }
-                       if (this->steps != COMPLETE) {
-                           ++this->steps;
-                       }
-                       return *this;
-                   }
-
-
-                   Iterator operator++(int) {
-                       auto ret = *this;
-                       ++*this;
-                       return ret;
-                   }
-
-                   bool operator!=(const Iterator& other) const {
-                       return !(*this == other);
-                   }
-
-                   bool operator==(const Iterator& other) const {
-                       return this->steps == other.steps;
-                   }
-
-           };
-
-           Iterator begin() {
-               return {this->container, this->length};
-           }
-
-           Iterator end() {
-               return {this->container, 0};
-           }
+    friend CombinatorWithReplacement<std::initializer_list<T>>
+        combinations_with_replacement(std::initializer_list<T>, std::size_t);
+
+    CombinatorWithReplacement(Container&& in_container, std::size_t n)
+        : container(std::forward<Container>(in_container)), length{n} {}
+
+    using IndexVector = std::vector<iterator_type<Container>>;
+    using CombIteratorDeref = IterIterWrapper<IndexVector>;
+
+   public:
+    class Iterator
+        : public std::iterator<std::input_iterator_tag, CombIteratorDeref> {
+     private:
+      constexpr static const int COMPLETE = -1;
+      typename std::remove_reference<Container>::type* container_p;
+      CombIteratorDeref indices;
+      int steps;
+
+     public:
+      Iterator(Container& in_container, std::size_t n)
+          : container_p{&in_container},
+            indices(n, std::begin(in_container)),
+            steps{(std::begin(in_container) != std::end(in_container) && n)
+                      ? 0
+                      : COMPLETE} {}
+
+      CombIteratorDeref& operator*() {
+        return this->indices;
+      }
+
+      CombIteratorDeref* operator->() {
+        return &this->indices;
+      }
+
+      Iterator& operator++() {
+        for (auto iter = indices.get().rbegin(); iter != indices.get().rend();
+             ++iter) {
+          ++(*iter);
+          if (!(*iter != std::end(*this->container_p))) {
+            if ((iter + 1) != indices.get().rend()) {
+              for (auto down = iter; down != indices.get().rbegin() - 1;
+                   --down) {
+                (*down) = dumb_next(*(iter + 1));
+              }
+            } else {
+              this->steps = COMPLETE;
+              break;
+            }
+          } else {
+            // we break because none of the rest of the items
+            // need to be incremented
+            break;
+          }
+        }
+        if (this->steps != COMPLETE) {
+          ++this->steps;
+        }
+        return *this;
+      }
+
+      Iterator operator++(int) {
+        auto ret = *this;
+        ++*this;
+        return ret;
+      }
+
+      bool operator!=(const Iterator& other) const {
+        return !(*this == other);
+      }
+
+      bool operator==(const Iterator& other) const {
+        return this->steps == other.steps;
+      }
     };
 
-    template <typename Container>
-    CombinatorWithReplacement<Container> combinations_with_replacement(
-            Container&& container, std::size_t length) {
-        return {std::forward<Container>(container), length};
+    Iterator begin() {
+      return {this->container, this->length};
     }
 
-    template <typename T>
-    CombinatorWithReplacement<std::initializer_list<T>> 
-    combinations_with_replacement(
-            std::initializer_list<T> il, std::size_t length) {
-        return {std::move(il), length};
+    Iterator end() {
+      return {this->container, 0};
     }
+  };
+
+  template <typename Container>
+  CombinatorWithReplacement<Container> combinations_with_replacement(
+      Container&& container, std::size_t length) {
+    return {std::forward<Container>(container), length};
+  }
+
+  template <typename T>
+  CombinatorWithReplacement<std::initializer_list<T>>
+  combinations_with_replacement(
+      std::initializer_list<T> il, std::size_t length) {
+    return {std::move(il), length};
+  }
 }
 
 #endif
diff --git a/compress.hpp b/compress.hpp
index cc79b930..5089228d 100644
--- a/compress.hpp
+++ b/compress.hpp
@@ -9,169 +9,155 @@
 
 namespace iter {
 
-    //Forward declarations of Compressed and compress
-    template <typename Container, typename Selector>
-    class Compressed;
+  // Forward declarations of Compressed and compress
+  template <typename Container, typename Selector>
+  class Compressed;
 
-    template <typename Container, typename Selector>
-    Compressed<Container, Selector> compress(Container&&, Selector&&);
+  template <typename Container, typename Selector>
+  Compressed<Container, Selector> compress(Container&&, Selector&&);
 
-    template <typename T, typename Selector>
-    Compressed<std::initializer_list<T>, Selector> compress(
-            std::initializer_list<T>, Selector&&);
+  template <typename T, typename Selector>
+  Compressed<std::initializer_list<T>, Selector> compress(
+      std::initializer_list<T>, Selector&&);
 
-    template <typename Container, typename T>
-    Compressed<Container, std::initializer_list<T>> compress(
-            Container&&, std::initializer_list<T>);
+  template <typename Container, typename T>
+  Compressed<Container, std::initializer_list<T>> compress(
+      Container&&, std::initializer_list<T>);
 
-    template <typename T, typename U>
-    Compressed<std::initializer_list<T>, std::initializer_list<U>> compress(
-            std::initializer_list<T>, std::initializer_list<U>);
-
-    template <typename Container, typename Selector>
-    class Compressed  {
-        private:
-            Container container;
-            Selector selectors;
-
-            // The only thing allowed to directly instantiate an Compressed is
-            // the compress function
-            friend Compressed compress<Container, Selector>(
-                    Container&&, Selector&&);
-
-            template <typename T, typename Sel>
-            friend Compressed<std::initializer_list<T>, Sel> compress(
-                    std::initializer_list<T>, Sel&&);
-
-            template <typename Con, typename T>
-            friend Compressed<Con, std::initializer_list<T>> compress(
-                    Con&&, std::initializer_list<T>);
-
-            template <typename T, typename U>
-            friend Compressed<std::initializer_list<T>,
-                   std::initializer_list<U>> compress(
-                    std::initializer_list<T>, std::initializer_list<U>);
-
-            
-            // Selector::Iterator type
-            using selector_iter_type = decltype(std::begin(selectors));
-            
-            // Value constructor for use only in the compress function
-            Compressed(Container&& in_container, Selector&& in_selectors)
-                : container(std::forward<Container>(in_container)),
-                selectors(std::forward<Selector>(in_selectors))
-            { }
-
-        public:
-
-            class Iterator 
-                : public std::iterator<std::input_iterator_tag,
-                        iterator_traits_deref<Container>>
-            {
-                private:
-                    iterator_type<Container> sub_iter;
-                    iterator_type<Container> sub_end;
-
-                    selector_iter_type selector_iter;
-                    selector_iter_type selector_end;
-
-                    void increment_iterators() {
-                        ++this->sub_iter;
-                        ++this->selector_iter;
-                    }
-
-                    void skip_failures() {
-                        while (this->sub_iter != this->sub_end
-                               && this->selector_iter != this->selector_end
-                                && !*this->selector_iter) {
-                            this->increment_iterators();
-                        }
-                    }
-
-                public:
-                    Iterator(iterator_type<Container>&& cont_iter,
-                            iterator_type<Container>&& cont_end,
-                            selector_iter_type&& sel_iter,
-                            selector_iter_type&& sel_end)
-                        : sub_iter{std::move(cont_iter)},
-                        sub_end{std::move(cont_end)},
-                        selector_iter{std::move(sel_iter)},
-                        selector_end{std::move(sel_end)}
-                    { 
-                        this->skip_failures();
-                    } 
-
-                    iterator_deref<Container> operator*() {
-                        return *this->sub_iter;
-                    }
-
-                    iterator_arrow<Container> operator->() {
-                        return apply_arrow(this->sub_iter);
-                    }
-
-                    Iterator& operator++() { 
-                        this->increment_iterators();
-                        this->skip_failures();
-                        return *this;
-                    }
-
-                    Iterator operator++(int) {
-                        auto ret = *this;
-                        ++*this;
-                        return ret;
-                    }
-
-                    bool operator!=(const Iterator& other) const {
-                        return this->sub_iter != other.sub_iter
-                            && this->selector_iter != other.selector_iter;
-                    }
-
-                    bool operator==(const Iterator& other) const {
-                        return !(*this != other);
-                    }
-            };
-
-            Iterator begin() {
-                return {std::begin(this->container), std::end(this->container),
-                    std::begin(this->selectors), std::end(this->selectors)};
-            }
-
-            Iterator end() {
-                return {std::end(this->container), std::end(this->container),
-                        std::end(this->selectors), std::end(this->selectors)};
-            }
+  template <typename T, typename U>
+  Compressed<std::initializer_list<T>, std::initializer_list<U>> compress(
+      std::initializer_list<T>, std::initializer_list<U>);
 
-    };
+  template <typename Container, typename Selector>
+  class Compressed {
+   private:
+    Container container;
+    Selector selectors;
 
-    // Helper function to instantiate an Compressed
-    template <typename Container, typename Selector>
-    Compressed<Container, Selector> compress(
-            Container&& container, Selector&& selectors) {
-        return {std::forward<Container>(container),
-                std::forward<Selector>(selectors)};
-    }
+    // The only thing allowed to directly instantiate an Compressed is
+    // the compress function
+    friend Compressed compress<Container, Selector>(Container&&, Selector&&);
 
-    template <typename T, typename Selector>
-    Compressed<std::initializer_list<T>, Selector> compress(
-            std::initializer_list<T> data, Selector&& selectors) {
-        return {std::move(data),
-                std::forward<Selector>(selectors)};
-    }
+    template <typename T, typename Sel>
+    friend Compressed<std::initializer_list<T>, Sel> compress(
+        std::initializer_list<T>, Sel&&);
 
-    template <typename Container, typename T>
-    Compressed<Container, std::initializer_list<T>> compress(
-            Container&& container, std::initializer_list<T> selectors) {
-        return {std::forward<Container>(container),
-                std::move(selectors)};
-    }
+    template <typename Con, typename T>
+    friend Compressed<Con, std::initializer_list<T>> compress(
+        Con&&, std::initializer_list<T>);
 
     template <typename T, typename U>
-    Compressed<std::initializer_list<T>, std::initializer_list<U>> compress(
-            std::initializer_list<T> data,
-            std::initializer_list<U> selectors) {
-        return {std::move(data),
-                std::move(selectors)};
+    friend Compressed<std::initializer_list<T>, std::initializer_list<U>>
+        compress(std::initializer_list<T>, std::initializer_list<U>);
+
+    // Selector::Iterator type
+    using selector_iter_type = decltype(std::begin(selectors));
+
+    // Value constructor for use only in the compress function
+    Compressed(Container&& in_container, Selector&& in_selectors)
+        : container(std::forward<Container>(in_container)),
+          selectors(std::forward<Selector>(in_selectors)) {}
+
+   public:
+    class Iterator : public std::iterator<std::input_iterator_tag,
+                         iterator_traits_deref<Container>> {
+     private:
+      iterator_type<Container> sub_iter;
+      iterator_type<Container> sub_end;
+
+      selector_iter_type selector_iter;
+      selector_iter_type selector_end;
+
+      void increment_iterators() {
+        ++this->sub_iter;
+        ++this->selector_iter;
+      }
+
+      void skip_failures() {
+        while (this->sub_iter != this->sub_end
+               && this->selector_iter != this->selector_end
+               && !*this->selector_iter) {
+          this->increment_iterators();
+        }
+      }
+
+     public:
+      Iterator(iterator_type<Container>&& cont_iter,
+          iterator_type<Container>&& cont_end, selector_iter_type&& sel_iter,
+          selector_iter_type&& sel_end)
+          : sub_iter{std::move(cont_iter)},
+            sub_end{std::move(cont_end)},
+            selector_iter{std::move(sel_iter)},
+            selector_end{std::move(sel_end)} {
+        this->skip_failures();
+      }
+
+      iterator_deref<Container> operator*() {
+        return *this->sub_iter;
+      }
+
+      iterator_arrow<Container> operator->() {
+        return apply_arrow(this->sub_iter);
+      }
+
+      Iterator& operator++() {
+        this->increment_iterators();
+        this->skip_failures();
+        return *this;
+      }
+
+      Iterator operator++(int) {
+        auto ret = *this;
+        ++*this;
+        return ret;
+      }
+
+      bool operator!=(const Iterator& other) const {
+        return this->sub_iter != other.sub_iter
+               && this->selector_iter != other.selector_iter;
+      }
+
+      bool operator==(const Iterator& other) const {
+        return !(*this != other);
+      }
+    };
+
+    Iterator begin() {
+      return {std::begin(this->container), std::end(this->container),
+          std::begin(this->selectors), std::end(this->selectors)};
+    }
+
+    Iterator end() {
+      return {std::end(this->container), std::end(this->container),
+          std::end(this->selectors), std::end(this->selectors)};
     }
+  };
+
+  // Helper function to instantiate an Compressed
+  template <typename Container, typename Selector>
+  Compressed<Container, Selector> compress(
+      Container&& container, Selector&& selectors) {
+    return {
+        std::forward<Container>(container), std::forward<Selector>(selectors)};
+  }
+
+  template <typename T, typename Selector>
+  Compressed<std::initializer_list<T>, Selector> compress(
+      std::initializer_list<T> data, Selector&& selectors) {
+    return {std::move(data), std::forward<Selector>(selectors)};
+  }
+
+  template <typename Container, typename T>
+  Compressed<Container, std::initializer_list<T>> compress(
+      Container&& container, std::initializer_list<T> selectors) {
+    return {std::forward<Container>(container), std::move(selectors)};
+  }
+
+  template <typename T, typename U>
+  Compressed<std::initializer_list<T>, std::initializer_list<U>> compress(
+      std::initializer_list<T> data, std::initializer_list<U> selectors) {
+    return {std::move(data), std::move(selectors)};
+  }
 }
 
 #endif
diff --git a/count.hpp b/count.hpp
index eec82f4e..0a67d971 100644
--- a/count.hpp
+++ b/count.hpp
@@ -7,23 +7,20 @@
 
 namespace iter {
 
-    template <typename T>
-    constexpr auto count(T start, T step) noexcept
-            -> decltype(range(start, start, start)) {
-        // if step is < 0, stop is numeric min, otherwise numeric max
-        return range(
-                start,
-                step < T(0) ? std::numeric_limits<T>::min() :
-                    std::numeric_limits<T>::max(),
-                step);
-    }
+  template <typename T>
+  constexpr auto count(T start, T step) noexcept
+      -> decltype(range(start, start, start)) {
+    // if step is < 0, stop is numeric min, otherwise numeric max
+    return range(start, step < T(0) ? std::numeric_limits<T>::min()
+                                    : std::numeric_limits<T>::max(),
+        step);
+  }
 
-    template <typename T =long>
-    constexpr auto count(T start =T(0)) noexcept
-            -> decltype(range(start, start)) {
-        return count(start, T(1));
-    }
+  template <typename T = long>
+  constexpr auto count(T start = T(0)) noexcept
+      -> decltype(range(start, start)) {
+    return count(start, T(1));
+  }
 }
 
-
 #endif
diff --git a/cycle.hpp b/cycle.hpp
index 42b86117..84e0c314 100644
--- a/cycle.hpp
+++ b/cycle.hpp
@@ -9,101 +9,91 @@
 
 namespace iter {
 
-    template <typename Container>
-    class Cycle;
+  template <typename Container>
+  class Cycle;
 
-    template <typename Container>
-    Cycle<Container> cycle(Container&&);
+  template <typename Container>
+  Cycle<Container> cycle(Container&&);
 
-    template <typename T>
-    Cycle<std::initializer_list<T>> cycle(std::initializer_list<T>);
-
-    template <typename Container>
-    class Cycle {
-        private:
-            friend Cycle cycle<Container>(Container&&);
-            template <typename T>
-            friend Cycle<std::initializer_list<T>> cycle(
-                    std::initializer_list<T>);
-
-            Container container;
-            
-            Cycle(Container&& in_container)
-                : container(std::forward<Container>(in_container))
-            { }
-
-        public:
-            class Iterator 
-                : public std::iterator<std::input_iterator_tag,
-                            iterator_traits_deref<Container>>
-            {
-                private:
-                    using iter_type = iterator_type<Container>;
-                    iterator_type<Container> sub_iter;
-                    iterator_type<Container> begin;
-                    iterator_type<Container> end;
-                public:
-                    Iterator (const iterator_type<Container>& iter,
-                            iterator_type<Container>&& in_end)
-                        : sub_iter{iter},
-                        begin{iter},
-                        end{std::move(in_end)}
-                    { } 
-
-                    iterator_deref<Container> operator*() {
-                        return *this->sub_iter;
-                    }
-                    
-                    iterator_arrow<Container> operator->() {
-                        return apply_arrow(this->sub_iter);
-                    }
-
-                    Iterator& operator++() { 
-                        ++this->sub_iter;
-                        // reset to beginning upon reaching the end
-                        if (!(this->sub_iter != this->end)) {
-                            this->sub_iter = this->begin;
-                        }
-                        return *this;
-                    }
-
-                    Iterator operator++(int) {
-                        auto ret = *this;
-                        ++*this;
-                        return ret;
-                    }
-
-                    bool operator!=(const Iterator& other) const {
-                        return this->sub_iter != other.sub_iter;
-                    }
-
-                    bool operator==(const Iterator& other) const {
-                        return !(*this != other);
-                    }
-            };
-
-            Iterator begin() {
-                return {std::begin(this->container),
-                        std::end(this->container)};
-            }
-
-            Iterator end() {
-                return {std::end(this->container),
-                        std::end(this->container)};
-            }
+  template <typename T>
+  Cycle<std::initializer_list<T>> cycle(std::initializer_list<T>);
 
+  template <typename Container>
+  class Cycle {
+   private:
+    friend Cycle cycle<Container>(Container&&);
+    template <typename T>
+    friend Cycle<std::initializer_list<T>> cycle(std::initializer_list<T>);
+
+    Container container;
+
+    Cycle(Container&& in_container)
+        : container(std::forward<Container>(in_container)) {}
+
+   public:
+    class Iterator : public std::iterator<std::input_iterator_tag,
+                         iterator_traits_deref<Container>> {
+     private:
+      using iter_type = iterator_type<Container>;
+      iterator_type<Container> sub_iter;
+      iterator_type<Container> begin;
+      iterator_type<Container> end;
+
+     public:
+      Iterator(const iterator_type<Container>& iter,
+          iterator_type<Container>&& in_end)
+          : sub_iter{iter}, begin{iter}, end{std::move(in_end)} {}
+
+      iterator_deref<Container> operator*() {
+        return *this->sub_iter;
+      }
+
+      iterator_arrow<Container> operator->() {
+        return apply_arrow(this->sub_iter);
+      }
+
+      Iterator& operator++() {
+        ++this->sub_iter;
+        // reset to beginning upon reaching the end
+        if (!(this->sub_iter != this->end)) {
+          this->sub_iter = this->begin;
+        }
+        return *this;
+      }
+
+      Iterator operator++(int) {
+        auto ret = *this;
+        ++*this;
+        return ret;
+      }
+
+      bool operator!=(const Iterator& other) const {
+        return this->sub_iter != other.sub_iter;
+      }
+
+      bool operator==(const Iterator& other) const {
+        return !(*this != other);
+      }
     };
 
-    template <typename Container>
-    Cycle<Container> cycle(Container&& container) {
-        return {std::forward<Container>(container)};
+    Iterator begin() {
+      return {std::begin(this->container), std::end(this->container)};
     }
 
-    template <typename T>
-    Cycle<std::initializer_list<T>> cycle(std::initializer_list<T> il)
-    {
-        return {std::move(il)};
+    Iterator end() {
+      return {std::end(this->container), std::end(this->container)};
     }
+  };
+
+  template <typename Container>
+  Cycle<Container> cycle(Container&& container) {
+    return {std::forward<Container>(container)};
+  }
+
+  template <typename T>
+  Cycle<std::initializer_list<T>> cycle(std::initializer_list<T> il) {
+    return {std::move(il)};
+  }
 }
 
 #endif
diff --git a/dropwhile.hpp b/dropwhile.hpp
index 7cdece67..073234de 100644
--- a/dropwhile.hpp
+++ b/dropwhile.hpp
@@ -9,129 +9,119 @@
 
 namespace iter {
 
-    template <typename FilterFunc, typename Container>
-    class DropWhile;
-
-    template <typename FilterFunc, typename Container>
-    DropWhile<FilterFunc, Container> dropwhile(FilterFunc, Container&&);
-
-    template <typename FilterFunc, typename T>
-    DropWhile<FilterFunc, std::initializer_list<T>> dropwhile(
-            FilterFunc, std::initializer_list<T>);
-
-    template <typename FilterFunc, typename Container>
-    class DropWhile  {
-        private:
-            Container container;
-            FilterFunc filter_func;
-
-            friend DropWhile dropwhile<FilterFunc, Container>(
-                    FilterFunc, Container&&);
-
-            template <typename FF, typename T>
-            friend DropWhile<FF, std::initializer_list<T>> dropwhile(
-                    FF, std::initializer_list<T>);
-            
-            DropWhile(FilterFunc in_filter_func, Container&& in_container)
-                : container(std::forward<Container>(in_container)),
-                filter_func(in_filter_func)
-            { }
-
-        public:
-            class Iterator 
-                : public std::iterator<std::input_iterator_tag,
-                    iterator_traits_deref<Container>>
-            {
-                private:
-                    using Holder = DerefHolder<iterator_deref<Container>>;
-                    iterator_type<Container> sub_iter;
-                    iterator_type<Container> sub_end;
-                    Holder item;
-                    FilterFunc *filter_func;
-
-                    void inc_sub_iter() {
-                            ++this->sub_iter;
-                            if (this->sub_iter != this->sub_end) {
-                                this->item.reset(*this->sub_iter);
-                            }
-                    }
-
-                    // skip all values for which the predicate is true
-                    void skip_passes() { 
-                        while (this->sub_iter != this->sub_end
-                                && (*this->filter_func)(this->item.get())) {
-                            this->inc_sub_iter();
-                        }
-                    }
-
-                public:
-                    Iterator(iterator_type<Container>&& iter,
-                            iterator_type<Container>&& end,
-                            FilterFunc& in_filter_func)
-                        : sub_iter{std::move(iter)},
-                        sub_end{std::move(end)},
-                        filter_func(&in_filter_func)
-                    { 
-                        if (this->sub_iter != this->sub_end) {
-                            this->item.reset(*this->sub_iter);
-                        }
-                        this->skip_passes();
-                    } 
-
-                    typename Holder::reference operator*() {
-                        return this->item.get();
-                    }
-
-                    typename Holder::pointer operator->() {
-                        return this->item.get_ptr();
-                    }
-
-                    Iterator& operator++() { 
-                        this->inc_sub_iter();
-                        return *this;
-                    }
-
-                    Iterator operator++(int) {
-                        auto ret = *this;
-                        ++*this;
-                        return ret;
-                    }
-
-                    bool operator!=(const Iterator& other) const {
-                        return this->sub_iter != other.sub_iter;
-                    }
-
-                    bool operator==(const Iterator& other) const {
-                        return !(*this != other);
-                    }
-            };
-
-            Iterator begin() {
-                return {std::begin(this->container),
-                        std::end(this->container),
-                        this->filter_func};
-            }
-
-            Iterator end() {
-                return {std::end(this->container),
-                        std::end(this->container),
-                        this->filter_func};
-            }
-
+  template <typename FilterFunc, typename Container>
+  class DropWhile;
+
+  template <typename FilterFunc, typename Container>
+  DropWhile<FilterFunc, Container> dropwhile(FilterFunc, Container&&);
+
+  template <typename FilterFunc, typename T>
+  DropWhile<FilterFunc, std::initializer_list<T>> dropwhile(
+      FilterFunc, std::initializer_list<T>);
+
+  template <typename FilterFunc, typename Container>
+  class DropWhile {
+   private:
+    Container container;
+    FilterFunc filter_func;
+
+    friend DropWhile dropwhile<FilterFunc, Container>(FilterFunc, Container&&);
+
+    template <typename FF, typename T>
+    friend DropWhile<FF, std::initializer_list<T>> dropwhile(
+        FF, std::initializer_list<T>);
+
+    DropWhile(FilterFunc in_filter_func, Container&& in_container)
+        : container(std::forward<Container>(in_container)),
+          filter_func(in_filter_func) {}
+
+   public:
+    class Iterator : public std::iterator<std::input_iterator_tag,
+                         iterator_traits_deref<Container>> {
+     private:
+      using Holder = DerefHolder<iterator_deref<Container>>;
+      iterator_type<Container> sub_iter;
+      iterator_type<Container> sub_end;
+      Holder item;
+      FilterFunc* filter_func;
+
+      void inc_sub_iter() {
+        ++this->sub_iter;
+        if (this->sub_iter != this->sub_end) {
+          this->item.reset(*this->sub_iter);
+        }
+      }
+
+      // skip all values for which the predicate is true
+      void skip_passes() {
+        while (this->sub_iter != this->sub_end
+               && (*this->filter_func)(this->item.get())) {
+          this->inc_sub_iter();
+        }
+      }
+
+     public:
+      Iterator(iterator_type<Container>&& iter, iterator_type<Container>&& end,
+          FilterFunc& in_filter_func)
+          : sub_iter{std::move(iter)},
+            sub_end{std::move(end)},
+            filter_func(&in_filter_func) {
+        if (this->sub_iter != this->sub_end) {
+          this->item.reset(*this->sub_iter);
+        }
+        this->skip_passes();
+      }
+
+      typename Holder::reference operator*() {
+        return this->item.get();
+      }
+
+      typename Holder::pointer operator->() {
+        return this->item.get_ptr();
+      }
+
+      Iterator& operator++() {
+        this->inc_sub_iter();
+        return *this;
+      }
+
+      Iterator operator++(int) {
+        auto ret = *this;
+        ++*this;
+        return ret;
+      }
+
+      bool operator!=(const Iterator& other) const {
+        return this->sub_iter != other.sub_iter;
+      }
+
+      bool operator==(const Iterator& other) const {
+        return !(*this != other);
+      }
     };
 
-    template <typename FilterFunc, typename Container>
-    DropWhile<FilterFunc, Container> dropwhile(
-            FilterFunc filter_func, Container&& container) {
-        return {filter_func, std::forward<Container>(container)};
+    Iterator begin() {
+      return {std::begin(this->container), std::end(this->container),
+          this->filter_func};
     }
 
-    template <typename FilterFunc, typename T>
-    DropWhile<FilterFunc, std::initializer_list<T>> dropwhile(
-            FilterFunc filter_func, std::initializer_list<T> il)
-    {
-        return {filter_func, std::move(il)};
+    Iterator end() {
+      return {std::end(this->container), std::end(this->container),
+          this->filter_func};
     }
+  };
+
+  template <typename FilterFunc, typename Container>
+  DropWhile<FilterFunc, Container> dropwhile(
+      FilterFunc filter_func, Container&& container) {
+    return {filter_func, std::forward<Container>(container)};
+  }
+
+  template <typename FilterFunc, typename T>
+  DropWhile<FilterFunc, std::initializer_list<T>> dropwhile(
+      FilterFunc filter_func, std::initializer_list<T> il) {
+    return {filter_func, std::move(il)};
+  }
 }
 
 #endif
diff --git a/enumerate.hpp b/enumerate.hpp
index e5df1ca9..c43996f7 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -11,111 +11,104 @@
 
 namespace iter {
 
-    //Forward declarations of Enumerable and enumerate
-    template <typename Container>
-    class Enumerable;
+  // Forward declarations of Enumerable and enumerate
+  template <typename Container>
+  class Enumerable;
 
-    template <typename Container>
-    Enumerable<Container> enumerate(Container&&);
+  template <typename Container>
+  Enumerable<Container> enumerate(Container&&);
 
+  template <typename T>
+  Enumerable<std::initializer_list<T>> enumerate(std::initializer_list<T>);
+
+  template <typename Container>
+  class Enumerable {
+   private:
+    Container container;
+
+    // The only thing allowed to directly instantiate an Enumerable is
+    // the enumerate function
+    friend Enumerable enumerate<Container>(Container&&);
     template <typename T>
-    Enumerable<std::initializer_list<T>> enumerate(std::initializer_list<T>);
-
-    template <typename Container>
-    class Enumerable {
-        private:
-            Container container;
-
-            // The only thing allowed to directly instantiate an Enumerable is
-            // the enumerate function
-            friend Enumerable enumerate<Container>(Container&&);
-            template <typename T>
-            friend Enumerable<std::initializer_list<T>> enumerate(
-                    std::initializer_list<T>);
-
-            // for IterYield
-            using BasePair = std::pair<std::size_t, iterator_deref<Container>>;
-
-            // Value constructor for use only in the enumerate function
-            Enumerable(Container&& in_container)
-                : container(std::forward<Container>(in_container))
-            { }
-
-        public:
-            // "yielded" by the Enumerable::Iterator.  Has a .index, and a
-            // .element referencing the value yielded by the subiterator
-            class IterYield : public BasePair {
-                public:
-                    using BasePair::BasePair;
-                    typename BasePair::first_type& index = BasePair::first;
-                    typename BasePair::second_type& element = BasePair::second;
-            };
-
-            //  Holds an iterator of the contained type and a size_t for the
-            //  index.  Each call to ++ increments both of these data members.
-            //  Each dereference returns an IterYield.
-            class Iterator :
-                public std::iterator<std::input_iterator_tag, IterYield>
-            {
-                private:
-                    iterator_type<Container> sub_iter;
-                    std::size_t index;
-                public:
-                    Iterator(iterator_type<Container>&& si)
-                        : sub_iter{std::move(si)},
-                        index{0}
-                    { }
-
-                    IterYield operator*() {
-                        return {this->index, *this->sub_iter};
-                    }
-
-                    ArrowProxy<IterYield> operator->() {
-                        return {**this};
-                    }
-
-                    Iterator& operator++() {
-                        ++this->sub_iter;
-                        ++this->index;
-                        return *this;
-                    }
-
-                    Iterator operator++(int) {
-                        auto ret = *this;
-                        ++*this;
-                        return ret;
-                    }
-
-                    bool operator!=(const Iterator& other) const {
-                        return this->sub_iter != other.sub_iter;
-                    }
-
-                    bool operator==(const Iterator& other) const {
-                        return !(*this != other);
-                    }
-            };
-
-            Iterator begin() {
-                return {std::begin(this->container)};
-            }
-
-            Iterator end() {
-                return {std::end(this->container)};
-            }
+    friend Enumerable<std::initializer_list<T>> enumerate(
+        std::initializer_list<T>);
+
+    // for IterYield
+    using BasePair = std::pair<std::size_t, iterator_deref<Container>>;
+
+    // Value constructor for use only in the enumerate function
+    Enumerable(Container&& in_container)
+        : container(std::forward<Container>(in_container)) {}
+
+   public:
+    // "yielded" by the Enumerable::Iterator.  Has a .index, and a
+    // .element referencing the value yielded by the subiterator
+    class IterYield : public BasePair {
+     public:
+      using BasePair::BasePair;
+      typename BasePair::first_type& index = BasePair::first;
+      typename BasePair::second_type& element = BasePair::second;
+    };
 
+    //  Holds an iterator of the contained type and a size_t for the
+    //  index.  Each call to ++ increments both of these data members.
+    //  Each dereference returns an IterYield.
+    class Iterator : public std::iterator<std::input_iterator_tag, IterYield> {
+     private:
+      iterator_type<Container> sub_iter;
+      std::size_t index;
+
+     public:
+      Iterator(iterator_type<Container>&& si)
+          : sub_iter{std::move(si)}, index{0} {}
+
+      IterYield operator*() {
+        return {this->index, *this->sub_iter};
+      }
+
+      ArrowProxy<IterYield> operator->() {
+        return {**this};
+      }
+
+      Iterator& operator++() {
+        ++this->sub_iter;
+        ++this->index;
+        return *this;
+      }
+
+      Iterator operator++(int) {
+        auto ret = *this;
+        ++*this;
+        return ret;
+      }
+
+      bool operator!=(const Iterator& other) const {
+        return this->sub_iter != other.sub_iter;
+      }
+
+      bool operator==(const Iterator& other) const {
+        return !(*this != other);
+      }
     };
 
-    template <typename Container>
-    Enumerable<Container> enumerate(Container&& container) {
-        return {std::forward<Container>(container)};
+    Iterator begin() {
+      return {std::begin(this->container)};
     }
 
-    template <typename T>
-    Enumerable<std::initializer_list<T>> enumerate(
-            std::initializer_list<T> il)
-    {
-        return {std::move(il)};
+    Iterator end() {
+      return {std::end(this->container)};
     }
+  };
+
+  template <typename Container>
+  Enumerable<Container> enumerate(Container&& container) {
+    return {std::forward<Container>(container)};
+  }
+
+  template <typename T>
+  Enumerable<std::initializer_list<T>> enumerate(std::initializer_list<T> il) {
+    return {std::move(il)};
+  }
 }
 
 #endif
diff --git a/filter.hpp b/filter.hpp
index 12801ed3..89e38531 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -9,175 +9,153 @@
 
 namespace iter {
 
-    //Forward declarations of Filter and filter
-    template <typename FilterFunc, typename Container>
-    class Filter;
-
-    template <typename FilterFunc, typename Container>
-    Filter<FilterFunc, Container> filter(FilterFunc, Container&&);
-
-    template <typename FilterFunc, typename T>
-    Filter<FilterFunc, std::initializer_list<T>> filter(
-            FilterFunc, std::initializer_list<T>);
-
-    template <typename FilterFunc, typename Container>
-    class Filter {
-        private:
-            Container container;
-            FilterFunc filter_func;
-
-            // The filter function is the only thing allowed to create a Filter
-            friend Filter filter<FilterFunc, Container>(
-                    FilterFunc, Container&&);
-
-            template <typename FF, typename T>
-            friend Filter<FF, std::initializer_list<T>> filter(
-                    FF, std::initializer_list<T>);
-            
-            // Value constructor for use only in the filter function
-            Filter(FilterFunc in_filter_func, Container&& in_container)
-                : container(std::forward<Container>(in_container)),
-                filter_func(in_filter_func)
-            { }
-
-        public:
-
-            class Iterator 
-                : public std::iterator<std::input_iterator_tag,
-                        iterator_traits_deref<Container>>
-            {
-                protected:
-                    using Holder = DerefHolder<iterator_deref<Container>>;
-                    iterator_type<Container> sub_iter;
-                    iterator_type<Container> sub_end;
-                    Holder item;
-                    FilterFunc *filter_func;
-
-                    void inc_sub_iter() {
-                            ++this->sub_iter;
-                            if (this->sub_iter != this->sub_end) {
-                                this->item.reset(*this->sub_iter);
-                            }
-                    }
-
-                    // increment until the iterator points to is true on the 
-                    // predicate.  Called by constructor and operator++
-                    void skip_failures() { 
-                        while (this->sub_iter != this->sub_end
-                                && !(*this->filter_func)(this->item.get())) {
-                            this->inc_sub_iter();
-                        }
-                    }
-
-                public:
-                    Iterator (iterator_type<Container> iter,
-                            iterator_type<Container> end,
-                            FilterFunc& in_filter_func)
-                        : sub_iter{iter},
-                        sub_end{end},
-                        filter_func(&in_filter_func)
-                    { 
-                        if (this->sub_iter != this->sub_end) {
-                            this->item.reset(*this->sub_iter);
-                        }
-                        this->skip_failures();
-                    } 
-
-                    typename Holder::reference operator*() {
-                        return this->item.get();
-                    }
-
-                    typename Holder::pointer operator->() {
-                        return this->item.get_ptr();
-                    }
-
-                    Iterator& operator++() { 
-                        this->inc_sub_iter();
-                        this->skip_failures();
-                        return *this;
-                    }
-
-                    Iterator operator++(int) {
-                        auto ret = *this;
-                        ++*this;
-                        return ret;
-                    }
-
-                    bool operator!=(const Iterator& other) const {
-                        return this->sub_iter != other.sub_iter;
-                    }
-
-                    bool operator==(const Iterator& other) const {
-                        return !(*this != other);
-                    }
-            };
-
-            Iterator begin() {
-                return {std::begin(this->container),
-                        std::end(this->container),
-                        this->filter_func};
-            }
-
-            Iterator end() {
-                return {std::end(this->container),
-                        std::end(this->container),
-                        this->filter_func};
-            }
-
+  // Forward declarations of Filter and filter
+  template <typename FilterFunc, typename Container>
+  class Filter;
+
+  template <typename FilterFunc, typename Container>
+  Filter<FilterFunc, Container> filter(FilterFunc, Container&&);
+
+  template <typename FilterFunc, typename T>
+  Filter<FilterFunc, std::initializer_list<T>> filter(
+      FilterFunc, std::initializer_list<T>);
+
+  template <typename FilterFunc, typename Container>
+  class Filter {
+   private:
+    Container container;
+    FilterFunc filter_func;
+
+    // The filter function is the only thing allowed to create a Filter
+    friend Filter filter<FilterFunc, Container>(FilterFunc, Container&&);
+
+    template <typename FF, typename T>
+    friend Filter<FF, std::initializer_list<T>> filter(
+        FF, std::initializer_list<T>);
+
+    // Value constructor for use only in the filter function
+    Filter(FilterFunc in_filter_func, Container&& in_container)
+        : container(std::forward<Container>(in_container)),
+          filter_func(in_filter_func) {}
+
+   public:
+    class Iterator : public std::iterator<std::input_iterator_tag,
+                         iterator_traits_deref<Container>> {
+     protected:
+      using Holder = DerefHolder<iterator_deref<Container>>;
+      iterator_type<Container> sub_iter;
+      iterator_type<Container> sub_end;
+      Holder item;
+      FilterFunc* filter_func;
+
+      void inc_sub_iter() {
+        ++this->sub_iter;
+        if (this->sub_iter != this->sub_end) {
+          this->item.reset(*this->sub_iter);
+        }
+      }
+
+      // increment until the iterator points to is true on the
+      // predicate.  Called by constructor and operator++
+      void skip_failures() {
+        while (this->sub_iter != this->sub_end
+               && !(*this->filter_func)(this->item.get())) {
+          this->inc_sub_iter();
+        }
+      }
+
+     public:
+      Iterator(iterator_type<Container> iter, iterator_type<Container> end,
+          FilterFunc& in_filter_func)
+          : sub_iter{iter}, sub_end{end}, filter_func(&in_filter_func) {
+        if (this->sub_iter != this->sub_end) {
+          this->item.reset(*this->sub_iter);
+        }
+        this->skip_failures();
+      }
+
+      typename Holder::reference operator*() {
+        return this->item.get();
+      }
+
+      typename Holder::pointer operator->() {
+        return this->item.get_ptr();
+      }
+
+      Iterator& operator++() {
+        this->inc_sub_iter();
+        this->skip_failures();
+        return *this;
+      }
+
+      Iterator operator++(int) {
+        auto ret = *this;
+        ++*this;
+        return ret;
+      }
+
+      bool operator!=(const Iterator& other) const {
+        return this->sub_iter != other.sub_iter;
+      }
+
+      bool operator==(const Iterator& other) const {
+        return !(*this != other);
+      }
     };
 
-    // Helper function to instantiate a Filter
-    template <typename FilterFunc, typename Container>
-    Filter<FilterFunc, Container> filter(
-            FilterFunc filter_func, Container&& container) {
-        return {filter_func, std::forward<Container>(container)};
+    Iterator begin() {
+      return {std::begin(this->container), std::end(this->container),
+          this->filter_func};
     }
 
-    template <typename FilterFunc, typename T>
-    Filter<FilterFunc, std::initializer_list<T>> filter(
-            FilterFunc filter_func,
-            std::initializer_list<T> il)
-    {
-        return {filter_func, std::move(il)};
+    Iterator end() {
+      return {std::end(this->container), std::end(this->container),
+          this->filter_func};
     }
+  };
 
-    namespace detail {
-
-        template <typename T>
-        bool boolean_cast(const T& t) {
-            return bool(t);
-        }
-
-        template <typename Container>
-        class BoolTester {
-            public:
-                bool operator() (const iterator_deref<Container> item) const {
-                    return bool(item);
-                }
-        };
-    }
+  // Helper function to instantiate a Filter
+  template <typename FilterFunc, typename Container>
+  Filter<FilterFunc, Container> filter(
+      FilterFunc filter_func, Container&& container) {
+    return {filter_func, std::forward<Container>(container)};
+  }
 
+  template <typename FilterFunc, typename T>
+  Filter<FilterFunc, std::initializer_list<T>> filter(
+      FilterFunc filter_func, std::initializer_list<T> il) {
+    return {filter_func, std::move(il)};
+  }
 
-    template <typename Container>
-    auto filter(Container&& container) ->
-            decltype(filter(
-                        detail::BoolTester<Container>(),
-                        std::forward<Container>(container))) {
-        return filter(
-                detail::BoolTester<Container>(),
-                std::forward<Container>(container));
-    }
+  namespace detail {
 
     template <typename T>
-    auto filter(std::initializer_list<T> il) ->
-            decltype(filter(
-                        detail::BoolTester<std::initializer_list<T>>(),
-                        std::move(il))) {
-           return filter(
-                   detail::BoolTester<std::initializer_list<T>>(),
-                   std::move(il));
+    bool boolean_cast(const T& t) {
+      return bool(t);
     }
 
+    template <typename Container>
+    class BoolTester {
+     public:
+      bool operator()(const iterator_deref<Container> item) const {
+        return bool(item);
+      }
+    };
+  }
+
+  template <typename Container>
+  auto filter(Container&& container) -> decltype(filter(
+      detail::BoolTester<Container>(), std::forward<Container>(container))) {
+    return filter(
+        detail::BoolTester<Container>(), std::forward<Container>(container));
+  }
+
+  template <typename T>
+  auto filter(std::initializer_list<T> il) -> decltype(
+      filter(detail::BoolTester<std::initializer_list<T>>(), std::move(il))) {
+    return filter(
+        detail::BoolTester<std::initializer_list<T>>(), std::move(il));
+  }
 }
 
 #endif
diff --git a/filterfalse.hpp b/filterfalse.hpp
index 247fa84b..9d7d7840 100644
--- a/filterfalse.hpp
+++ b/filterfalse.hpp
@@ -8,98 +8,85 @@
 
 namespace iter {
 
-    namespace detail {
+  namespace detail {
 
-        // Callable object that reverses the boolean result of another
-        // callable, taking the object in a Container's iterator
-        template <typename FilterFunc, typename Container>
-        class PredicateFlipper {
-            private:
-                FilterFunc filter_func;
-
-            public:
-                PredicateFlipper(FilterFunc in_filter_func) :
-                    filter_func(in_filter_func)
-                { }
-
-                PredicateFlipper() = delete;
-                PredicateFlipper(const PredicateFlipper&) = default;
-
-                // Calls the filter_func 
-                bool operator() (const iterator_deref<Container> item) const {
-                    return !bool(filter_func(item));
-                }
-
-                // with non-const incase FilterFunc::operator() is non-const
-                bool operator() (const iterator_deref<Container> item) {
-                    return !bool(filter_func(item));
-                }
-        };
-
-        // Reverses the bool() conversion result of anything that supports a
-        // bool conversion
-        template <typename Container>
-        class BoolFlipper {
-            public:
-                bool operator() (const iterator_deref<Container> item) const {
-                    return !bool(item);
-                }
-        };
-
-
-    }
-
-    // Creates a PredicateFlipper for the predicate function, which reverses
-    // the bool result of the function.  The PredicateFlipper is then passed
-    // to the normal filter() function
+    // Callable object that reverses the boolean result of another
+    // callable, taking the object in a Container's iterator
     template <typename FilterFunc, typename Container>
-    auto filterfalse(FilterFunc filter_func, Container&& container) ->
-            decltype(filter(
-                        detail::PredicateFlipper<FilterFunc, Container>(
-                            filter_func),
-                        std::forward<Container>(container))) {
-        return filter(
-                detail::PredicateFlipper<FilterFunc, Container>(filter_func),
-                std::forward<Container>(container));
-    }
-
-    // Single argument version, uses a BoolFlipper to reverse the truthiness
-    // of an object
+    class PredicateFlipper {
+     private:
+      FilterFunc filter_func;
+
+     public:
+      PredicateFlipper(FilterFunc in_filter_func)
+          : filter_func(in_filter_func) {}
+
+      PredicateFlipper() = delete;
+      PredicateFlipper(const PredicateFlipper&) = default;
+
+      // Calls the filter_func
+      bool operator()(const iterator_deref<Container> item) const {
+        return !bool(filter_func(item));
+      }
+
+      // with non-const incase FilterFunc::operator() is non-const
+      bool operator()(const iterator_deref<Container> item) {
+        return !bool(filter_func(item));
+      }
+    };
+
+    // Reverses the bool() conversion result of anything that supports a
+    // bool conversion
     template <typename Container>
-    auto filterfalse(Container&& container) ->
-            decltype(filter(
-                        detail::BoolFlipper<Container>(),
-                        std::forward<Container>(container))) {
-        return filter(
-                detail::BoolFlipper<Container>(),
-                std::forward<Container>(container));
-    }
-
-    
-
-    //specializations for initializer_lists
-    template <typename FilterFunc, typename T>
-    auto filterfalse(FilterFunc filter_func, std::initializer_list<T> container) ->
-            decltype(filter(
-                        detail::PredicateFlipper<FilterFunc, std::initializer_list<T>>(
-                            filter_func),
-                        std::move(container))) {
-        return filter(
-                detail::PredicateFlipper<FilterFunc, std::initializer_list<T>>(filter_func),
-                std::move(container));
-    }
-
-    // Single argument version, uses a BoolFlipper to reverse the truthiness
-    // of an object
-    template <typename T>
-    auto filterfalse(std::initializer_list<T> container) ->
-            decltype(filter(
-                        detail::BoolFlipper<std::initializer_list<T>>(),
-                        std::move(container))) {
-        return filter(
-                detail::BoolFlipper<std::initializer_list<T>>(),
-                std::move(container));
-    }
+    class BoolFlipper {
+     public:
+      bool operator()(const iterator_deref<Container> item) const {
+        return !bool(item);
+      }
+    };
+  }
+
+  // Creates a PredicateFlipper for the predicate function, which reverses
+  // the bool result of the function.  The PredicateFlipper is then passed
+  // to the normal filter() function
+  template <typename FilterFunc, typename Container>
+  auto filterfalse(FilterFunc filter_func, Container&& container) -> decltype(
+      filter(detail::PredicateFlipper<FilterFunc, Container>(filter_func),
+          std::forward<Container>(container))) {
+    return filter(detail::PredicateFlipper<FilterFunc, Container>(filter_func),
+        std::forward<Container>(container));
+  }
+
+  // Single argument version, uses a BoolFlipper to reverse the truthiness
+  // of an object
+  template <typename Container>
+  auto filterfalse(Container&& container) -> decltype(filter(
+      detail::BoolFlipper<Container>(), std::forward<Container>(container))) {
+    return filter(
+        detail::BoolFlipper<Container>(), std::forward<Container>(container));
+  }
+
+  // specializations for initializer_lists
+  template <typename FilterFunc, typename T>
+  auto filterfalse(FilterFunc filter_func, std::initializer_list<T> container)
+      -> decltype(
+          filter(detail::PredicateFlipper<FilterFunc, std::initializer_list<T>>(
+                     filter_func),
+              std::move(container))) {
+    return filter(
+        detail::PredicateFlipper<FilterFunc, std::initializer_list<T>>(
+            filter_func),
+        std::move(container));
+  }
+
+  // Single argument version, uses a BoolFlipper to reverse the truthiness
+  // of an object
+  template <typename T>
+  auto filterfalse(std::initializer_list<T> container) -> decltype(filter(
+      detail::BoolFlipper<std::initializer_list<T>>(), std::move(container))) {
+    return filter(
+        detail::BoolFlipper<std::initializer_list<T>>(), std::move(container));
+  }
 }
 
 #endif
diff --git a/groupby.hpp b/groupby.hpp
index e238373f..c6d758a1 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -13,336 +13,301 @@
 
 namespace iter {
 
-    template <typename Container, typename KeyFunc>
-    class GroupBy;
-
-    template <typename Container, typename KeyFunc>
-    GroupBy<Container, KeyFunc> groupby(Container&&, KeyFunc);
-
-    template <typename T, typename KeyFunc>
-    GroupBy<std::initializer_list<T>, KeyFunc> groupby(
-            std::initializer_list<T>, KeyFunc);
-
-    template <typename Container, typename KeyFunc>
-    class GroupBy  {
-        private:
-            Container container;
-            KeyFunc key_func;
-
-            friend GroupBy groupby<Container, KeyFunc>(Container&&, KeyFunc);
-
-            template <typename T, typename KF>
-            friend GroupBy<std::initializer_list<T>, KF> groupby(
-                    std::initializer_list<T>, KF);
-
-            using key_func_ret = typename
-                std::result_of<KeyFunc(iterator_deref<Container>)>::type;
-
-            GroupBy(Container&& in_container, KeyFunc in_key_func)
-                : container(std::forward<Container>(in_container)),
-                key_func(in_key_func)
-            { }
-
-        public:
-            GroupBy() = delete;
-            GroupBy(const GroupBy&) = delete;
-            GroupBy& operator=(const GroupBy&) = delete;
-            GroupBy& operator=(GroupBy&&) = delete;
-
-            GroupBy(GroupBy&&) = default;
-
-            class Iterator;
-            class Group;
-
-        private:
-            using KeyGroupPair =
-                std::pair<key_func_ret, Group>;
-            using Holder = DerefHolder<iterator_deref<Container>>;
-        public:
-
-            class Iterator 
-                : public std::iterator<std::input_iterator_tag, KeyGroupPair>
-            {
-                private:
-                    iterator_type<Container> sub_iter;
-                    iterator_type<Container> sub_end;
-                    Holder item;
-                    KeyFunc *key_func;
-
-                    std::unique_ptr<KeyGroupPair> current_key_group_pair;
-
-                public:
-                    Iterator(iterator_type<Container>&& si,
-                              iterator_type<Container>&& end,
-                              KeyFunc& in_key_func)
-                        : sub_iter{std::move(si)},
-                        sub_end{std::move(end)},
-                        key_func(&in_key_func)
-                    {
-                        if (this->sub_iter != this->sub_end) {
-                            this->item.reset(*this->sub_iter);
-                        }
-                    }
-
-                    Iterator(const Iterator& other)
-                        : sub_iter{other.sub_iter},
-                        sub_end{other.sub_end},
-                        item{other.item},
-                        key_func{other.key_func}
-                    { }
-
-                    Iterator& operator=(const Iterator& other) {
-                        if (this == &other) return *this;
-                        this->sub_iter = other.sub_iter;
-                        this->sub_end = other.sub_end;
-                        this->item = other.item;
-                        this->key_func = other.key_func;
-                        this->current_key_group_pair.reset();
-                        return *this;
-                    }
-
-                    ~Iterator() =default;
-
-                    // NOTE the implicitly generated move constructor would
-                    // be wrong
-
-                    KeyGroupPair& operator*() {
-                        set_key_group_pair();
-                        return *this->current_key_group_pair;
-                    }
-
-                    KeyGroupPair *operator->() {
-                        set_key_group_pair();
-                        return this->current_key_group_pair.get();
-                    }
-
-                    Iterator& operator++() { 
-                        if (!this->current_key_group_pair) {
-                            this->set_key_group_pair();
-                        }
-                        this->current_key_group_pair.reset();
-                        return *this;
-                    }
-
-                    Iterator operator++(int) {
-                        auto ret = *this;
-                        ++*this;
-                        return ret;
-                    }
-
-                    bool operator!=(const Iterator& other) const {
-                        return this->sub_iter != other.sub_iter;
-                    }
-
-                    bool operator==(const Iterator& other) const {
-                        return !(*this != other);
-                    }
-
-                    void increment_iterator() {
-                        if (this->sub_iter != this->sub_end) {
-                            ++this->sub_iter;
-                            if (this->sub_iter != this->sub_end) {
-                                this->item.reset(*this->sub_iter);
-                            }
-                        }
-                    }
-
-                    bool exhausted() const {
-                        return !(this->sub_iter != this->sub_end);
-                    }
-
-                    typename Holder::reference get() {
-                        return this->item.get();
-                    }
-
-                    typename Holder::pointer get_ptr() {
-                        return this->item.get_ptr();
-                    }
-
-                    key_func_ret next_key() {
-                        return (*this->key_func)(this->item.get());
-                    }
-
-                    void set_key_group_pair() {
-                        if (!this->current_key_group_pair) {
-                            this->current_key_group_pair.reset(
-                                    new KeyGroupPair(
-                                        (*this->key_func)(this->item.get()),
-                                        Group{*this, this->next_key()}));
-                        }
-                    }
-
-            };
-
-
-            class Group {
-                private:
-                    friend Iterator;
-                    friend class GroupIterator;
-                    Iterator& owner;
-                    key_func_ret key;
-
-                    // completed is set if a Group is iterated through
-                    // completely.  It is checked in the destructor, and
-                    // if the Group has not been completed, the destructor
-                    // exhausts it.  This ensures that the next Group starts
-                    // at the correct position when the user short-circuits
-                    // iteration over a Group.
-                    // The move constructor sets the rvalue's completed
-                    // attribute to true, so its destructor doesn't do anything
-                    // when called.
-                    bool completed = false;
-
-                    Group(Iterator& in_owner, key_func_ret in_key) :
-                        owner(in_owner),
-                        key(in_key)
-                    { }
-
-                public:
-                    ~Group() {
-                        if (!this->completed) {
-                            for (auto iter = this->begin(), end = this->end();
-                                    iter != end;
-                                    ++iter) { }
-                        }
-                    }
-                           
-                    // move-constructible, non-copy-constructible,
-                    // non-assignable
-                    Group() = delete;
-                    Group(const Group&) = default;
-                    Group& operator=(const Group&) = delete;
-                    Group& operator=(Group&&) = delete;
-
-                    Group(Group&& other)
-                            : owner{other.owner},
-                            key{other.key},
-                            completed{other.completed} {
-                        other.completed = true;
-                    }
-
-                    class GroupIterator 
-                        : public std::iterator<std::input_iterator_tag,
-                                iterator_traits_deref<Container>>
-                    {
-                        private:
-                            typename std::remove_reference<key_func_ret>::type  *key;
-                            Group *group_p;
-
-                            bool not_at_end() {
-                                return !this->group_p->owner.exhausted()&&
-                                    this->group_p->owner.next_key() == *this->key;
-                            }
-
-                        public:
-                            GroupIterator(Group *in_group_p,
-                                          key_func_ret& in_key)
-                                : key{&in_key},
-                                group_p{in_group_p}
-                            { }
-
-                            bool operator!=(const GroupIterator& other) const {
-                                return !(*this == other);
-                            }
-
-                            bool operator==(const GroupIterator& other) const {
-                                return this->group_p == other.group_p;
-                            }
-
-                            GroupIterator& operator++() {
-                                this->group_p->owner.increment_iterator();
-                                if (!this->not_at_end()) {
-                                    this->group_p->completed = true;
-                                    this->group_p = nullptr;
-                                }
-                                return *this;
-                            }
-
-                            GroupIterator operator++(int) {
-                                auto ret = *this;
-                                ++*this;
-                                return ret;
-                            }
-
-                            iterator_deref<Container> operator*() {
-                                return this->group_p->owner.get();
-                            }
-
-                            typename Holder::pointer operator->() {
-                                return this->group_p->owner.get_ptr();
-                            }
-                    };
-
-                    GroupIterator begin() {
-                        return {this, key};
-                    }
-
-                    GroupIterator end() {
-                        return {nullptr, key};
-                    }
-
-            };
-
-
-            Iterator begin() {
-                return {std::begin(this->container),
-                        std::end(this->container),
-                        this->key_func};
-            }
-
-            Iterator end() {
-                return {std::end(this->container),
-                        std::end(this->container),
-                        this->key_func};
-            }
-
+  template <typename Container, typename KeyFunc>
+  class GroupBy;
+
+  template <typename Container, typename KeyFunc>
+  GroupBy<Container, KeyFunc> groupby(Container&&, KeyFunc);
+
+  template <typename T, typename KeyFunc>
+  GroupBy<std::initializer_list<T>, KeyFunc> groupby(
+      std::initializer_list<T>, KeyFunc);
+
+  template <typename Container, typename KeyFunc>
+  class GroupBy {
+   private:
+    Container container;
+    KeyFunc key_func;
+
+    friend GroupBy groupby<Container, KeyFunc>(Container&&, KeyFunc);
+
+    template <typename T, typename KF>
+    friend GroupBy<std::initializer_list<T>, KF> groupby(
+        std::initializer_list<T>, KF);
+
+    using key_func_ret =
+        typename std::result_of<KeyFunc(iterator_deref<Container>)>::type;
+
+    GroupBy(Container&& in_container, KeyFunc in_key_func)
+        : container(std::forward<Container>(in_container)),
+          key_func(in_key_func) {}
+
+   public:
+    GroupBy() = delete;
+    GroupBy(const GroupBy&) = delete;
+    GroupBy& operator=(const GroupBy&) = delete;
+    GroupBy& operator=(GroupBy&&) = delete;
+
+    GroupBy(GroupBy&&) = default;
+
+    class Iterator;
+    class Group;
+
+   private:
+    using KeyGroupPair = std::pair<key_func_ret, Group>;
+    using Holder = DerefHolder<iterator_deref<Container>>;
+
+   public:
+    class Iterator
+        : public std::iterator<std::input_iterator_tag, KeyGroupPair> {
+     private:
+      iterator_type<Container> sub_iter;
+      iterator_type<Container> sub_end;
+      Holder item;
+      KeyFunc* key_func;
+
+      std::unique_ptr<KeyGroupPair> current_key_group_pair;
+
+     public:
+      Iterator(iterator_type<Container>&& si, iterator_type<Container>&& end,
+          KeyFunc& in_key_func)
+          : sub_iter{std::move(si)},
+            sub_end{std::move(end)},
+            key_func(&in_key_func) {
+        if (this->sub_iter != this->sub_end) {
+          this->item.reset(*this->sub_iter);
+        }
+      }
+
+      Iterator(const Iterator& other)
+          : sub_iter{other.sub_iter},
+            sub_end{other.sub_end},
+            item{other.item},
+            key_func{other.key_func} {}
+
+      Iterator& operator=(const Iterator& other) {
+        if (this == &other) return *this;
+        this->sub_iter = other.sub_iter;
+        this->sub_end = other.sub_end;
+        this->item = other.item;
+        this->key_func = other.key_func;
+        this->current_key_group_pair.reset();
+        return *this;
+      }
+
+      ~Iterator() = default;
+
+      // NOTE the implicitly generated move constructor would
+      // be wrong
+
+      KeyGroupPair& operator*() {
+        set_key_group_pair();
+        return *this->current_key_group_pair;
+      }
+
+      KeyGroupPair* operator->() {
+        set_key_group_pair();
+        return this->current_key_group_pair.get();
+      }
+
+      Iterator& operator++() {
+        if (!this->current_key_group_pair) {
+          this->set_key_group_pair();
+        }
+        this->current_key_group_pair.reset();
+        return *this;
+      }
+
+      Iterator operator++(int) {
+        auto ret = *this;
+        ++*this;
+        return ret;
+      }
+
+      bool operator!=(const Iterator& other) const {
+        return this->sub_iter != other.sub_iter;
+      }
+
+      bool operator==(const Iterator& other) const {
+        return !(*this != other);
+      }
+
+      void increment_iterator() {
+        if (this->sub_iter != this->sub_end) {
+          ++this->sub_iter;
+          if (this->sub_iter != this->sub_end) {
+            this->item.reset(*this->sub_iter);
+          }
+        }
+      }
+
+      bool exhausted() const {
+        return !(this->sub_iter != this->sub_end);
+      }
+
+      typename Holder::reference get() {
+        return this->item.get();
+      }
+
+      typename Holder::pointer get_ptr() {
+        return this->item.get_ptr();
+      }
+
+      key_func_ret next_key() {
+        return (*this->key_func)(this->item.get());
+      }
+
+      void set_key_group_pair() {
+        if (!this->current_key_group_pair) {
+          this->current_key_group_pair.reset(
+              new KeyGroupPair((*this->key_func)(this->item.get()),
+                  Group{*this, this->next_key()}));
+        }
+      }
     };
 
-    // Takes something and returns it, used for default key of comparing
-    // items in the sequence directly
-    template <typename Container>
-    class ItemReturner {
-        public:
-            iterator_deref<Container> operator() (
-                    iterator_deref<Container> item) const {
-                return item;
-            }
+    class Group {
+     private:
+      friend Iterator;
+      friend class GroupIterator;
+      Iterator& owner;
+      key_func_ret key;
+
+      // completed is set if a Group is iterated through
+      // completely.  It is checked in the destructor, and
+      // if the Group has not been completed, the destructor
+      // exhausts it.  This ensures that the next Group starts
+      // at the correct position when the user short-circuits
+      // iteration over a Group.
+      // The move constructor sets the rvalue's completed
+      // attribute to true, so its destructor doesn't do anything
+      // when called.
+      bool completed = false;
+
+      Group(Iterator& in_owner, key_func_ret in_key)
+          : owner(in_owner), key(in_key) {}
+
+     public:
+      ~Group() {
+        if (!this->completed) {
+          for (auto iter = this->begin(), end = this->end(); iter != end;
+               ++iter) {
+          }
+        }
+      }
+
+      // move-constructible, non-copy-constructible,
+      // non-assignable
+      Group() = delete;
+      Group(const Group&) = default;
+      Group& operator=(const Group&) = delete;
+      Group& operator=(Group&&) = delete;
+
+      Group(Group&& other)
+          : owner{other.owner}, key{other.key}, completed{other.completed} {
+        other.completed = true;
+      }
+
+      class GroupIterator : public std::iterator<std::input_iterator_tag,
+                                iterator_traits_deref<Container>> {
+       private:
+        typename std::remove_reference<key_func_ret>::type* key;
+        Group* group_p;
+
+        bool not_at_end() {
+          return !this->group_p->owner.exhausted()
+                 && this->group_p->owner.next_key() == *this->key;
+        }
+
+       public:
+        GroupIterator(Group* in_group_p, key_func_ret& in_key)
+            : key{&in_key}, group_p{in_group_p} {}
+
+        bool operator!=(const GroupIterator& other) const {
+          return !(*this == other);
+        }
+
+        bool operator==(const GroupIterator& other) const {
+          return this->group_p == other.group_p;
+        }
+
+        GroupIterator& operator++() {
+          this->group_p->owner.increment_iterator();
+          if (!this->not_at_end()) {
+            this->group_p->completed = true;
+            this->group_p = nullptr;
+          }
+          return *this;
+        }
+
+        GroupIterator operator++(int) {
+          auto ret = *this;
+          ++*this;
+          return ret;
+        }
+
+        iterator_deref<Container> operator*() {
+          return this->group_p->owner.get();
+        }
+
+        typename Holder::pointer operator->() {
+          return this->group_p->owner.get_ptr();
+        }
+      };
+
+      GroupIterator begin() {
+        return {this, key};
+      }
+
+      GroupIterator end() {
+        return {nullptr, key};
+      }
     };
 
-
-    template <typename Container, typename KeyFunc>
-    GroupBy<Container, KeyFunc> groupby(
-            Container&& container, KeyFunc key_func) {
-        return {std::forward<Container>(container), key_func};
+    Iterator begin() {
+      return {std::begin(this->container), std::end(this->container),
+          this->key_func};
     }
 
-
-    template <typename Container>
-    auto groupby(Container&& container) ->
-            decltype(groupby(std::forward<Container>(container),
-                        ItemReturner<Container>())) {
-        return groupby(std::forward<Container>(container),
-                ItemReturner<Container>());
+    Iterator end() {
+      return {
+          std::end(this->container), std::end(this->container), this->key_func};
     }
-
-    
-    template <typename T, typename KeyFunc>
-    GroupBy<std::initializer_list<T>, KeyFunc> groupby(
-            std::initializer_list<T> il, KeyFunc key_func) {
-        return {std::move(il), key_func};
+  };
+
+  // Takes something and returns it, used for default key of comparing
+  // items in the sequence directly
+  template <typename Container>
+  class ItemReturner {
+   public:
+    iterator_deref<Container> operator()(iterator_deref<Container> item) const {
+      return item;
     }
-
-
-    template <typename T>
-    auto groupby(std::initializer_list<T> il) ->
-            decltype(groupby(std::move(il),
-                        ItemReturner<std::initializer_list<T>>())) {
-        return groupby(
-                std::move(il),
-                ItemReturner<std::initializer_list<T>>());
-    }
-
+  };
+
+  template <typename Container, typename KeyFunc>
+  GroupBy<Container, KeyFunc> groupby(Container&& container, KeyFunc key_func) {
+    return {std::forward<Container>(container), key_func};
+  }
+
+  template <typename Container>
+  auto groupby(Container&& container) -> decltype(
+      groupby(std::forward<Container>(container), ItemReturner<Container>())) {
+    return groupby(
+        std::forward<Container>(container), ItemReturner<Container>());
+  }
+
+  template <typename T, typename KeyFunc>
+  GroupBy<std::initializer_list<T>, KeyFunc> groupby(
+      std::initializer_list<T> il, KeyFunc key_func) {
+    return {std::move(il), key_func};
+  }
+
+  template <typename T>
+  auto groupby(std::initializer_list<T> il) -> decltype(
+      groupby(std::move(il), ItemReturner<std::initializer_list<T>>())) {
+    return groupby(std::move(il), ItemReturner<std::initializer_list<T>>());
+  }
 }
 
-
 #endif
diff --git a/grouper.hpp b/grouper.hpp
index d3bebcdf..0c6abd09 100644
--- a/grouper.hpp
+++ b/grouper.hpp
@@ -13,124 +13,113 @@
 #include <initializer_list>
 
 namespace iter {
-    template <typename Container>
-    class Grouper;
+  template <typename Container>
+  class Grouper;
 
-    template <typename Container>
-    Grouper<Container> grouper(Container&&, std::size_t);
+  template <typename Container>
+  Grouper<Container> grouper(Container&&, std::size_t);
 
+  template <typename T>
+  Grouper<std::initializer_list<T>> grouper(
+      std::initializer_list<T>, std::size_t);
+
+  template <typename Container>
+  class Grouper {
+   private:
+    Container container;
+    std::size_t group_size;
+
+    Grouper(Container&& c, std::size_t sz)
+        : container(std::forward<Container>(c)), group_size{sz} {}
+
+    friend Grouper grouper<Container>(Container&&, std::size_t);
     template <typename T>
-    Grouper<std::initializer_list<T>> grouper(
-            std::initializer_list<T>, std::size_t);
-
-    template <typename Container>
-    class Grouper {
-        private:
-            Container container;
-            std::size_t group_size;
-
-            Grouper(Container&& c, std::size_t sz)
-                : container(std::forward<Container>(c)),
-                group_size{sz}
-            { }
-
-            friend Grouper grouper<Container>(Container&&, std::size_t);
-            template <typename T>
-            friend Grouper<std::initializer_list<T>> grouper(
-                    std::initializer_list<T>, std::size_t);
-
-            using IndexVector = std::vector<iterator_type<Container>>;
-            using DerefVec = IterIterWrapper<IndexVector>;
-        public:
-            class Iterator :
-                public std::iterator<std::input_iterator_tag, DerefVec>
-            {
-                private:
-                    iterator_type<Container> sub_iter;
-                    iterator_type<Container> sub_end;
-                    DerefVec group;
-                    std::size_t group_size = 0;
-
-                    bool done() const {
-                        return this->group.empty();
-                    }
-
-                    void refill_group() {
-                        this->group.get().clear();
-                        std::size_t i{0};
-                        while (i < group_size
-                                    && this->sub_iter != this->sub_end) {
-                            group.get().push_back(this->sub_iter);
-                            ++this->sub_iter;
-                            ++i;
-                        }
-                    }
-
-                public: 
-                    Iterator(iterator_type<Container>&& in_iter,
-                            iterator_type<Container>&& in_end,
-                            std::size_t s)
-                        : sub_iter{std::move(in_iter)},
-                        sub_end{std::move(in_end)},
-                        group_size{s} 
-                    {
-                        this->group.get().reserve(this->group_size);
-                        this->refill_group();
-                    }
-
-                    Iterator& operator++() {
-                        this->refill_group();
-                        return *this;
-                    }
-
-                    Iterator operator++(int) {
-                        auto ret = *this;
-                        ++*this;
-                        return ret;
-                    }
-
-                    bool operator!=(const Iterator& other) const {
-                        return !(*this == other);
-                    }
-
-                    bool operator==(const Iterator& other) const {
-                        return this->done() == other.done()
-                            && (this->done()
-                                    || !(this->sub_iter != other.sub_iter));
-                    }
-
-
-                    DerefVec& operator*() {
-                        return this->group;
-                    }
-
-                    DerefVec *operator->() {
-                        return &this->group;
-                    }
-            };
-
-            Iterator begin() {
-                return {std::begin(this->container),
-                    std::end(this->container),
-                    group_size};
-            }
-
-            Iterator end() {
-                return {std::end(this->container),
-                    std::end(this->container),
-                    group_size};
-            }
+    friend Grouper<std::initializer_list<T>> grouper(
+        std::initializer_list<T>, std::size_t);
+
+    using IndexVector = std::vector<iterator_type<Container>>;
+    using DerefVec = IterIterWrapper<IndexVector>;
+
+   public:
+    class Iterator : public std::iterator<std::input_iterator_tag, DerefVec> {
+     private:
+      iterator_type<Container> sub_iter;
+      iterator_type<Container> sub_end;
+      DerefVec group;
+      std::size_t group_size = 0;
+
+      bool done() const {
+        return this->group.empty();
+      }
+
+      void refill_group() {
+        this->group.get().clear();
+        std::size_t i{0};
+        while (i < group_size && this->sub_iter != this->sub_end) {
+          group.get().push_back(this->sub_iter);
+          ++this->sub_iter;
+          ++i;
+        }
+      }
+
+     public:
+      Iterator(iterator_type<Container>&& in_iter,
+          iterator_type<Container>&& in_end, std::size_t s)
+          : sub_iter{std::move(in_iter)},
+            sub_end{std::move(in_end)},
+            group_size{s} {
+        this->group.get().reserve(this->group_size);
+        this->refill_group();
+      }
+
+      Iterator& operator++() {
+        this->refill_group();
+        return *this;
+      }
+
+      Iterator operator++(int) {
+        auto ret = *this;
+        ++*this;
+        return ret;
+      }
+
+      bool operator!=(const Iterator& other) const {
+        return !(*this == other);
+      }
+
+      bool operator==(const Iterator& other) const {
+        return this->done() == other.done()
+               && (this->done() || !(this->sub_iter != other.sub_iter));
+      }
+
+      DerefVec& operator*() {
+        return this->group;
+      }
+
+      DerefVec* operator->() {
+        return &this->group;
+      }
     };
 
-    template <typename Container>
-    Grouper<Container> grouper(Container&& container, std::size_t group_size) {
-        return {std::forward<Container>(container), group_size};
+    Iterator begin() {
+      return {
+          std::begin(this->container), std::end(this->container), group_size};
     }
 
-    template <typename T>
-    Grouper<std::initializer_list<T>> grouper(
-            std::initializer_list<T> il, std::size_t group_size) {
-        return {std::move(il), group_size};
+    Iterator end() {
+      return {std::end(this->container), std::end(this->container), group_size};
     }
+  };
+
+  template <typename Container>
+  Grouper<Container> grouper(Container&& container, std::size_t group_size) {
+    return {std::forward<Container>(container), group_size};
+  }
+
+  template <typename T>
+  Grouper<std::initializer_list<T>> grouper(
+      std::initializer_list<T> il, std::size_t group_size) {
+    return {std::move(il), group_size};
+  }
 }
 #endif
diff --git a/imap.hpp b/imap.hpp
index cbe7174c..c65a7035 100644
--- a/imap.hpp
+++ b/imap.hpp
@@ -9,154 +9,136 @@
 
 namespace iter {
 
-    namespace detail {
+  namespace detail {
 
     template <std::size_t Index, typename Functor, typename Tup>
     struct Expander {
-        template <typename... Ts>
-        static auto call(Functor&& f, Tup&& tup, Ts&&... args)
-            -> decltype(Expander<Index-1, Functor, Tup>::call(
-                    std::forward<Functor>(f),
-                    std::forward<Tup>(tup),
-                    std::forward<
-                        typename std::tuple_element<Index-1,
-                            typename std::remove_reference<Tup>::type>::type>(
-                        std::get<Index-1>(tup)),
-                    std::forward<Ts>(args)...))
-        {
-            // recurse
-            return Expander<Index-1, Functor, Tup>::call(
-                    std::forward<Functor>(f),
-                    std::forward<Tup>(tup),
-                    // pull out one element
-                    std::forward<
-                        typename std::tuple_element<Index-1,
-                            typename std::remove_reference<Tup>::type>::type>(
-                        std::get<Index-1>(tup)),
-                    std::forward<Ts>(args)...); // everything already expanded
-        }
+      template <typename... Ts>
+      static auto call(Functor&& f, Tup&& tup, Ts&&... args)
+          -> decltype(Expander<Index - 1, Functor, Tup>::call(
+              std::forward<Functor>(f), std::forward<Tup>(tup),
+              std::forward<typename std::tuple_element<Index - 1,
+                  typename std::remove_reference<Tup>::type>::type>(
+                  std::get<Index - 1>(tup)),
+              std::forward<Ts>(args)...)) {
+        // recurse
+        return Expander<Index - 1, Functor, Tup>::call(
+            std::forward<Functor>(f), std::forward<Tup>(tup),
+            // pull out one element
+            std::forward<typename std::tuple_element<Index - 1,
+                typename std::remove_reference<Tup>::type>::type>(
+                std::get<Index - 1>(tup)),
+            std::forward<Ts>(args)...);  // everything already expanded
+      }
     };
 
     template <typename Functor, typename Tup>
     struct Expander<0, Functor, Tup> {
-        template <typename... Ts>
-        static auto call(Functor&& f, Tup&&, Ts&&... args)
-            -> decltype(f(std::forward<Ts>(args)...))
-        {
-            static_assert(
-                std::tuple_size<
-                    typename std::remove_reference<Tup>::type>::value
-                    == sizeof...(Ts),
-                "tuple has not been fully expanded");
-            return f(std::forward<Ts>(args)...); // the actual call
-        }
+      template <typename... Ts>
+      static auto call(Functor&& f, Tup&&, Ts&&... args)
+          -> decltype(f(std::forward<Ts>(args)...)) {
+        static_assert(
+            std::tuple_size<typename std::remove_reference<Tup>::type>::value
+                == sizeof...(Ts),
+            "tuple has not been fully expanded");
+        return f(std::forward<Ts>(args)...);  // the actual call
+      }
     };
 
     template <typename Functor, typename Tup>
-    auto call_with_tuple(Functor&& f, Tup&& tup)
-        -> decltype(Expander<std::tuple_size<
-                    typename std::remove_reference<Tup>::type>::value,
-                    Functor, Tup>::call(
-                        std::forward<Functor>(f),
-                        std::forward<Tup>(tup)))
-    {
-        return Expander<std::tuple_size<
-            typename std::remove_reference<Tup>::type>::value,
-            Functor, Tup>::call(
-                std::forward<Functor>(f),
-                std::forward<Tup>(tup));
+    auto call_with_tuple(Functor&& f, Tup&& tup) -> decltype(
+        Expander<std::tuple_size<
+                     typename std::remove_reference<Tup>::type>::value,
+            Functor, Tup>::call(std::forward<Functor>(f),
+            std::forward<Tup>(tup))) {
+      return Expander<std::tuple_size<
+                          typename std::remove_reference<Tup>::type>::value,
+          Functor, Tup>::call(std::forward<Functor>(f), std::forward<Tup>(tup));
     }
 
-    } // end detail
-
-    //Forward declarations of IMap and imap
-    template <typename MapFunc, typename... Containers>
-    class IMap;
-
-    template <typename MapFunc, typename... Containers>
-    IMap<MapFunc, Containers...> imap(MapFunc, Containers&&...);
-
-    template <typename MapFunc, typename... Containers>
-    class IMap {
-        // The imap function is the only thing allowed to create a IMap
-        friend IMap imap<MapFunc, Containers...>(MapFunc, Containers&& ...);
-
-        using ZippedType = decltype(zip(std::declval<Containers>()...));
-        using ZippedIterType = iterator_type<ZippedType>;
-        private:
-            MapFunc map_func;
-            ZippedType zipped;
-
-            using IMapIterDeref = decltype(detail::call_with_tuple(
-                        map_func, *std::begin(zipped)));
-            
-            // Value constructor for use only in the imap function
-            IMap(MapFunc in_map_func, Containers&&... in_containers) :
-                map_func(in_map_func),
-                zipped(zip(std::forward<Containers>(in_containers)...))
-            { }
-
-        public:
-            class Iterator 
-                : public std::iterator<std::input_iterator_tag,
-                    typename std::remove_reference<IMapIterDeref>::type >
-            {
-                private:
-                    MapFunc *map_func;
-                    ZippedIterType zipiter;
-
-                public:
-                    Iterator(MapFunc& in_map_func, ZippedIterType&& in_zipiter)
-                        : map_func(&in_map_func),
-                        zipiter(std::move(in_zipiter))
-                    { } 
-
-                    IMapIterDeref operator*() {
-                        return detail::call_with_tuple(
-                                *this->map_func, *(this->zipiter));
-                    }
-
-                    ArrowProxy<IMapIterDeref> operator->() {
-                        return {**this};
-                    }
-
-                    Iterator& operator++() { 
-                        ++this->zipiter;
-                        return *this;
-                    }
- 
-                    Iterator operator++(int) {
-                        auto ret = *this;
-                        ++*this;
-                        return ret;
-                    }
-
-                    bool operator!=(const Iterator& other) const {
-                        return this->zipiter != other.zipiter;
-                    }
-
-                    bool operator==(const Iterator& other) const {
-                        return !(*this != other);
-                    }
-            };
-
-            Iterator begin() {
-                return {this->map_func, this->zipped.begin()};
-            }
-
-            Iterator end() {
-                return {this->map_func, this->zipped.end()};
-            }
+  }  // end detail
 
+  // Forward declarations of IMap and imap
+  template <typename MapFunc, typename... Containers>
+  class IMap;
+
+  template <typename MapFunc, typename... Containers>
+  IMap<MapFunc, Containers...> imap(MapFunc, Containers&&...);
+
+  template <typename MapFunc, typename... Containers>
+  class IMap {
+    // The imap function is the only thing allowed to create a IMap
+    friend IMap imap<MapFunc, Containers...>(MapFunc, Containers&&...);
+
+    using ZippedType = decltype(zip(std::declval<Containers>()...));
+    using ZippedIterType = iterator_type<ZippedType>;
+
+   private:
+    MapFunc map_func;
+    ZippedType zipped;
+
+    using IMapIterDeref =
+        decltype(detail::call_with_tuple(map_func, *std::begin(zipped)));
+
+    // Value constructor for use only in the imap function
+    IMap(MapFunc in_map_func, Containers&&... in_containers)
+        : map_func(in_map_func),
+          zipped(zip(std::forward<Containers>(in_containers)...)) {}
+
+   public:
+    class Iterator : public std::iterator<std::input_iterator_tag,
+                         typename std::remove_reference<IMapIterDeref>::type> {
+     private:
+      MapFunc* map_func;
+      ZippedIterType zipiter;
+
+     public:
+      Iterator(MapFunc& in_map_func, ZippedIterType&& in_zipiter)
+          : map_func(&in_map_func), zipiter(std::move(in_zipiter)) {}
+
+      IMapIterDeref operator*() {
+        return detail::call_with_tuple(*this->map_func, *(this->zipiter));
+      }
+
+      ArrowProxy<IMapIterDeref> operator->() {
+        return {**this};
+      }
+
+      Iterator& operator++() {
+        ++this->zipiter;
+        return *this;
+      }
+
+      Iterator operator++(int) {
+        auto ret = *this;
+        ++*this;
+        return ret;
+      }
+
+      bool operator!=(const Iterator& other) const {
+        return this->zipiter != other.zipiter;
+      }
+
+      bool operator==(const Iterator& other) const {
+        return !(*this != other);
+      }
     };
 
-    // Helper function to instantiate a IMap
-    template <typename MapFunc, typename... Containers>
-    IMap<MapFunc, Containers...> imap(
-            MapFunc map_func, Containers&& ... containers) {
-        return {map_func, std::forward<Containers>(containers)...};
+    Iterator begin() {
+      return {this->map_func, this->zipped.begin()};
     }
 
+    Iterator end() {
+      return {this->map_func, this->zipped.end()};
+    }
+  };
+
+  // Helper function to instantiate a IMap
+  template <typename MapFunc, typename... Containers>
+  IMap<MapFunc, Containers...> imap(
+      MapFunc map_func, Containers&&... containers) {
+    return {map_func, std::forward<Containers>(containers)...};
+  }
 }
 
-#endif // #ifndef ITER_IMAP_H_
+#endif  // #ifndef ITER_IMAP_H_
diff --git a/iteratoriterator.hpp b/iteratoriterator.hpp
index bf4fc35b..ad330c6c 100644
--- a/iteratoriterator.hpp
+++ b/iteratoriterator.hpp
@@ -15,273 +15,254 @@
 // behave like some_collection<T> when iterated over or indexed
 
 namespace iter {
-    template <typename T, typename =void>
-    struct HasConstDeref : std::false_type { };
-
-    template <typename T>
-    struct HasConstDeref<T, void_t<decltype(*std::declval<const T&>())>>
-        : std::true_type { };
-
-    template <typename Iter,
-         typename Diff =typename std::iterator_traits<Iter>::difference_type>
-    class IteratorIterator : public std::iterator<
-        std::random_access_iterator_tag,
-        typename std::iterator_traits<Iter>::value_type,
-        Diff,
-        typename std::iterator_traits<Iter>::pointer,
-        typename std::iterator_traits<Iter>::reference
-     >
-    {
-        static_assert(std::is_same<
-            typename std::iterator_traits<Iter>::iterator_category,
+  template <typename T, typename = void>
+  struct HasConstDeref : std::false_type {};
+
+  template <typename T>
+  struct HasConstDeref<T, void_t<decltype(*std::declval<const T&>())>>
+      : std::true_type {};
+
+  template <typename Iter,
+      typename Diff = typename std::iterator_traits<Iter>::difference_type>
+  class IteratorIterator
+      : public std::iterator<std::random_access_iterator_tag,
+            typename std::iterator_traits<Iter>::value_type, Diff,
+            typename std::iterator_traits<Iter>::pointer,
+            typename std::iterator_traits<Iter>::reference> {
+    static_assert(
+        std::is_same<typename std::iterator_traits<Iter>::iterator_category,
             std::random_access_iterator_tag>::value,
-            "IteratorIterator only works with random access iterators");
-        private:
-            Iter sub_iter;
-        public:
-            IteratorIterator() = default;
-            IteratorIterator(const Iter& it)
-                : sub_iter{it}
-            { }
-
-            bool operator==(const IteratorIterator& other) const {
-                return !(*this != other);
-            }
-
-            bool operator!=(const IteratorIterator& other) const {
-                return this->sub_iter != other.sub_iter;
-            }
-
-            IteratorIterator& operator++() {
-                ++this->sub_iter;
-                return *this;
-            }
-
-            IteratorIterator operator++(int) {
-                auto ret = *this;
-                ++*this;
-                return ret;
-            }
-
-            IteratorIterator& operator--() {
-                --this->sub_iter;
-                return *this;
-            }
-
-            IteratorIterator operator--(int) {
-                auto ret = *this;
-                --*this;
-                return ret;
-            }
-
-            auto operator*() -> decltype(**sub_iter) {
-                return **this->sub_iter;
-            }
-
-            auto operator->() -> decltype(*sub_iter) {
-                return *this->sub_iter;
-            }
-
-
-            IteratorIterator& operator+=(Diff n) {
-                this->sub_iter += n;
-                return *this;
-            }
-
-            IteratorIterator operator+(Diff n) const {
-                auto it = *this;
-                it += n;
-                return it;
-            }
-
-            friend IteratorIterator operator+(Diff n, IteratorIterator it) {
-                it += n;
-                return it;
-            }
-
-            IteratorIterator& operator-=(Diff n) {
-                this->sub_iter -= n;
-                return *this;
-            }
-
-            IteratorIterator operator-(Diff n) const {
-                auto it = *this;
-                it -= n;
-                return it;
-            }
-
-            friend IteratorIterator operator-(Diff n, IteratorIterator it) {
-                it -= n;
-                return it;
-            }
-
-            Diff operator-(const IteratorIterator& rhs) const {
-                return this->sub_iter - rhs.sub_iter;
-            }
-
-            auto operator[](Diff idx) -> decltype(*sub_iter[idx]) {
-                return *sub_iter[idx];
-            }
-
-            bool operator<(const IteratorIterator& rhs) const {
-                return this->sub_iter < rhs.sub_iter;
-            }
-
-            bool operator>(const IteratorIterator& rhs) const {
-                return this->sub_iter > rhs.sub_iter;
-            }
-
-            bool operator<=(const IteratorIterator& rhs) const {
-                return this->sub_iter <= rhs.sub_iter;
-            }
-
-            bool operator>=(const IteratorIterator& rhs) const {
-                return this->sub_iter >= rhs.sub_iter;
-            }
-    };
-
-    template <typename Container>
-    class IterIterWrapper {
-        private:
-            Container container;
-
-            using contained_iter = typename Container::value_type;
-            using size_type = typename Container::size_type;
-            using iterator =
-                IteratorIterator<typename Container::iterator>;
-            using const_iterator =
-                IteratorIterator<typename Container::const_iterator>;
-            using reverse_iterator =
-                IteratorIterator<typename Container::reverse_iterator>;
-            using const_reverse_iterator =
-                IteratorIterator<typename Container::const_reverse_iterator>;
-
-            template <typename U =Container, typename =void>
-            struct ConstAtTypeOrVoid : type_is<void> { };
-
-            template <typename U>
-            struct ConstAtTypeOrVoid <
-                U, void_t<decltype(*std::declval<const U&>().at(0))>>
-            : type_is<decltype(*std::declval<const U&>().at(0))>
-            { };
-
-            using const_at_type_or_void_t = typename ConstAtTypeOrVoid<>::type;
-
-            template <typename U =Container, typename =void>
-            struct ConstIndexTypeOrVoid : type_is<void> { };
-
-            template <typename U>
-            struct ConstIndexTypeOrVoid <
-                U, void_t<decltype(*std::declval<const U&>()[0])>>
-            : type_is<decltype(*std::declval<const U&>()[0])>
-            { };
-
-            using const_index_type_or_void_t =
-                typename ConstIndexTypeOrVoid<>::type;
-
-        public:
-            IterIterWrapper() = default;
-
-            explicit IterIterWrapper(size_type sz)
-                : container(sz)
-            { }
-
-            IterIterWrapper(size_type sz, const contained_iter& val)
-                : container(sz, val)
-            { }
-
-            auto at(size_type pos) -> decltype(*container.at(pos)) {
-                return *container.at(pos);
-            }
-
-            auto at(size_type pos) const ->
-                const_at_type_or_void_t 
-            {
-                return *container.at(pos);
-            }
-
-            auto operator[](size_type pos) 
-                noexcept(noexcept(*container[pos]))
-                -> decltype(*container[pos])
-            {
-                return *container[pos];
-            }
-
-            auto operator[](size_type pos) const
-                noexcept(noexcept(*container[pos]))
-                -> const_index_type_or_void_t
-            {
-                return *container[pos];
-            }
-
-            bool empty() const noexcept {
-                return container.empty();
-            }
-
-            size_type size() const noexcept {
-                return container.size();
-            }
-
-            iterator begin() noexcept {
-                return {container.begin()};
-            }
-
-            iterator end() noexcept {
-                return {container.end()};
-            }
-
-            const_iterator begin() const noexcept {
-                return {container.begin()};
-            }
-
-            const_iterator end() const noexcept {
-                return {container.end()};
-            }
-
-            const_iterator cbegin() const noexcept {
-                return {container.cbegin()};
-            }
-
-            const_iterator cend() const noexcept {
-                return {container.cend()};
-            }
-
-            reverse_iterator rbegin() noexcept {
-                return {container.rbegin()};
-            }
-
-            reverse_iterator rend() noexcept {
-                return {container.rend()};
-            }
-
-            const_reverse_iterator rbegin() const noexcept {
-                return {container.rbegin()};
-            }
-
-            const_reverse_iterator rend() const noexcept {
-                return {container.rend()};
-            }
-
-            const_reverse_iterator crbegin() const noexcept {
-                return {container.rbegin()};
-            }
-
-            const_reverse_iterator crend() const noexcept {
-                return {container.rend()};
-            }
-
-            // get() exposes the underlying container.  this allows the
-            // itertools to manipulate the iterators in the container
-            // and should not be depended on anywhere else.
-            Container& get() noexcept {
-                return container;
-            }
-
-            const Container& get() const noexcept {
-                return container;
-            }
-
-    };
+        "IteratorIterator only works with random access iterators");
+
+   private:
+    Iter sub_iter;
+
+   public:
+    IteratorIterator() = default;
+    IteratorIterator(const Iter& it) : sub_iter{it} {}
+
+    bool operator==(const IteratorIterator& other) const {
+      return !(*this != other);
+    }
+
+    bool operator!=(const IteratorIterator& other) const {
+      return this->sub_iter != other.sub_iter;
+    }
+
+    IteratorIterator& operator++() {
+      ++this->sub_iter;
+      return *this;
+    }
+
+    IteratorIterator operator++(int) {
+      auto ret = *this;
+      ++*this;
+      return ret;
+    }
+
+    IteratorIterator& operator--() {
+      --this->sub_iter;
+      return *this;
+    }
+
+    IteratorIterator operator--(int) {
+      auto ret = *this;
+      --*this;
+      return ret;
+    }
+
+    auto operator*() -> decltype(**sub_iter) {
+      return **this->sub_iter;
+    }
+
+    auto operator-> () -> decltype(*sub_iter) {
+      return *this->sub_iter;
+    }
+
+    IteratorIterator& operator+=(Diff n) {
+      this->sub_iter += n;
+      return *this;
+    }
+
+    IteratorIterator operator+(Diff n) const {
+      auto it = *this;
+      it += n;
+      return it;
+    }
+
+    friend IteratorIterator operator+(Diff n, IteratorIterator it) {
+      it += n;
+      return it;
+    }
+
+    IteratorIterator& operator-=(Diff n) {
+      this->sub_iter -= n;
+      return *this;
+    }
+
+    IteratorIterator operator-(Diff n) const {
+      auto it = *this;
+      it -= n;
+      return it;
+    }
+
+    friend IteratorIterator operator-(Diff n, IteratorIterator it) {
+      it -= n;
+      return it;
+    }
+
+    Diff operator-(const IteratorIterator& rhs) const {
+      return this->sub_iter - rhs.sub_iter;
+    }
+
+    auto operator[](Diff idx) -> decltype(*sub_iter[idx]) {
+      return *sub_iter[idx];
+    }
+
+    bool operator<(const IteratorIterator& rhs) const {
+      return this->sub_iter < rhs.sub_iter;
+    }
+
+    bool operator>(const IteratorIterator& rhs) const {
+      return this->sub_iter > rhs.sub_iter;
+    }
+
+    bool operator<=(const IteratorIterator& rhs) const {
+      return this->sub_iter <= rhs.sub_iter;
+    }
+
+    bool operator>=(const IteratorIterator& rhs) const {
+      return this->sub_iter >= rhs.sub_iter;
+    }
+  };
+
+  template <typename Container>
+  class IterIterWrapper {
+   private:
+    Container container;
+
+    using contained_iter = typename Container::value_type;
+    using size_type = typename Container::size_type;
+    using iterator = IteratorIterator<typename Container::iterator>;
+    using const_iterator = IteratorIterator<typename Container::const_iterator>;
+    using reverse_iterator =
+        IteratorIterator<typename Container::reverse_iterator>;
+    using const_reverse_iterator =
+        IteratorIterator<typename Container::const_reverse_iterator>;
+
+    template <typename U = Container, typename = void>
+    struct ConstAtTypeOrVoid : type_is<void> {};
+
+    template <typename U>
+    struct ConstAtTypeOrVoid<U,
+        void_t<decltype(*std::declval<const U&>().at(0))>>
+        : type_is<decltype(*std::declval<const U&>().at(0))> {};
+
+    using const_at_type_or_void_t = typename ConstAtTypeOrVoid<>::type;
+
+    template <typename U = Container, typename = void>
+    struct ConstIndexTypeOrVoid : type_is<void> {};
+
+    template <typename U>
+    struct ConstIndexTypeOrVoid<U,
+        void_t<decltype(*std::declval<const U&>()[0])>>
+        : type_is<decltype(*std::declval<const U&>()[0])> {};
+
+    using const_index_type_or_void_t = typename ConstIndexTypeOrVoid<>::type;
+
+   public:
+    IterIterWrapper() = default;
+
+    explicit IterIterWrapper(size_type sz) : container(sz) {}
+
+    IterIterWrapper(size_type sz, const contained_iter& val)
+        : container(sz, val) {}
+
+    auto at(size_type pos) -> decltype(*container.at(pos)) {
+      return *container.at(pos);
+    }
+
+    auto at(size_type pos) const -> const_at_type_or_void_t {
+      return *container.at(pos);
+    }
+
+    auto operator[](size_type pos) noexcept(noexcept(*container[pos]))
+        -> decltype(*container[pos]) {
+      return *container[pos];
+    }
+
+    auto operator[](size_type pos) const noexcept(noexcept(*container[pos]))
+        -> const_index_type_or_void_t {
+      return *container[pos];
+    }
+
+    bool empty() const noexcept {
+      return container.empty();
+    }
+
+    size_type size() const noexcept {
+      return container.size();
+    }
+
+    iterator begin() noexcept {
+      return {container.begin()};
+    }
+
+    iterator end() noexcept {
+      return {container.end()};
+    }
+
+    const_iterator begin() const noexcept {
+      return {container.begin()};
+    }
+
+    const_iterator end() const noexcept {
+      return {container.end()};
+    }
+
+    const_iterator cbegin() const noexcept {
+      return {container.cbegin()};
+    }
+
+    const_iterator cend() const noexcept {
+      return {container.cend()};
+    }
+
+    reverse_iterator rbegin() noexcept {
+      return {container.rbegin()};
+    }
+
+    reverse_iterator rend() noexcept {
+      return {container.rend()};
+    }
+
+    const_reverse_iterator rbegin() const noexcept {
+      return {container.rbegin()};
+    }
+
+    const_reverse_iterator rend() const noexcept {
+      return {container.rend()};
+    }
+
+    const_reverse_iterator crbegin() const noexcept {
+      return {container.rbegin()};
+    }
+
+    const_reverse_iterator crend() const noexcept {
+      return {container.rend()};
+    }
+
+    // get() exposes the underlying container.  this allows the
+    // itertools to manipulate the iterators in the container
+    // and should not be depended on anywhere else.
+    Container& get() noexcept {
+      return container;
+    }
+
+    const Container& get() const noexcept {
+      return container;
+    }
+  };
 }
 
 #endif
diff --git a/iterbase.hpp b/iterbase.hpp
index cc195a0e..20585a7a 100644
--- a/iterbase.hpp
+++ b/iterbase.hpp
@@ -1,7 +1,6 @@
 #ifndef ITERBASE_HPP_
 #define ITERBASE_HPP_
 
-
 // This file consists of utilities used for the generic nature of the
 // iterable wrapper classes.  As such, the contents of this file should be
 // considered UNDOCUMENTED and is subject to change without warning.  This
@@ -16,285 +15,268 @@
 #include <cstddef>
 
 namespace iter {
-    template <typename T>
-    struct type_is {
-        using type = T;
-    };
-
-    // gcc CWG 1558
-    template <typename...>
-    struct void_t_help {
-        using type = void;
-    };
-    template <typename... Ts>
-    using void_t = typename void_t_help<Ts...>::type;
-
-
-    // iterator_type<C> is the type of C's iterator
-    template <typename Container>
-    using iterator_type =
-        decltype(std::begin(std::declval<Container&>()));
-
-    // iterator_deref<C> is the type obtained by dereferencing an iterator
-    // to an object of type C
-    template <typename Container>
-    using iterator_deref =
-        decltype(*std::declval<iterator_type<Container>&>());
-
-    // const_iteator_deref is the type obtained through dereferencing
-    // a const iterator& (note: not a const_iterator).  ie: the result
-    // of Container::iterator::operator*() const
-    template <typename Container>
-    using const_iterator_deref =
-        decltype(*std::declval<const iterator_type<Container>&>());
-
-
-    template <typename Container>
-    using iterator_traits_deref =
-        typename std::remove_reference<iterator_deref<Container>>::type;
-
-    // iterator_type<C> is the type of C's iterator
-    template <typename Container>
-    using reverse_iterator_type =
-        decltype(std::declval<Container&>().rbegin());
-
-    // iterator_deref<C> is the type obtained by dereferencing an iterator
-    // to an object of type C
-    template <typename Container>
-    using reverse_iterator_deref =
-        decltype(*std::declval<reverse_iterator_type<Container>&>());
-
-    namespace detail {
-    template <typename T, typename =void>
+  template <typename T>
+  struct type_is {
+    using type = T;
+  };
+
+  // gcc CWG 1558
+  template <typename...>
+  struct void_t_help {
+    using type = void;
+  };
+  template <typename... Ts>
+  using void_t = typename void_t_help<Ts...>::type;
+
+  // iterator_type<C> is the type of C's iterator
+  template <typename Container>
+  using iterator_type = decltype(std::begin(std::declval<Container&>()));
+
+  // iterator_deref<C> is the type obtained by dereferencing an iterator
+  // to an object of type C
+  template <typename Container>
+  using iterator_deref = decltype(*std::declval<iterator_type<Container>&>());
+
+  // const_iteator_deref is the type obtained through dereferencing
+  // a const iterator& (note: not a const_iterator).  ie: the result
+  // of Container::iterator::operator*() const
+  template <typename Container>
+  using const_iterator_deref =
+      decltype(*std::declval<const iterator_type<Container>&>());
+
+  template <typename Container>
+  using iterator_traits_deref =
+      typename std::remove_reference<iterator_deref<Container>>::type;
+
+  // iterator_type<C> is the type of C's iterator
+  template <typename Container>
+  using reverse_iterator_type = decltype(std::declval<Container&>().rbegin());
+
+  // iterator_deref<C> is the type obtained by dereferencing an iterator
+  // to an object of type C
+  template <typename Container>
+  using reverse_iterator_deref =
+      decltype(*std::declval<reverse_iterator_type<Container>&>());
+
+  namespace detail {
+    template <typename T, typename = void>
     struct ArrowHelper {
-        using type = void;
+      using type = void;
     };
 
     template <typename T>
     struct ArrowHelper<T*, void> {
-        using type = T*;
-        constexpr type operator()(T* t) const noexcept {
-            return t;
-        }
+      using type = T*;
+      constexpr type operator()(T* t) const noexcept {
+        return t;
+      }
     };
 
-
     template <typename T>
     struct ArrowHelper<T, void_t<decltype(std::declval<T&>().operator->())>> {
-        using type = decltype(std::declval<T&>().operator->());
-        type operator()(T& t) const {
-            return t.operator->();
-        }
+      using type = decltype(std::declval<T&>().operator->());
+      type operator()(T& t) const {
+        return t.operator->();
+      }
     };
 
     template <typename T>
     using arrow = typename detail::ArrowHelper<T>::type;
-
+  }
+
+  // type of C::iterator::operator->, also works with pointers
+  // void if the iterator has no operator->
+  template <typename C>
+  using iterator_arrow = detail::arrow<iterator_type<C>>;
+
+  template <typename C>
+  using reverse_iterator_arrow = detail::arrow<reverse_iterator_type<C>>;
+
+  // applys the -> operator to an object, if the object is a pointer,
+  // it returns the pointer
+  template <typename T>
+  detail::arrow<T> apply_arrow(T& t) {
+    return detail::ArrowHelper<T>{}(t);
+  }
+
+  // For iterators that have an operator* which returns a value
+  // they can return this type from their operator-> instead, which will
+  // wrap an object and allow it to be used with arrow
+  template <typename T>
+  class ArrowProxy {
+   private:
+    using TPlain = typename std::remove_reference<T>::type;
+    T obj;
+
+   public:
+    constexpr ArrowProxy(T&& in_obj) : obj(std::forward<T>(in_obj)) {}
+
+    TPlain* operator->() {
+      return &obj;
     }
-
-    // type of C::iterator::operator->, also works with pointers
-    // void if the iterator has no operator->
-    template <typename C>
-    using iterator_arrow = detail::arrow<iterator_type<C>>;
-
-    template <typename C>
-    using reverse_iterator_arrow = detail::arrow<reverse_iterator_type<C>>;
-
-    // applys the -> operator to an object, if the object is a pointer,
-    // it returns the pointer
-    template <typename T>
-    detail::arrow<T> apply_arrow(T& t) {
-        return detail::ArrowHelper<T>{}(t);
+  };
+
+  template <typename, typename = void>
+  struct is_random_access_iter : std::false_type {};
+
+  template <typename T>
+  struct is_random_access_iter<T,
+      typename std::enable_if<std::is_same<typename std::iterator_traits<T>::
+                                               iterator_category,
+                                  std::random_access_iterator_tag>::value,
+                                   void>::type> : std::true_type {};
+
+  template <typename T>
+  using has_random_access_iter = is_random_access_iter<iterator_type<T>>;
+  // because std::advance assumes a lot and is actually smart, I need a dumb
+
+  // version that will work with most things
+  template <typename InputIt, typename Distance = std::size_t>
+  void dumb_advance(InputIt& iter, Distance distance = 1) {
+    for (Distance i(0); i < distance; ++i) {
+      ++iter;
     }
+  }
 
-    // For iterators that have an operator* which returns a value
-    // they can return this type from their operator-> instead, which will
-    // wrap an object and allow it to be used with arrow
-    template <typename T>
-    class ArrowProxy {
-        private:
-            using TPlain = typename std::remove_reference<T>::type;
-            T obj;
-        public:
-            constexpr ArrowProxy(T&& in_obj)
-                : obj(std::forward<T>(in_obj))
-            { }
-
-            TPlain *operator->() {
-                return &obj;
-            }
-    };
-
-
-    template <typename, typename =void>
-    struct is_random_access_iter : std::false_type { };
-
-    template <typename T>
-    struct is_random_access_iter<T,
-        typename std::enable_if<
-             std::is_same<
-                 typename std::iterator_traits<T>::iterator_category,
-              std::random_access_iterator_tag>::value,
-          void>::type> : std::true_type { };
-
-    template <typename T>
-    using has_random_access_iter = is_random_access_iter<iterator_type<T>>;
-    // because std::advance assumes a lot and is actually smart, I need a dumb
-
-    // version that will work with most things
-    template <typename InputIt, typename Distance =std::size_t>
-    void dumb_advance(InputIt& iter, Distance distance=1) {
-        for (Distance i(0); i < distance; ++i) {
-            ++iter;
-        }
+  template <typename Iter, typename Distance>
+  void dumb_advance_impl(
+      Iter& iter, const Iter& end, Distance distance, std::false_type) {
+    for (Distance i(0); i < distance && iter != end; ++i) {
+      ++iter;
     }
-
-    template <typename Iter, typename Distance>
-    void dumb_advance_impl(Iter& iter, const Iter& end,
-            Distance distance, std::false_type) {
-        for (Distance i(0); i < distance && iter != end; ++i) {
-            ++iter;
-        }
+  }
+
+  template <typename Iter, typename Distance>
+  void dumb_advance_impl(
+      Iter& iter, const Iter& end, Distance distance, std::true_type) {
+    if (static_cast<Distance>(end - iter) < distance) {
+      iter = end;
+    } else {
+      iter += distance;
     }
-
-    template <typename Iter, typename Distance>
-    void dumb_advance_impl(Iter& iter, const Iter& end,
-            Distance distance, std::true_type) {
-        if (static_cast<Distance>(end - iter) < distance) {
-            iter = end;
-        } else {
-            iter += distance;
-        }
+  }
+
+  // iter will not be incremented past end
+  template <typename Iter, typename Distance = std::size_t>
+  void dumb_advance(Iter& iter, const Iter& end, Distance distance = 1) {
+    dumb_advance_impl(iter, end, distance, is_random_access_iter<Iter>{});
+  }
+
+  template <typename ForwardIt, typename Distance = std::size_t>
+  ForwardIt dumb_next(ForwardIt it, Distance distance = 1) {
+    dumb_advance(it, distance);
+    return it;
+  }
+
+  template <typename ForwardIt, typename Distance = std::size_t>
+  ForwardIt dumb_next(
+      ForwardIt it, const ForwardIt& end, Distance distance = 1) {
+    dumb_advance(it, end, distance);
+    return it;
+  }
+
+  template <typename Container, typename Distance = std::size_t>
+  Distance dumb_size(Container&& container) {
+    Distance d{0};
+    for (auto it = std::begin(container), end = std::end(container); it != end;
+         ++it) {
+      ++d;
     }
-
-    // iter will not be incremented past end
-    template <typename Iter, typename Distance =std::size_t>
-    void dumb_advance(Iter& iter, const Iter& end, Distance distance=1) {
-        dumb_advance_impl(iter, end, distance, is_random_access_iter<Iter>{});
+    return d;
+  }
+
+  template <typename... Ts>
+  struct are_same : std::true_type {};
+
+  template <typename T, typename U, typename... Ts>
+  struct are_same<T, U, Ts...>
+      : std::integral_constant<bool,
+            std::is_same<T, U>::value && are_same<T, Ts...>::value> {};
+
+  // DerefHolder holds the value gotten from an iterator dereference
+  // if the iterate dereferences to an lvalue references, a pointer to the
+  //     element is stored
+  // if it does not, a value is stored instead
+  // get() returns a reference to the held item
+  // get_ptr() returns a pointer to the held item
+  // reset() replaces the currently held item
+
+  template <typename T, typename = void>
+  class DerefHolder {
+   private:
+    static_assert(!std::is_lvalue_reference<T>::value,
+        "Non-lvalue-ref specialization used for lvalue ref type");
+    // it could still be an rvalue reference
+    using TPlain = typename std::remove_reference<T>::type;
+
+    std::unique_ptr<TPlain> item_p;
+
+   public:
+    using reference = TPlain&;
+    using pointer = TPlain*;
+
+    DerefHolder() = default;
+
+    DerefHolder(const DerefHolder& other)
+        : item_p{other.item_p ? new TPlain(*other.item_p) : nullptr} {}
+
+    DerefHolder& operator=(const DerefHolder& other) {
+      this->item_p.reset(other.item_p ? new TPlain(*other.item_p) : nullptr);
+      return *this;
     }
 
-    template <typename ForwardIt, typename Distance =std::size_t>
-    ForwardIt dumb_next(ForwardIt it, Distance distance=1) {
-        dumb_advance(it, distance);
-        return it;
-    }
+    DerefHolder(DerefHolder&&) = default;
+    DerefHolder& operator=(DerefHolder&&) = default;
+    ~DerefHolder() = default;
 
-    template <typename ForwardIt, typename Distance =std::size_t>
-    ForwardIt dumb_next(
-            ForwardIt it, const ForwardIt& end, Distance distance=1) {
-        dumb_advance(it, end, distance);
-        return it;
+    reference get() {
+      return *this->item_p;
     }
 
-    template <typename Container, typename Distance =std::size_t>
-    Distance dumb_size(Container&& container) {
-        Distance d{0};
-        for (auto it = std::begin(container), end = std::end(container);
-                it != end;
-                ++it) {
-            ++d;
-        }
-        return d;
+    pointer get_ptr() {
+      return this->item_p.get();
     }
 
+    void reset(T&& item) {
+      item_p.reset(new TPlain(std::move(item)));
+    }
 
-    template <typename... Ts>
-    struct are_same : std::true_type { };
-
-    template <typename T, typename U, typename... Ts>
-    struct are_same<T, U, Ts...>
-        : std::integral_constant<bool,
-            std::is_same<T, U>::value && are_same<T, Ts...>::value> { };
-
-    // DerefHolder holds the value gotten from an iterator dereference
-    // if the iterate dereferences to an lvalue references, a pointer to the
-    //     element is stored
-    // if it does not, a value is stored instead
-    // get() returns a reference to the held item
-    // get_ptr() returns a pointer to the held item
-    // reset() replaces the currently held item
-
-    template <typename T, typename =void>
-    class DerefHolder {
-        private:
-            static_assert(!std::is_lvalue_reference<T>::value,
-                    "Non-lvalue-ref specialization used for lvalue ref type");
-            // it could still be an rvalue reference
-            using TPlain = typename std::remove_reference<T>::type;
-
-            std::unique_ptr<TPlain> item_p;
-
-        public:
-            using reference = TPlain&;
-            using pointer = TPlain*;
-
-            DerefHolder() = default;
-
-            DerefHolder(const DerefHolder& other)
-                : item_p{other.item_p ? new TPlain(*other.item_p) : nullptr}
-            { }
-
-            DerefHolder& operator=(const DerefHolder& other) {
-                this->item_p.reset(other.item_p
-                        ? new TPlain(*other.item_p) : nullptr);
-                return *this;
-            }
-
-            DerefHolder(DerefHolder&&) = default;
-            DerefHolder& operator=(DerefHolder&&) = default;
-            ~DerefHolder() = default;
+    explicit operator bool() const {
+      return this->item_p;
+    }
+  };
 
-            reference get() {
-                return *this->item_p;
-            }
+  // Specialization for when T is an lvalue ref.  Keep this in mind
+  // wherever a T appears.
+  template <typename T>
+  class DerefHolder<T,
+      typename std::enable_if<std::is_lvalue_reference<T>::value>::type> {
+   public:
+    using reference = T;
+    using pointer = typename std::remove_reference<T>::type*;
 
-            pointer get_ptr() {
-                return this->item_p.get();
-            }
+   private:
+    pointer item_p{};
 
-            void reset(T&& item) {
-                item_p.reset(new TPlain(std::move(item)));
-            }
+   public:
+    DerefHolder() = default;
 
-            explicit operator bool() const {
-                return this->item_p;
-            }
-    };
+    reference get() {
+      return *this->item_p;
+    }
 
+    pointer get_ptr() {
+      return this->item_p;
+    }
 
-    // Specialization for when T is an lvalue ref.  Keep this in mind
-    // wherever a T appears.
-    template <typename T>
-    class DerefHolder<T,
-        typename std::enable_if<std::is_lvalue_reference<T>::value>::type>
-    {
-        public:
-            using reference = T;
-            using pointer = typename std::remove_reference<T>::type*;
-
-        private:
-            pointer item_p{};
-            
-        public:
-            DerefHolder() = default;
-
-            reference get() {
-                return *this->item_p;
-            }
-
-            pointer get_ptr() {
-                return this->item_p;
-            }
-
-            void reset(T item) {
-                this->item_p = &item;
-            }
-
-            explicit operator bool() const {
-                return this->item_p != nullptr;
-            }
-    };
+    void reset(T item) {
+      this->item_p = &item;
+    }
 
+    explicit operator bool() const {
+      return this->item_p != nullptr;
+    }
+  };
 }
 
 #endif
diff --git a/itertools.hpp b/itertools.hpp
index 1f54acff..dddbb293 100644
--- a/itertools.hpp
+++ b/itertools.hpp
@@ -33,5 +33,3 @@
 // included explicitly
 
 #endif
-
-
diff --git a/permutations.hpp b/permutations.hpp
index 4e53f259..772c11d7 100644
--- a/permutations.hpp
+++ b/permutations.hpp
@@ -12,106 +12,94 @@
 
 namespace iter {
 
-    template <typename Container>
-    class Permuter {
-        private:
-            Container container;
-
-            using IndexVector = std::vector<iterator_type<Container>>;
-            using Permutable = IterIterWrapper<IndexVector>;
-
-        public:
-            Permuter(Container&& in_container)
-                : container(std::forward<Container>(in_container))
-            { }
-
-            class Iterator 
-                : public std::iterator<std::input_iterator_tag, Permutable>
-            {
-                private:
-                    static constexpr const int COMPLETE = -1;
-                    static bool cmp_iters(
-                            const iterator_type<Container>& lhs,
-                            const iterator_type<Container>& rhs) noexcept {
-                        return *lhs < *rhs;
-                    }
-
-                    Permutable working_set;
-                    int steps{};
-
-                public:
-                    Iterator(iterator_type<Container>&& sub_iter,
-                            iterator_type<Container>&& sub_end)
-                        : steps{ sub_iter != sub_end ? 0 : COMPLETE }
-                    {
-                        // done like this instead of using vector ctor with
-                        // two iterators because that causes a substitution
-                        // failure when the iterator is minimal
-                        while (sub_iter != sub_end) {
-                            this->working_set.get().push_back(sub_iter);
-                            ++sub_iter;
-                        }
-                        std::sort(std::begin(working_set.get()),
-                                std::end(working_set.get()),
-                                cmp_iters);
-                    }
-
-                    Permutable& operator*() {
-                        return this->working_set;
-                    }
-
-                    Permutable *operator->() {
-                        return &this->working_set;
-                    }
-
-                    Iterator& operator++() {
-                        ++this->steps;
-                        if (!std::next_permutation(std::begin(working_set.get()),
-                                    std::end(working_set.get()), cmp_iters)) {
-                            this->steps = COMPLETE;
-                        }
-                        return *this;
-                    }
-
-                    Iterator operator++(int) {
-                        auto ret = *this;
-                        ++*this;
-                        return ret;
-                    }
-
-                    bool operator!=(const Iterator& other) const {
-                        return !(*this == other);
-                    }
-
-                    bool operator==(const Iterator& other) const {
-                        return this->steps == other.steps;
-                    }
-            };
-
-            Iterator begin() {
-                return {std::begin(this->container),
-                    std::end(this->container)};
-            }
-
-            Iterator end() {
-                return {std::end(this->container),
-                    std::end(this->container)};
-            }
-
-
+  template <typename Container>
+  class Permuter {
+   private:
+    Container container;
+
+    using IndexVector = std::vector<iterator_type<Container>>;
+    using Permutable = IterIterWrapper<IndexVector>;
+
+   public:
+    Permuter(Container&& in_container)
+        : container(std::forward<Container>(in_container)) {}
+
+    class Iterator : public std::iterator<std::input_iterator_tag, Permutable> {
+     private:
+      static constexpr const int COMPLETE = -1;
+      static bool cmp_iters(const iterator_type<Container>& lhs,
+          const iterator_type<Container>& rhs) noexcept {
+        return *lhs < *rhs;
+      }
+
+      Permutable working_set;
+      int steps{};
+
+     public:
+      Iterator(iterator_type<Container>&& sub_iter,
+          iterator_type<Container>&& sub_end)
+          : steps{sub_iter != sub_end ? 0 : COMPLETE} {
+        // done like this instead of using vector ctor with
+        // two iterators because that causes a substitution
+        // failure when the iterator is minimal
+        while (sub_iter != sub_end) {
+          this->working_set.get().push_back(sub_iter);
+          ++sub_iter;
+        }
+        std::sort(std::begin(working_set.get()), std::end(working_set.get()),
+            cmp_iters);
+      }
+
+      Permutable& operator*() {
+        return this->working_set;
+      }
+
+      Permutable* operator->() {
+        return &this->working_set;
+      }
+
+      Iterator& operator++() {
+        ++this->steps;
+        if (!std::next_permutation(std::begin(working_set.get()),
+                std::end(working_set.get()), cmp_iters)) {
+          this->steps = COMPLETE;
+        }
+        return *this;
+      }
+
+      Iterator operator++(int) {
+        auto ret = *this;
+        ++*this;
+        return ret;
+      }
+
+      bool operator!=(const Iterator& other) const {
+        return !(*this == other);
+      }
+
+      bool operator==(const Iterator& other) const {
+        return this->steps == other.steps;
+      }
     };
 
-    template <typename Container>
-    Permuter<Container> permutations(Container&& container) {
-        return {std::forward<Container>(container)};
+    Iterator begin() {
+      return {std::begin(this->container), std::end(this->container)};
     }
 
-    template <typename T>
-    Permuter<std::initializer_list<T>> permutations(
-            std::initializer_list<T> il) {
-        return {std::move(il)};
+    Iterator end() {
+      return {std::end(this->container), std::end(this->container)};
     }
+  };
+
+  template <typename Container>
+  Permuter<Container> permutations(Container&& container) {
+    return {std::forward<Container>(container)};
+  }
 
+  template <typename T>
+  Permuter<std::initializer_list<T>> permutations(std::initializer_list<T> il) {
+    return {std::move(il)};
+  }
 }
 
 #endif
diff --git a/powerset.hpp b/powerset.hpp
index a87b73f2..dda2f4fe 100644
--- a/powerset.hpp
+++ b/powerset.hpp
@@ -12,95 +12,87 @@
 #include <type_traits>
 
 namespace iter {
-    template <typename Container>
-    class Powersetter {
-        private:
-            Container container;
-            using CombinatorType =
-                decltype(combinations(std::declval<Container&>(), 0));
-
-        public:
-            Powersetter(Container&& in_container)
-                : container(std::forward<Container>(in_container))
-            { }
-
-            class Iterator
-                : public std::iterator<
-                      std::input_iterator_tag, CombinatorType>
-            {
-                private:
-                    typename std::remove_reference<Container>::type *
-                        container_p;
-                    std::size_t set_size;
-                    std::shared_ptr<CombinatorType> comb;
-                    iterator_type<CombinatorType> comb_iter;
-                    iterator_type<CombinatorType> comb_end;
-
-                public:
-                    Iterator(Container& in_container, std::size_t sz)
-                        : container_p{&in_container},
-                        set_size{sz},
-                        comb{new CombinatorType(
-                                combinations(in_container, sz))},
-                        comb_iter{std::begin(*comb)},
-                        comb_end{std::end(*comb)}
-                    { }
-
-                    Iterator& operator++() {
-                        ++this->comb_iter;
-                        if (this->comb_iter == this->comb_end) {
-                            ++this->set_size;
-                            this->comb.reset(new CombinatorType(combinations(
-                                            *this->container_p,
-                                            this->set_size)));
-                            this->comb_iter = std::begin(*this->comb);
-                            this->comb_end = std::end(*this->comb);
-                        }
-                        return *this;
-                    }
-
-                    Iterator operator++(int) {
-                        auto ret = *this;
-                        ++*this;
-                        return ret;
-                    }
-
-                    iterator_deref<CombinatorType> operator*() {
-                        return *this->comb_iter;
-                    }
-
-                    iterator_arrow<CombinatorType> operator->() {
-                        apply_arrow(this->comb_iter);
-                    }
-
-                    bool operator != (const Iterator& other) const {
-                        return !(*this == other);
-                    }
-
-                    bool operator==(const Iterator& other) const {
-                        return this->set_size == other.set_size
-                            && this->comb_iter == other.comb_iter;
-                    }
-            };
-
-            Iterator begin() {
-                return {this->container, 0};
-            }
-
-            Iterator end() {
-                return {this->container, dumb_size(this->container) + 1};
-            }
+  template <typename Container>
+  class Powersetter {
+   private:
+    Container container;
+    using CombinatorType =
+        decltype(combinations(std::declval<Container&>(), 0));
+
+   public:
+    Powersetter(Container&& in_container)
+        : container(std::forward<Container>(in_container)) {}
+
+    class Iterator
+        : public std::iterator<std::input_iterator_tag, CombinatorType> {
+     private:
+      typename std::remove_reference<Container>::type* container_p;
+      std::size_t set_size;
+      std::shared_ptr<CombinatorType> comb;
+      iterator_type<CombinatorType> comb_iter;
+      iterator_type<CombinatorType> comb_end;
+
+     public:
+      Iterator(Container& in_container, std::size_t sz)
+          : container_p{&in_container},
+            set_size{sz},
+            comb{new CombinatorType(combinations(in_container, sz))},
+            comb_iter{std::begin(*comb)},
+            comb_end{std::end(*comb)} {}
+
+      Iterator& operator++() {
+        ++this->comb_iter;
+        if (this->comb_iter == this->comb_end) {
+          ++this->set_size;
+          this->comb.reset(new CombinatorType(
+              combinations(*this->container_p, this->set_size)));
+          this->comb_iter = std::begin(*this->comb);
+          this->comb_end = std::end(*this->comb);
+        }
+        return *this;
+      }
+
+      Iterator operator++(int) {
+        auto ret = *this;
+        ++*this;
+        return ret;
+      }
+
+      iterator_deref<CombinatorType> operator*() {
+        return *this->comb_iter;
+      }
+
+      iterator_arrow<CombinatorType> operator->() {
+        apply_arrow(this->comb_iter);
+      }
+
+      bool operator!=(const Iterator& other) const {
+        return !(*this == other);
+      }
+
+      bool operator==(const Iterator& other) const {
+        return this->set_size == other.set_size
+               && this->comb_iter == other.comb_iter;
+      }
     };
 
-    template <typename Container>
-    Powersetter<Container> powerset(Container&& container) {
-        return {std::forward<Container>(container)};
+    Iterator begin() {
+      return {this->container, 0};
     }
 
-    template <typename T>
-    Powersetter<std::initializer_list<T>> powerset(
-            std::initializer_list<T> il) {
-        return {std::move(il)};
+    Iterator end() {
+      return {this->container, dumb_size(this->container) + 1};
     }
+  };
+
+  template <typename Container>
+  Powersetter<Container> powerset(Container&& container) {
+    return {std::forward<Container>(container)};
+  }
+
+  template <typename T>
+  Powersetter<std::initializer_list<T>> powerset(std::initializer_list<T> il) {
+    return {std::move(il)};
+  }
 }
 #endif
diff --git a/product.hpp b/product.hpp
index c0c90858..77f01e33 100644
--- a/product.hpp
+++ b/product.hpp
@@ -9,167 +9,154 @@
 #include <array>
 
 namespace iter {
-    template <typename... RestContainers>
-    class Productor;
-
-    template <typename... Containers>
-    Productor<Containers...> product(Containers&&...);
-
-    // specialization for at least 1 template argument
-    template <typename Container, typename... RestContainers>
-    class Productor <Container, RestContainers...> {
-        static_assert(!std::is_rvalue_reference<Container>::value,
-                "Itertools cannot be templated with rvalue references");
-
-        friend Productor product<Container, RestContainers...>(
-                Container&&, RestContainers&&...);
-
-        template <typename... RC>
-        friend class Productor;
-
-        using ProdIterDeref = std::tuple<
-            iterator_deref<Container>, iterator_deref<RestContainers>...>;
-
-        private:
-            Container container;
-            Productor<RestContainers...> rest_products;
-            Productor(Container&& in_container, RestContainers&&... rest)
-                : container(std::forward<Container>(in_container)),
-                rest_products{std::forward<RestContainers>(rest)...}
-            { }
-
-        public:
-            class Iterator
-                : public std::iterator<std::input_iterator_tag, ProdIterDeref>
-            {
-                private:
-                    using RestIter =
-                        typename Productor<RestContainers...>::Iterator;
-
-                    iterator_type<Container> iter;
-                    iterator_type<Container> begin;
-
-                    RestIter rest_iter;
-                    RestIter rest_end;
-                public:
-                    constexpr static const bool is_base_iter = false;
-                    Iterator(const iterator_type<Container>& it,
-                            RestIter&& rest,
-                            RestIter&& in_rest_end)
-                        : iter{it},
-                        begin{it},
-                        rest_iter{rest},
-                        rest_end{in_rest_end}
-                    { }
-
-                    void reset() {
-                        this->iter = this->begin;
-                    }
-
-                    Iterator& operator++() {
-                        ++this->rest_iter;
-                        if (!(this->rest_iter != this->rest_end)) {
-                            this->rest_iter.reset();
-                            ++this->iter;
-                        }
-                        return *this;
-                    }
-
-                    Iterator operator++(int) {
-                        auto ret = *this;
-                        ++*this;
-                        return ret;
-                    }
-
-                    bool operator!=(const Iterator& other) const {
-                        return this->iter != other.iter &&
-                            (RestIter::is_base_iter
-                                || this->rest_iter != other.rest_iter);
-                    }
-
-                    bool operator==(const Iterator& other) const {
-                        return !(*this != other);
-                    }
-
-
-                    ProdIterDeref operator*() {
-                        return std::tuple_cat(
-                                std::tuple<iterator_deref<Container>>{
-                                    *this->iter},
-                                *this->rest_iter);
-                    }
-
-                    ArrowProxy<ProdIterDeref> operator->() {
-                        return {**this};
-                    }
-            };
-
-            Iterator begin() {
-                return {std::begin(this->container),
-                    std::begin(this->rest_products),
-                    std::end(this->rest_products)};
-            }
-
-            Iterator end() {
-                return {std::end(this->container),
-                    std::end(this->rest_products),
-                    std::end(this->rest_products)};
-            }
+  template <typename... RestContainers>
+  class Productor;
+
+  template <typename... Containers>
+  Productor<Containers...> product(Containers&&...);
+
+  // specialization for at least 1 template argument
+  template <typename Container, typename... RestContainers>
+  class Productor<Container, RestContainers...> {
+    static_assert(!std::is_rvalue_reference<Container>::value,
+        "Itertools cannot be templated with rvalue references");
+
+    friend Productor product<Container, RestContainers...>(
+        Container&&, RestContainers&&...);
+
+    template <typename... RC>
+    friend class Productor;
+
+    using ProdIterDeref = std::tuple<iterator_deref<Container>,
+        iterator_deref<RestContainers>...>;
+
+   private:
+    Container container;
+    Productor<RestContainers...> rest_products;
+    Productor(Container&& in_container, RestContainers&&... rest)
+        : container(std::forward<Container>(in_container)),
+          rest_products{std::forward<RestContainers>(rest)...} {}
+
+   public:
+    class Iterator
+        : public std::iterator<std::input_iterator_tag, ProdIterDeref> {
+     private:
+      using RestIter = typename Productor<RestContainers...>::Iterator;
+
+      iterator_type<Container> iter;
+      iterator_type<Container> begin;
+
+      RestIter rest_iter;
+      RestIter rest_end;
+
+     public:
+      constexpr static const bool is_base_iter = false;
+      Iterator(const iterator_type<Container>& it, RestIter&& rest,
+          RestIter&& in_rest_end)
+          : iter{it}, begin{it}, rest_iter{rest}, rest_end{in_rest_end} {}
+
+      void reset() {
+        this->iter = this->begin;
+      }
+
+      Iterator& operator++() {
+        ++this->rest_iter;
+        if (!(this->rest_iter != this->rest_end)) {
+          this->rest_iter.reset();
+          ++this->iter;
+        }
+        return *this;
+      }
+
+      Iterator operator++(int) {
+        auto ret = *this;
+        ++*this;
+        return ret;
+      }
+
+      bool operator!=(const Iterator& other) const {
+        return this->iter != other.iter
+               && (RestIter::is_base_iter
+                      || this->rest_iter != other.rest_iter);
+      }
+
+      bool operator==(const Iterator& other) const {
+        return !(*this != other);
+      }
+
+      ProdIterDeref operator*() {
+        return std::tuple_cat(
+            std::tuple<iterator_deref<Container>>{*this->iter},
+            *this->rest_iter);
+      }
+
+      ArrowProxy<ProdIterDeref> operator->() {
+        return {**this};
+      }
     };
 
+    Iterator begin() {
+      return {std::begin(this->container), std::begin(this->rest_products),
+          std::end(this->rest_products)};
+    }
 
-    template <>
-    class Productor<> {
-        public:
-            class Iterator
-                : public std::iterator<std::input_iterator_tag, std::tuple<>>
-            {
-                public:
-                    constexpr static const bool is_base_iter = true;
-
-                    void reset() { }
-
-                    Iterator& operator++() {
-                        return *this;
-                    }
-
-                    Iterator operator++(int) {
-                        auto ret = *this;
-                        ++*this;
-                        return ret;
-                    }
-
-                    // see note in zip about base case operator!=
-                    bool operator!=(const Iterator&) const {
-                        return false;
-                    }
-
-                    bool operator==(const Iterator& other) const {
-                        return !(*this != other);
-                    }
-
-                    std::tuple<> operator*() const {
-                        return {};
-                    }
-            };
-
-            Iterator begin() {
-                return {};
-            }
-
-            Iterator end() {
-                return {};
-            }
+    Iterator end() {
+      return {std::end(this->container), std::end(this->rest_products),
+          std::end(this->rest_products)};
+    }
+  };
+
+  template <>
+  class Productor<> {
+   public:
+    class Iterator
+        : public std::iterator<std::input_iterator_tag, std::tuple<>> {
+     public:
+      constexpr static const bool is_base_iter = true;
+
+      void reset() {}
+
+      Iterator& operator++() {
+        return *this;
+      }
+
+      Iterator operator++(int) {
+        auto ret = *this;
+        ++*this;
+        return ret;
+      }
+
+      // see note in zip about base case operator!=
+      bool operator!=(const Iterator&) const {
+        return false;
+      }
+
+      bool operator==(const Iterator& other) const {
+        return !(*this != other);
+      }
+
+      std::tuple<> operator*() const {
+        return {};
+      }
     };
 
-    template <typename... Containers>
-    Productor<Containers...> product(Containers&&... containers) {
-        return {std::forward<Containers>(containers)...};
+    Iterator begin() {
+      return {};
     }
 
-    constexpr std::array<std::tuple<>, 1> product() {
-        return {{}};
+    Iterator end() {
+      return {};
     }
+  };
+
+  template <typename... Containers>
+  Productor<Containers...> product(Containers&&... containers) {
+    return {std::forward<Containers>(containers)...};
+  }
+
+  constexpr std::array<std::tuple<>, 1> product() {
+    return {{}};
+  }
 }
 
 #endif
diff --git a/range.hpp b/range.hpp
index f412a93b..fb955e02 100644
--- a/range.hpp
+++ b/range.hpp
@@ -10,261 +10,237 @@
 
 namespace iter {
 
-    template <typename T, bool IsFloat=std::is_floating_point<T>::value>
-    class RangeIterData;
-
-    // everything except floats
-    template <typename T>
-    class RangeIterData<T, false> {
-        private:
-            T value_{};
-            T step_{};
-        public:
-            constexpr RangeIterData() noexcept =default;
-            constexpr RangeIterData(T in_value, T in_step) noexcept
-                : value_{in_value},
-                step_{in_step}
-            { }
-
-            constexpr T value() const noexcept {
-                return this->value_;
-            }
-
-            constexpr T step() const noexcept {
-                return this->step_;
-            }
-
-            void inc() noexcept {
-                this->value_ += step_;
-            }
-
-            constexpr bool operator==(const RangeIterData& other)
-                const noexcept {
-              return this->value_ == other.value_;
-            }
-
-            constexpr bool operator!=(const RangeIterData& other)
-                const noexcept {
-              return !(*this == other);
-            }
-    };
+  template <typename T, bool IsFloat = std::is_floating_point<T>::value>
+  class RangeIterData;
+
+  // everything except floats
+  template <typename T>
+  class RangeIterData<T, false> {
+   private:
+    T value_{};
+    T step_{};
+
+   public:
+    constexpr RangeIterData() noexcept = default;
+    constexpr RangeIterData(T in_value, T in_step) noexcept : value_{in_value},
+                                                              step_{in_step} {}
+
+    constexpr T value() const noexcept {
+      return this->value_;
+    }
 
-    // float data
-    template <typename T>
-    class RangeIterData<T, true> {
-        private:
-            T start_{};
-            T value_{};
-            T step_{};
-            unsigned long steps_taken{};
-        public:
-            constexpr RangeIterData() noexcept =default;
-            constexpr RangeIterData(T in_start, T in_step) noexcept
-                : start_{in_start},
-                value_{in_start},
-                step_{in_step}
-            { }
-
-            constexpr T value() const noexcept {
-                return this->value_;
-            }
-
-            constexpr T step() const noexcept {
-                return this->step_;
-            }
-
-            void inc() noexcept {
-                ++this->steps_taken;
-                value_ = this->start_ +
-                        (this->step_ * this->steps_taken);
-            }
-
-            constexpr bool operator==(const RangeIterData& other)
-                    const noexcept {
-                // if the difference between the two values is less than the
-                // step size, they are considered equal
-                return (this->value_ < other.value_ ?
-                    other.value_ - this->value_ :
-                    this->value_ - other.value_) < this->step_;
-            }
-
-            constexpr bool operator!=(const RangeIterData& other)
-                  const noexcept {
-                return !(*this == other);
-            }
-    };
+    constexpr T step() const noexcept {
+      return this->step_;
+    }
 
+    void inc() noexcept {
+      this->value_ += step_;
+    }
 
-    template <typename T>
-    class Range;
-
-    template <typename T>
-    constexpr Range<T> range(T) noexcept;
-    template <typename T>
-    constexpr Range<T> range(T, T) noexcept;
-    template <typename T>
-    constexpr Range<T> range(T, T, T) noexcept;
-
-    // General version for everything not a float
-    template <typename T>
-    class Range {
-        friend Range range<T>(T);
-        friend Range range<T>(T, T);
-        friend Range range<T>(T, T, T);
-        private:
-            const T start;
-            const T stop;
-            const T step;
-
-            constexpr Range(T in_stop) noexcept
-                : start{0},
-                stop{in_stop},
-                step{1}
-            { }
-
-            constexpr Range(T in_start, T in_stop, T in_step =1) noexcept
-                : start{in_start},
-                stop{in_stop},
-                step{in_step}
-            { }
-
-        public:
-            // the reference type here is T, which doesn't strictly follow all
-            // of the rules, but std::vector<bool>::iterator::reference isn't
-            // a reference type either, this isn't any worse
-
-            class Iterator
-                : public std::iterator<
-                  std::forward_iterator_tag,
-                  T,
-                  std::ptrdiff_t,
-                  T*,
-                  T>
-            {
-                private:
-                    RangeIterData<T> data;
-                    bool is_end;
-
-                    // compare unsigned values
-                    static bool not_equal_to_impl(
-                            const Iterator& iter, const Iterator& end_iter,
-                            std::true_type ) noexcept {
-                        assert(!iter.is_end);
-                        assert(end_iter.is_end);
-                        return iter.data.value() < end_iter.data.value();
-                    }
-
-                    // compare signed values
-                    static bool not_equal_to_impl(
-                            const Iterator& iter, const Iterator& end_iter,
-                            std::false_type) noexcept {
-                        assert(!iter.is_end);
-                        assert(end_iter.is_end);
-                        return !(iter.data.step() > 0 && iter.data.value()
-                                 >= end_iter.data.value())
-                            && !(iter.data.step() < 0 && iter.data.value()
-                                 <= end_iter.data.value());
-                    }
-
-                    static bool not_equal_to_end(const Iterator& lhs,
-                            const Iterator& rhs) noexcept{
-                        if (rhs.is_end) {
-                            return not_equal_to_impl(
-                                    lhs, rhs, std::is_unsigned<T>{});
-                        } else {
-                            return not_equal_to_impl(
-                                    rhs, lhs, std::is_unsigned<T>{});
-                        }
-                    }
-
-                public:
-                    constexpr Iterator() noexcept =default;
-
-                    constexpr Iterator(T in_value, T in_step, bool in_is_end)
-                        noexcept
-                        : data(in_value, in_step),
-                        is_end{in_is_end}
-                    { }
-
-                    constexpr T operator*() const noexcept {
-                        return this->data.value();
-                    }
-
-                    constexpr ArrowProxy<T> operator->() const noexcept {
-                        return {**this};
-                    }
-
-                    Iterator& operator++() noexcept {
-                        this->data.inc();
-                        return *this;
-                    }
-
-                    Iterator operator++(int) noexcept {
-                        auto ret = *this;
-                        ++*this;
-                        return ret;
-                    }
-
-                    // This operator would more accurately read as "in bounds"
-                    // or "incomplete" because exact comparison with the end
-                    // isn't good enough for the purposes of this Iterator.
-                    // There are two odd cases that need to be handled
-                    //
-                    // 1) The Range is infinite, such as
-                    // Range (-1, 0, -1) which would go forever down toward
-                    // infinitely (theoretically).  If this occurs, the Range
-                    // will instead effectively be empty
-                    //
-                    // 2) (stop - start) % step != 0.  For
-                    // example Range(1, 10, 2).  The iterator will never be
-                    // exactly equal to the stop value.
-                    //
-                    // Another way to think about it is that the "end"
-                    // iterator represents the range of values that are invalid
-                    // So, if an iterator is not equal to that, it is valid
-                    //
-                    // Two end iterators will compare equal
-                    //
-                    // Two non-end iterators will compare by their stored values
-                    bool operator!=(const Iterator& other) const noexcept {
-                        if (this->is_end && other.is_end) {
-                            return false;
-                        }
-
-                        if (!this->is_end && !other.is_end) {
-                            return this->data != other.data;
-                        }
-                        return not_equal_to_end(*this, other);
-                    }
-
-                    bool operator==(const Iterator& other) const noexcept {
-                        return !(*this != other);
-                    }
-            };
-
-            constexpr Iterator begin() const noexcept {
-                return {start, step, false};
-            }
-
-            constexpr Iterator end() const noexcept {
-                return {stop, step, true};
-            }
-    };
+    constexpr bool operator==(const RangeIterData& other) const noexcept {
+      return this->value_ == other.value_;
+    }
 
-    template <typename T>
-    constexpr Range<T> range(T stop) noexcept {
-        return {stop};
+    constexpr bool operator!=(const RangeIterData& other) const noexcept {
+      return !(*this == other);
     }
+  };
+
+  // float data
+  template <typename T>
+  class RangeIterData<T, true> {
+   private:
+    T start_{};
+    T value_{};
+    T step_{};
+    unsigned long steps_taken{};
+
+   public:
+    constexpr RangeIterData() noexcept = default;
+    constexpr RangeIterData(T in_start, T in_step) noexcept : start_{in_start},
+                                                              value_{in_start},
+                                                              step_{in_step} {}
+
+    constexpr T value() const noexcept {
+      return this->value_;
+    }
+
+    constexpr T step() const noexcept {
+      return this->step_;
+    }
+
+    void inc() noexcept {
+      ++this->steps_taken;
+      value_ = this->start_ + (this->step_ * this->steps_taken);
+    }
+
+    constexpr bool operator==(const RangeIterData& other) const noexcept {
+      // if the difference between the two values is less than the
+      // step size, they are considered equal
+      return (this->value_ < other.value_ ? other.value_ - this->value_
+                                          : this->value_ - other.value_)
+             < this->step_;
+    }
+
+    constexpr bool operator!=(const RangeIterData& other) const noexcept {
+      return !(*this == other);
+    }
+  };
+
+  template <typename T>
+  class Range;
+
+  template <typename T>
+  constexpr Range<T> range(T) noexcept;
+  template <typename T>
+  constexpr Range<T> range(T, T) noexcept;
+  template <typename T>
+  constexpr Range<T> range(T, T, T) noexcept;
+
+  // General version for everything not a float
+  template <typename T>
+  class Range {
+    friend Range range<T>(T);
+    friend Range range<T>(T, T);
+    friend Range range<T>(T, T, T);
+
+   private:
+    const T start;
+    const T stop;
+    const T step;
+
+    constexpr Range(T in_stop) noexcept : start{0}, stop{in_stop}, step{1} {}
+
+    constexpr Range(T in_start, T in_stop, T in_step = 1) noexcept
+        : start{in_start},
+          stop{in_stop},
+          step{in_step} {}
+
+   public:
+    // the reference type here is T, which doesn't strictly follow all
+    // of the rules, but std::vector<bool>::iterator::reference isn't
+    // a reference type either, this isn't any worse
+
+    class Iterator : public std::iterator<std::forward_iterator_tag, T,
+                         std::ptrdiff_t, T*, T> {
+     private:
+      RangeIterData<T> data;
+      bool is_end;
+
+      // compare unsigned values
+      static bool not_equal_to_impl(const Iterator& iter,
+          const Iterator& end_iter, std::true_type) noexcept {
+        assert(!iter.is_end);
+        assert(end_iter.is_end);
+        return iter.data.value() < end_iter.data.value();
+      }
+
+      // compare signed values
+      static bool not_equal_to_impl(const Iterator& iter,
+          const Iterator& end_iter, std::false_type) noexcept {
+        assert(!iter.is_end);
+        assert(end_iter.is_end);
+        return !(iter.data.step() > 0
+                   && iter.data.value() >= end_iter.data.value())
+               && !(iter.data.step() < 0
+                      && iter.data.value() <= end_iter.data.value());
+      }
+
+      static bool not_equal_to_end(
+          const Iterator& lhs, const Iterator& rhs) noexcept {
+        if (rhs.is_end) {
+          return not_equal_to_impl(lhs, rhs, std::is_unsigned<T>{});
+        } else {
+          return not_equal_to_impl(rhs, lhs, std::is_unsigned<T>{});
+        }
+      }
+
+     public:
+      constexpr Iterator() noexcept = default;
+
+      constexpr Iterator(T in_value, T in_step, bool in_is_end) noexcept
+          : data(in_value, in_step),
+            is_end{in_is_end} {}
+
+      constexpr T operator*() const noexcept {
+        return this->data.value();
+      }
+
+      constexpr ArrowProxy<T> operator->() const noexcept {
+        return {**this};
+      }
+
+      Iterator& operator++() noexcept {
+        this->data.inc();
+        return *this;
+      }
+
+      Iterator operator++(int) noexcept {
+        auto ret = *this;
+        ++*this;
+        return ret;
+      }
+
+      // This operator would more accurately read as "in bounds"
+      // or "incomplete" because exact comparison with the end
+      // isn't good enough for the purposes of this Iterator.
+      // There are two odd cases that need to be handled
+      //
+      // 1) The Range is infinite, such as
+      // Range (-1, 0, -1) which would go forever down toward
+      // infinitely (theoretically).  If this occurs, the Range
+      // will instead effectively be empty
+      //
+      // 2) (stop - start) % step != 0.  For
+      // example Range(1, 10, 2).  The iterator will never be
+      // exactly equal to the stop value.
+      //
+      // Another way to think about it is that the "end"
+      // iterator represents the range of values that are invalid
+      // So, if an iterator is not equal to that, it is valid
+      //
+      // Two end iterators will compare equal
+      //
+      // Two non-end iterators will compare by their stored values
+      bool operator!=(const Iterator& other) const noexcept {
+        if (this->is_end && other.is_end) {
+          return false;
+        }
+
+        if (!this->is_end && !other.is_end) {
+          return this->data != other.data;
+        }
+        return not_equal_to_end(*this, other);
+      }
+
+      bool operator==(const Iterator& other) const noexcept {
+        return !(*this != other);
+      }
+    };
 
-    template <typename T>
-    constexpr Range<T> range(T start, T stop) noexcept {
-        return {start, stop};
+    constexpr Iterator begin() const noexcept {
+      return {start, step, false};
     }
 
-    template <typename T>
-    constexpr Range<T> range(T start, T stop, T step) noexcept {
-        return step == T(0) ? Range<T>{0} : Range<T>{start, stop, step};
+    constexpr Iterator end() const noexcept {
+      return {stop, step, true};
     }
+  };
+
+  template <typename T>
+  constexpr Range<T> range(T stop) noexcept {
+    return {stop};
+  }
+
+  template <typename T>
+  constexpr Range<T> range(T start, T stop) noexcept {
+    return {start, stop};
+  }
+
+  template <typename T>
+  constexpr Range<T> range(T start, T stop, T step) noexcept {
+    return step == T(0) ? Range<T>{0} : Range<T>{start, stop, step};
+  }
 }
 
-#endif // #ifndef ITER_RANGE_H_
+#endif  // #ifndef ITER_RANGE_H_
diff --git a/repeat.hpp b/repeat.hpp
index b2449baf..b2ba8ff7 100644
--- a/repeat.hpp
+++ b/repeat.hpp
@@ -6,148 +6,140 @@
 #include <utility>
 
 namespace iter {
-    template <typename T>
-    class RepeaterWithCount ;
-
-    template <typename T>
-    constexpr RepeaterWithCount<T> repeat(T&&, int);
-
-    template <typename T>
-    class RepeaterWithCount {
-        friend RepeaterWithCount repeat<T>(T&&, int);
-        private:
-            T elem;
-            int count;
-
-            constexpr RepeaterWithCount(T e, int c)
-                : elem(std::forward<T>(e)),
-                count{c}
-            { }
-
-            using TPlain = typename std::remove_reference<T>::type;
-        public:
-            class Iterator
-                : public std::iterator<std::input_iterator_tag, const TPlain>
-            {
-                private:
-                    const TPlain *elem;
-                    int count;
-                public:
-                    constexpr Iterator(const TPlain* e, int c)
-                        : elem{e},
-                        count{c}
-                    { }
-
-                    Iterator& operator++() {
-                        --this->count;
-                        return *this;
-                    }
-
-                    Iterator operator++(int) {
-                        auto ret = *this;
-                        ++*this;
-                        return ret;
-                    }
-
-                    constexpr bool operator!=(const Iterator& other) const {
-                        return !(*this == other);
-                    }
-
-                    constexpr bool operator==(const Iterator& other) const {
-                        return this->count == other.count;
-                    }
-
-                    constexpr const TPlain& operator*() const {
-                        return *this->elem;
-                    }
-
-                    constexpr const TPlain* operator->() const {
-                        return this->elem;
-                    }
-            };
-
-            constexpr Iterator begin() {
-                return {&this->elem, this->count};
-            }
-
-            constexpr Iterator end() {
-                return {&this->elem, 0};
-            }
+  template <typename T>
+  class RepeaterWithCount;
 
+  template <typename T>
+  constexpr RepeaterWithCount<T> repeat(T&&, int);
+
+  template <typename T>
+  class RepeaterWithCount {
+    friend RepeaterWithCount repeat<T>(T&&, int);
+
+   private:
+    T elem;
+    int count;
+
+    constexpr RepeaterWithCount(T e, int c)
+        : elem(std::forward<T>(e)), count{c} {}
+
+    using TPlain = typename std::remove_reference<T>::type;
+
+   public:
+    class Iterator
+        : public std::iterator<std::input_iterator_tag, const TPlain> {
+     private:
+      const TPlain* elem;
+      int count;
+
+     public:
+      constexpr Iterator(const TPlain* e, int c) : elem{e}, count{c} {}
+
+      Iterator& operator++() {
+        --this->count;
+        return *this;
+      }
+
+      Iterator operator++(int) {
+        auto ret = *this;
+        ++*this;
+        return ret;
+      }
+
+      constexpr bool operator!=(const Iterator& other) const {
+        return !(*this == other);
+      }
+
+      constexpr bool operator==(const Iterator& other) const {
+        return this->count == other.count;
+      }
+
+      constexpr const TPlain& operator*() const {
+        return *this->elem;
+      }
+
+      constexpr const TPlain* operator->() const {
+        return this->elem;
+      }
     };
-        
-    template <typename T>
-    constexpr RepeaterWithCount<T> repeat(T&& e, int count) {
-        return {std::forward<T>(e), count < 0 ? 0 : count};
+
+    constexpr Iterator begin() {
+      return {&this->elem, this->count};
+    }
+
+    constexpr Iterator end() {
+      return {&this->elem, 0};
     }
+  };
+
+  template <typename T>
+  constexpr RepeaterWithCount<T> repeat(T&& e, int count) {
+    return {std::forward<T>(e), count < 0 ? 0 : count};
+  }
 
-    template <typename T>
-    class Repeater;
-
-    template <typename T>
-    constexpr Repeater<T> repeat(T&&);
-
-    template <typename T>
-    class Repeater{
-        friend Repeater repeat<T>(T&&);
-        private:
-            using TPlain = typename std::remove_reference<T>::type;
-            T elem;
-
-            constexpr Repeater(T e)
-                : elem(std::forward<T>(e))
-            { }
-        public:
-            class Iterator
-                : public std::iterator<std::input_iterator_tag, const TPlain>
-            {
-                private:
-                    const TPlain *elem;
-
-                public:
-                    constexpr Iterator(const TPlain* e)
-                        : elem{e}
-                    { }
-
-                    constexpr const Iterator& operator++() const {
-                        return *this;
-                    }
-
-                    constexpr Iterator operator++(int) const {
-                        return *this;
-                    }
-
-                    constexpr bool operator!=(const Iterator&) const {
-                        return true;
-                    }
-
-                    constexpr bool operator==(const Iterator&) const {
-                        return false;
-                    }
-
-                    constexpr const TPlain& operator*() const {
-                        return *this->elem;
-                    }
-
-                    constexpr const TPlain* operator->() const {
-                        return this->elem;
-                    }
-            };
-
-
-            constexpr Iterator begin() {
-                return {&this->elem};
-            }
-
-            constexpr Iterator end() {
-                return {nullptr};
-            }
+  template <typename T>
+  class Repeater;
+
+  template <typename T>
+  constexpr Repeater<T> repeat(T&&);
+
+  template <typename T>
+  class Repeater {
+    friend Repeater repeat<T>(T&&);
+
+   private:
+    using TPlain = typename std::remove_reference<T>::type;
+    T elem;
+
+    constexpr Repeater(T e) : elem(std::forward<T>(e)) {}
+
+   public:
+    class Iterator
+        : public std::iterator<std::input_iterator_tag, const TPlain> {
+     private:
+      const TPlain* elem;
+
+     public:
+      constexpr Iterator(const TPlain* e) : elem{e} {}
+
+      constexpr const Iterator& operator++() const {
+        return *this;
+      }
+
+      constexpr Iterator operator++(int) const {
+        return *this;
+      }
+
+      constexpr bool operator!=(const Iterator&) const {
+        return true;
+      }
+
+      constexpr bool operator==(const Iterator&) const {
+        return false;
+      }
+
+      constexpr const TPlain& operator*() const {
+        return *this->elem;
+      }
+
+      constexpr const TPlain* operator->() const {
+        return this->elem;
+      }
     };
 
-    template <typename T>
-    constexpr Repeater<T> repeat(T&& e) {
-        return {std::forward<T>(e)};
+    constexpr Iterator begin() {
+      return {&this->elem};
     }
+
+    constexpr Iterator end() {
+      return {nullptr};
+    }
+  };
+
+  template <typename T>
+  constexpr Repeater<T> repeat(T&& e) {
+    return {std::forward<T>(e)};
+  }
 }
 
 #endif
diff --git a/reversed.hpp b/reversed.hpp
index 795cb7ea..ccc63470 100644
--- a/reversed.hpp
+++ b/reversed.hpp
@@ -7,149 +7,138 @@
 #include <iterator>
 
 namespace iter {
-    template <typename Container>
-    class Reverser;
-
-    template <typename Container>
-    Reverser<Container> reversed(Container&&);
-
-
-    template <typename Container>
-    class Reverser {
-        private:
-            Container container;
-            friend Reverser reversed<Container>(Container&&);
-            
-            Reverser(Container&& in_container)
-                : container(std::forward<Container>(in_container))
-            { }
-
-        public:
-            class Iterator : public std::iterator<
-                         std::input_iterator_tag,
-                         iterator_traits_deref<Container>>
-            {
-                private:
-                    reverse_iterator_type<Container> sub_iter;
-                public:
-                    Iterator (reverse_iterator_type<Container>&& iter)
-                        : sub_iter{std::move(iter)}
-                    { } 
-
-                    reverse_iterator_deref<Container> operator*() {
-                        return *this->sub_iter;
-                    }
-
-                    reverse_iterator_arrow<Container> operator->() {
-                        return apply_arrow(this->sub_iter);
-                    }
-
-                    Iterator& operator++() { 
-                        ++this->sub_iter;
-                        return *this;
-                    }
-
-                    Iterator operator++(int) {
-                        auto ret = *this;
-                        ++*this;
-                        return ret;
-                    }
-
-                    bool operator!=(const Iterator& other) const {
-                        return this->sub_iter != other.sub_iter;
-                    }
-
-                    bool operator==(const Iterator& other) const {
-                        return !(*this != other);
-                    }
-            };
-
-            Iterator begin() {
-                return {this->container.rbegin()};
-            }
-
-            Iterator end() {
-                return {this->container.rend()};
-            }
-
+  template <typename Container>
+  class Reverser;
+
+  template <typename Container>
+  Reverser<Container> reversed(Container&&);
+
+  template <typename Container>
+  class Reverser {
+   private:
+    Container container;
+    friend Reverser reversed<Container>(Container&&);
+
+    Reverser(Container&& in_container)
+        : container(std::forward<Container>(in_container)) {}
+
+   public:
+    class Iterator : public std::iterator<std::input_iterator_tag,
+                         iterator_traits_deref<Container>> {
+     private:
+      reverse_iterator_type<Container> sub_iter;
+
+     public:
+      Iterator(reverse_iterator_type<Container>&& iter)
+          : sub_iter{std::move(iter)} {}
+
+      reverse_iterator_deref<Container> operator*() {
+        return *this->sub_iter;
+      }
+
+      reverse_iterator_arrow<Container> operator->() {
+        return apply_arrow(this->sub_iter);
+      }
+
+      Iterator& operator++() {
+        ++this->sub_iter;
+        return *this;
+      }
+
+      Iterator operator++(int) {
+        auto ret = *this;
+        ++*this;
+        return ret;
+      }
+
+      bool operator!=(const Iterator& other) const {
+        return this->sub_iter != other.sub_iter;
+      }
+
+      bool operator==(const Iterator& other) const {
+        return !(*this != other);
+      }
     };
 
-    template <typename Container>
-    Reverser<Container> reversed(Container&& container) {
-        return {std::forward<Container>(container)};
+    Iterator begin() {
+      return {this->container.rbegin()};
     }
 
-    //
-    // specialization for statically allocated arrays
-    //
-    template <typename T, std::size_t N>
-    Reverser<T[N]> reversed(T (&)[N]);
-
-    template <typename T, std::size_t N>
-    class Reverser<T[N]> {
-        private:
-            T *array;
-            friend Reverser reversed<T, N>(T (&)[N]);
-            
-            // Value constructor for use only in the reversed function
-            Reverser(T *in_array)
-                : array{in_array}
-            { }
-
-        public:
-            Reverser(const Reverser&) = default;
-            class Iterator : public std::iterator<std::input_iterator_tag, T>
-            {
-                private:
-                    T *sub_iter;
-                public:
-                    Iterator (T *iter)
-                        : sub_iter{iter}
-                    { } 
-
-                    T& operator*() {
-                        return *(this->sub_iter - 1);
-                    }
-
-                    T *operator->() {
-                        return (this->sub_iter - 1);
-                    }
-
-                    Iterator& operator++() { 
-                        --this->sub_iter;
-                        return *this;
-                    }
-
-                    Iterator operator++(int) {
-                        auto ret = *this;
-                        ++*this;
-                        return ret;
-                    }
-
-                    bool operator!=(const Iterator& other) const {
-                        return this->sub_iter != other.sub_iter;
-                    }
-
-                    bool operator==(const Iterator& other) const {
-                        return !(*this != other);
-                    }
-            };
-
-            Iterator begin() {
-                return {this->array + N};
-            }
-
-            Iterator end() {
-            return {this->array};
-            }
-
+    Iterator end() {
+      return {this->container.rend()};
+    }
+  };
+
+  template <typename Container>
+  Reverser<Container> reversed(Container&& container) {
+    return {std::forward<Container>(container)};
+  }
+
+  //
+  // specialization for statically allocated arrays
+  //
+  template <typename T, std::size_t N>
+  Reverser<T[N]> reversed(T(&)[N]);
+
+  template <typename T, std::size_t N>
+  class Reverser<T[N]> {
+   private:
+    T* array;
+    friend Reverser reversed<T, N>(T(&)[N]);
+
+    // Value constructor for use only in the reversed function
+    Reverser(T* in_array) : array{in_array} {}
+
+   public:
+    Reverser(const Reverser&) = default;
+    class Iterator : public std::iterator<std::input_iterator_tag, T> {
+     private:
+      T* sub_iter;
+
+     public:
+      Iterator(T* iter) : sub_iter{iter} {}
+
+      T& operator*() {
+        return *(this->sub_iter - 1);
+      }
+
+      T* operator->() {
+        return (this->sub_iter - 1);
+      }
+
+      Iterator& operator++() {
+        --this->sub_iter;
+        return *this;
+      }
+
+      Iterator operator++(int) {
+        auto ret = *this;
+        ++*this;
+        return ret;
+      }
+
+      bool operator!=(const Iterator& other) const {
+        return this->sub_iter != other.sub_iter;
+      }
+
+      bool operator==(const Iterator& other) const {
+        return !(*this != other);
+      }
     };
 
-    template <typename T, std::size_t N>
-    Reverser<T[N]> reversed(T (&array)[N]) {
-        return {array};
+    Iterator begin() {
+      return {this->array + N};
+    }
+
+    Iterator end() {
+      return {this->array};
     }
+  };
 
+  template <typename T, std::size_t N>
+  Reverser<T[N]> reversed(T(&array)[N]) {
+    return {array};
+  }
 }
 
 #endif
diff --git a/slice.hpp b/slice.hpp
index 1880522d..671e3a68 100644
--- a/slice.hpp
+++ b/slice.hpp
@@ -7,153 +7,140 @@
 #include <type_traits>
 #include <initializer_list>
 
-
 namespace iter {
 
-    template <typename Container, typename DifferenceType>
-    class Slice;
-
-    template <typename Container, typename DifferenceType>
-    Slice<Container, DifferenceType> slice(
-            Container&& container,
-            DifferenceType start, DifferenceType stop, DifferenceType step=1);
-
-    template <typename Container, typename DifferenceType>
-    Slice<Container, DifferenceType> slice(
-            Container&& container, DifferenceType stop);
-
-    template <typename T, typename DifferenceType>
-    Slice<std::initializer_list<T>, DifferenceType> slice(
-            std::initializer_list<T> il, DifferenceType start,
-            DifferenceType stop, DifferenceType step=1);
-
-    template <typename T, typename DifferenceType>
-    Slice<std::initializer_list<T>, DifferenceType> slice(
-            std::initializer_list<T> il, DifferenceType stop);
-
-    template <typename Container, typename DifferenceType>
-    class Slice {
-        private:
-            Container container;
-            DifferenceType start;
-            DifferenceType stop;
-            DifferenceType step;
-
-            friend Slice slice<Container, DifferenceType>(
-                    Container&&, DifferenceType, DifferenceType,
-                    DifferenceType);
-
-            friend Slice slice<Container, DifferenceType>(
-                    Container&&, DifferenceType);
-
-            Slice(Container&& in_container, DifferenceType in_start,
-                  DifferenceType in_stop, DifferenceType in_step)
-                : container(std::forward<Container>(in_container)),
-                start{in_start < in_stop && in_step > 0 ? in_start : in_stop},
-                stop{in_stop},
-                step{in_step}
-            { }
-
-
-        public:
-            class Iterator 
-                : public std::iterator<std::input_iterator_tag,
-                    iterator_traits_deref<Container>>
-            {
-                private:
-                    iterator_type<Container> sub_iter;
-                    iterator_type<Container> sub_end;
-                    DifferenceType current;
-                    DifferenceType stop;
-                    DifferenceType step;
-
-                public:
-                    Iterator (iterator_type<Container>&& si,
-                            iterator_type<Container>&& se,
-                            DifferenceType in_start,
-                            DifferenceType in_stop,
-                            DifferenceType in_step)
-                        : sub_iter{std::move(si)},
-                        sub_end{std::move(se)},
-                        current{in_start},
-                        stop{in_stop},
-                        step{in_step}
-                    { }
-
-                    iterator_deref<Container> operator*() {
-                        return *this->sub_iter;
-                    }
-
-                    iterator_arrow<Container> operator->() {
-                        return apply_arrow(this->sub_iter);
-                    }
-
-                    Iterator& operator++() { 
-                        dumb_advance(this->sub_iter, this->sub_end,this->step);
-                        this->current += this->step;
-                        if (this->stop < this->current ) {
-                            this->current = this->stop;
-                        }
-                        return *this;
-                    }
-
-                    Iterator operator++(int) {
-                        auto ret = *this;
-                        ++*this;
-                        return ret;
-                    }
-
-                    bool operator!=(const Iterator& other) const {
-                        return this->sub_iter != other.sub_iter
-                            && this->current != other.current;
-                    }
-
-                    bool operator==(const Iterator& other) const {
-                        return !(*this != other);
-                    }
-            };
-
-            Iterator begin() {
-                auto it = std::begin(this->container);
-                dumb_advance(it, std::end(this->container), this->start);
-                return {std::move(it), std::end(this->container),
-                        this->start, this->stop, this->step};
-            }
-
-            Iterator end() {
-                return {std::end(this->container), std::end(this->container),
-                        this->stop, this->stop, this->step};
-            }
-
+  template <typename Container, typename DifferenceType>
+  class Slice;
+
+  template <typename Container, typename DifferenceType>
+  Slice<Container, DifferenceType> slice(Container&& container,
+      DifferenceType start, DifferenceType stop, DifferenceType step = 1);
+
+  template <typename Container, typename DifferenceType>
+  Slice<Container, DifferenceType> slice(
+      Container&& container, DifferenceType stop);
+
+  template <typename T, typename DifferenceType>
+  Slice<std::initializer_list<T>, DifferenceType> slice(
+      std::initializer_list<T> il, DifferenceType start, DifferenceType stop,
+      DifferenceType step = 1);
+
+  template <typename T, typename DifferenceType>
+  Slice<std::initializer_list<T>, DifferenceType> slice(
+      std::initializer_list<T> il, DifferenceType stop);
+
+  template <typename Container, typename DifferenceType>
+  class Slice {
+   private:
+    Container container;
+    DifferenceType start;
+    DifferenceType stop;
+    DifferenceType step;
+
+    friend Slice slice<Container, DifferenceType>(
+        Container&&, DifferenceType, DifferenceType, DifferenceType);
+
+    friend Slice slice<Container, DifferenceType>(Container&&, DifferenceType);
+
+    Slice(Container&& in_container, DifferenceType in_start,
+        DifferenceType in_stop, DifferenceType in_step)
+        : container(std::forward<Container>(in_container)),
+          start{in_start < in_stop && in_step > 0 ? in_start : in_stop},
+          stop{in_stop},
+          step{in_step} {}
+
+   public:
+    class Iterator : public std::iterator<std::input_iterator_tag,
+                         iterator_traits_deref<Container>> {
+     private:
+      iterator_type<Container> sub_iter;
+      iterator_type<Container> sub_end;
+      DifferenceType current;
+      DifferenceType stop;
+      DifferenceType step;
+
+     public:
+      Iterator(iterator_type<Container>&& si, iterator_type<Container>&& se,
+          DifferenceType in_start, DifferenceType in_stop,
+          DifferenceType in_step)
+          : sub_iter{std::move(si)},
+            sub_end{std::move(se)},
+            current{in_start},
+            stop{in_stop},
+            step{in_step} {}
+
+      iterator_deref<Container> operator*() {
+        return *this->sub_iter;
+      }
+
+      iterator_arrow<Container> operator->() {
+        return apply_arrow(this->sub_iter);
+      }
+
+      Iterator& operator++() {
+        dumb_advance(this->sub_iter, this->sub_end, this->step);
+        this->current += this->step;
+        if (this->stop < this->current) {
+          this->current = this->stop;
+        }
+        return *this;
+      }
+
+      Iterator operator++(int) {
+        auto ret = *this;
+        ++*this;
+        return ret;
+      }
+
+      bool operator!=(const Iterator& other) const {
+        return this->sub_iter != other.sub_iter
+               && this->current != other.current;
+      }
+
+      bool operator==(const Iterator& other) const {
+        return !(*this != other);
+      }
     };
 
-    // Helper function to instantiate a Slice
-    template <typename Container, typename DifferenceType>
-    Slice<Container, DifferenceType> slice(
-            Container&& container,
-            DifferenceType start, DifferenceType stop, DifferenceType step) {
-        return {std::forward<Container>(container), start, stop, step};
-    }
-
-    //only give the end as an arg and assume step  is 1 and begin is 0
-    template <typename Container, typename DifferenceType>
-    Slice<Container, DifferenceType> slice(
-            Container&& container, DifferenceType stop) {
-        return {std::forward<Container>(container), 0, stop, 1};
-    }
-
-    template <typename T, typename DifferenceType>
-    Slice<std::initializer_list<T>, DifferenceType> slice(
-            std::initializer_list<T> il, DifferenceType start,
-            DifferenceType stop, DifferenceType step) {
-        return {std::move(il), start, stop, step};
+    Iterator begin() {
+      auto it = std::begin(this->container);
+      dumb_advance(it, std::end(this->container), this->start);
+      return {std::move(it), std::end(this->container), this->start, this->stop,
+          this->step};
     }
 
-    template <typename T, typename DifferenceType>
-    Slice<std::initializer_list<T>, DifferenceType> slice(
-            std::initializer_list<T> il, DifferenceType stop) {
-        return {std::move(il), 0, stop, 1};
+    Iterator end() {
+      return {std::end(this->container), std::end(this->container), this->stop,
+          this->stop, this->step};
     }
+  };
+
+  // Helper function to instantiate a Slice
+  template <typename Container, typename DifferenceType>
+  Slice<Container, DifferenceType> slice(Container&& container,
+      DifferenceType start, DifferenceType stop, DifferenceType step) {
+    return {std::forward<Container>(container), start, stop, step};
+  }
+
+  // only give the end as an arg and assume step  is 1 and begin is 0
+  template <typename Container, typename DifferenceType>
+  Slice<Container, DifferenceType> slice(
+      Container&& container, DifferenceType stop) {
+    return {std::forward<Container>(container), 0, stop, 1};
+  }
+
+  template <typename T, typename DifferenceType>
+  Slice<std::initializer_list<T>, DifferenceType> slice(
+      std::initializer_list<T> il, DifferenceType start, DifferenceType stop,
+      DifferenceType step) {
+    return {std::move(il), start, stop, step};
+  }
+
+  template <typename T, typename DifferenceType>
+  Slice<std::initializer_list<T>, DifferenceType> slice(
+      std::initializer_list<T> il, DifferenceType stop) {
+    return {std::move(il), 0, stop, 1};
+  }
 }
 
 #endif
diff --git a/sliding_window.hpp b/sliding_window.hpp
index 36ab877e..aefbca30 100644
--- a/sliding_window.hpp
+++ b/sliding_window.hpp
@@ -9,116 +9,106 @@
 #include <iterator>
 
 namespace iter {
-    template <typename Container>
-    class SlidingWindow;
+  template <typename Container>
+  class SlidingWindow;
 
-    template <typename Container>
-    SlidingWindow<Container> sliding_window(Container&&, std::size_t);
+  template <typename Container>
+  SlidingWindow<Container> sliding_window(Container&&, std::size_t);
+
+  template <typename T>
+  SlidingWindow<std::initializer_list<T>> sliding_window(
+      std::initializer_list<T>, std::size_t);
+
+  template <typename Container>
+  class SlidingWindow {
+   private:
+    Container container;
+    std::size_t window_size;
+
+    friend SlidingWindow sliding_window<Container>(Container&&, std::size_t);
 
     template <typename T>
-    SlidingWindow<std::initializer_list<T>> sliding_window(
-            std::initializer_list<T>, std::size_t);
-
-    template <typename Container>
-    class SlidingWindow {
-        private: Container container;
-            std::size_t window_size;
-
-            friend SlidingWindow sliding_window<Container>(
-                    Container&&, std::size_t);
-            
-            template <typename T>
-            friend SlidingWindow<std::initializer_list<T>> sliding_window(
-                    std::initializer_list<T>, std::size_t);
-
-            SlidingWindow(Container&& in_container, std::size_t win_sz)
-                : container(std::forward<Container>(in_container)),
-                window_size{win_sz}
-            { }
-
-            using IndexVector = std::deque<iterator_type<Container>>;
-            using DerefVec = IterIterWrapper<IndexVector>;
-        public:
-
-            class Iterator
-                : public std::iterator<std::input_iterator_tag, DerefVec>
-            {
-                private:
-                    iterator_type<Container> sub_iter;
-                    DerefVec window;
-
-                public:
-                    Iterator(iterator_type<Container>&& in_iter,
-                            const iterator_type<Container>& in_end,
-                             std::size_t window_sz)
-                        : sub_iter(std::move(in_iter))
-                    {
-                        std::size_t i{0};
-                        while (i < window_sz
-                                && this->sub_iter != in_end) {
-                            this->window.get().push_back(this->sub_iter);
-                            ++i;
-                            if (i != window_sz) ++this->sub_iter;
-                        }
-                    }
-
-                    bool operator!=(const Iterator& other) const {
-                        return this->sub_iter != other.sub_iter;
-                    }
-
-                    bool operator==(const Iterator& other) const {
-                        return !(*this != other);
-                    }
-
-                    DerefVec& operator*() {
-                        return this->window;
-                    }
-
-                    DerefVec *operator->() {
-                        return this->window;
-                    }
-
-                    Iterator& operator++() {
-                        ++this->sub_iter;
-                        this->window.get().pop_front();
-                        this->window.get().push_back(this->sub_iter);
-                        return *this;
-                    }
-
-                    Iterator operator++(int) {
-                        auto ret = *this;
-                        ++*this;
-                        return ret;
-                    }
-            };
-
-            Iterator begin() {
-                return {
-                    (this->window_size != 0 ?
-                     std::begin(this->container)
-                     : std::end(this->container)),
-                    std::end(this->container),
-                    this->window_size};
-            }
-
-            Iterator end() {
-                return {std::end(this->container),
-                    std::end(this->container),
-                    this->window_size};
-            }
+    friend SlidingWindow<std::initializer_list<T>> sliding_window(
+        std::initializer_list<T>, std::size_t);
+
+    SlidingWindow(Container&& in_container, std::size_t win_sz)
+        : container(std::forward<Container>(in_container)),
+          window_size{win_sz} {}
+
+    using IndexVector = std::deque<iterator_type<Container>>;
+    using DerefVec = IterIterWrapper<IndexVector>;
+
+   public:
+    class Iterator : public std::iterator<std::input_iterator_tag, DerefVec> {
+     private:
+      iterator_type<Container> sub_iter;
+      DerefVec window;
+
+     public:
+      Iterator(iterator_type<Container>&& in_iter,
+          const iterator_type<Container>& in_end, std::size_t window_sz)
+          : sub_iter(std::move(in_iter)) {
+        std::size_t i{0};
+        while (i < window_sz && this->sub_iter != in_end) {
+          this->window.get().push_back(this->sub_iter);
+          ++i;
+          if (i != window_sz) ++this->sub_iter;
+        }
+      }
+
+      bool operator!=(const Iterator& other) const {
+        return this->sub_iter != other.sub_iter;
+      }
+
+      bool operator==(const Iterator& other) const {
+        return !(*this != other);
+      }
+
+      DerefVec& operator*() {
+        return this->window;
+      }
+
+      DerefVec* operator->() {
+        return this->window;
+      }
+
+      Iterator& operator++() {
+        ++this->sub_iter;
+        this->window.get().pop_front();
+        this->window.get().push_back(this->sub_iter);
+        return *this;
+      }
+
+      Iterator operator++(int) {
+        auto ret = *this;
+        ++*this;
+        return ret;
+      }
     };
 
-    template <typename Container>
-    SlidingWindow<Container> sliding_window(
-            Container&& container, std::size_t window_size) {
-        return {std::forward<Container>(container), window_size};
+    Iterator begin() {
+      return {(this->window_size != 0 ? std::begin(this->container)
+                                      : std::end(this->container)),
+          std::end(this->container), this->window_size};
     }
 
-    template <typename T>
-    SlidingWindow<std::initializer_list<T>> sliding_window(
-            std::initializer_list<T> il, std::size_t window_size) {
-        return {std::move(il), window_size};
+    Iterator end() {
+      return {std::end(this->container), std::end(this->container),
+          this->window_size};
     }
+  };
+
+  template <typename Container>
+  SlidingWindow<Container> sliding_window(
+      Container&& container, std::size_t window_size) {
+    return {std::forward<Container>(container), window_size};
+  }
+
+  template <typename T>
+  SlidingWindow<std::initializer_list<T>> sliding_window(
+      std::initializer_list<T> il, std::size_t window_size) {
+    return {std::move(il), window_size};
+  }
 }
 
 #endif
diff --git a/sorted.hpp b/sorted.hpp
index c68171e3..318ae415 100644
--- a/sorted.hpp
+++ b/sorted.hpp
@@ -9,72 +9,64 @@
 #include <vector>
 
 namespace iter {
-    template <typename Container>
-    class Sorted;
-
-    template <typename Container, typename CompareFunc>
-    Sorted<Container> sorted(Container&&, CompareFunc);
-
-    template <typename Container>
-    class Sorted  {
-        private:
-            using IterIterWrap =
-                IterIterWrapper<std::vector<iterator_type<Container>>>;
-            using ItIt = iterator_type<IterIterWrap>;
-
-            template <typename C, typename F>
-            friend Sorted<C> sorted(C&&, F);
-
-            Container container;
-            IterIterWrap sorted_iters;
-
-            template <typename CompareFunc>
-            Sorted(Container&& in_container, CompareFunc compare_func)
-                : container(std::forward<Container>(in_container))
-            {
-                // Fill the sorted_iters vector with an iterator to each
-                // element in the container
-                for (auto iter = std::begin(this->container);
-                        iter != std::end(this->container);
-                        ++iter) {
-                    this->sorted_iters.get().push_back(iter);
-                }
-
-                // sort by comparing the elements that the iterators point to
-                std::sort(std::begin(sorted_iters.get()),
-                        std::end(sorted_iters.get()),
-                        [compare_func] (const iterator_type<Container>& it1,
-                            const iterator_type<Container>& it2)
-                        { return compare_func(*it1, *it2); });
-            }
-
-        public:
-
-            ItIt begin() {
-                return std::begin(sorted_iters);
-                
-            }
-
-            ItIt end() {
-                return std::end(sorted_iters);
-            }
-    };
-
-    template <typename Container, typename CompareFunc>
-    Sorted<Container> sorted(
-            Container&& container, CompareFunc compare_func) {
-        return {std::forward<Container>(container), compare_func};
+  template <typename Container>
+  class Sorted;
+
+  template <typename Container, typename CompareFunc>
+  Sorted<Container> sorted(Container&&, CompareFunc);
+
+  template <typename Container>
+  class Sorted {
+   private:
+    using IterIterWrap = IterIterWrapper<std::vector<iterator_type<Container>>>;
+    using ItIt = iterator_type<IterIterWrap>;
+
+    template <typename C, typename F>
+    friend Sorted<C> sorted(C&&, F);
+
+    Container container;
+    IterIterWrap sorted_iters;
+
+    template <typename CompareFunc>
+    Sorted(Container&& in_container, CompareFunc compare_func)
+        : container(std::forward<Container>(in_container)) {
+      // Fill the sorted_iters vector with an iterator to each
+      // element in the container
+      for (auto iter = std::begin(this->container);
+           iter != std::end(this->container); ++iter) {
+        this->sorted_iters.get().push_back(iter);
+      }
+
+      // sort by comparing the elements that the iterators point to
+      std::sort(std::begin(sorted_iters.get()), std::end(sorted_iters.get()),
+          [compare_func](const iterator_type<Container>& it1,
+                    const iterator_type<Container>& it2) {
+            return compare_func(*it1, *it2);
+          });
     }
 
-    template <typename Container>
-    auto sorted(Container&& container) ->
-             decltype(sorted(std::forward<Container>(container),
-                         std::less<const_iterator_deref<Container>>()))
-     {
-         return sorted(std::forward<Container>(container),
-                 std::less<const_iterator_deref<Container>>());
-     }
+   public:
+    ItIt begin() {
+      return std::begin(sorted_iters);
+    }
 
+    ItIt end() {
+      return std::end(sorted_iters);
+    }
+  };
+
+  template <typename Container, typename CompareFunc>
+  Sorted<Container> sorted(Container&& container, CompareFunc compare_func) {
+    return {std::forward<Container>(container), compare_func};
+  }
+
+  template <typename Container>
+  auto sorted(Container&& container)
+      -> decltype(sorted(std::forward<Container>(container),
+          std::less<const_iterator_deref<Container>>())) {
+    return sorted(std::forward<Container>(container),
+        std::less<const_iterator_deref<Container>>());
+  }
 }
 
 #endif
diff --git a/takewhile.hpp b/takewhile.hpp
index 6d514327..4f09fae7 100644
--- a/takewhile.hpp
+++ b/takewhile.hpp
@@ -9,134 +9,120 @@
 
 namespace iter {
 
-    //Forward declarations of TakeWhile and takewhile
-    template <typename FilterFunc, typename Container>
-    class TakeWhile;
-
-    template <typename FilterFunc, typename Container>
-    TakeWhile<FilterFunc, Container> takewhile(FilterFunc, Container&&);
-
-    template <typename FilterFunc, typename T>
-    TakeWhile<FilterFunc, std::initializer_list<T>> takewhile(
-            FilterFunc, std::initializer_list<T>);
-
-    template <typename FilterFunc, typename Container>
-    class TakeWhile {
-        private:
-            Container container;
-            FilterFunc filter_func;
-
-            friend TakeWhile takewhile<FilterFunc, Container>(
-                    FilterFunc, Container&&);
-
-            template <typename FF, typename T>
-            friend TakeWhile<FF, std::initializer_list<T>> takewhile(
-                    FF, std::initializer_list<T>);
-
-            TakeWhile(FilterFunc in_filter_func, Container&& in_container)
-                : container(std::forward<Container>(in_container)),
-                filter_func(in_filter_func)
-            { }
-
-
-        public:
-
-            class Iterator 
-                : public std::iterator<std::input_iterator_tag,
-                    iterator_traits_deref<Container>>
-            {
-                private:
-                    using Holder = DerefHolder<iterator_deref<Container>>;
-                    iterator_type<Container> sub_iter;
-                    iterator_type<Container> sub_end;
-                    Holder item;
-                    FilterFunc *filter_func;
-
-                    void inc_sub_iter() {
-                        ++this->sub_iter;
-                        if (this->sub_iter != this->sub_end) {
-                            this->item.reset(*this->sub_iter);
-                        }
-                    }
-
-                    void check_current() {
-                        if (this->sub_iter != this->sub_end
-                                && !(*this->filter_func)(this->item.get())) {
-                            this->sub_iter = this->sub_end;
-                        }
-                    }
-
-                public:
-                    Iterator(iterator_type<Container>&& iter,
-                            iterator_type<Container>&& end,
-                            FilterFunc& in_filter_func)
-                        : sub_iter{std::move(iter)},
-                        sub_end{std::move(end)},
-                        filter_func(&in_filter_func)
-                    { 
-                        if (this->sub_iter != this->sub_end) {
-                            this->item.reset(*this->sub_iter);
-                        }
-                        this->check_current();
-                    } 
-
-                    typename Holder::reference operator*() {
-                        return this->item.get();
-                    }
-
-                    typename Holder::pointer operator->() {
-                        return this->item.get_ptr();
-                    }
-
-                    Iterator& operator++() { 
-                        this->inc_sub_iter();
-                        this->check_current();
-                        return *this;
-                    }
-
-                    Iterator operator++(int) {
-                        auto ret = *this;
-                        ++*this;
-                        return ret;
-                    }
-
-                    bool operator!=(const Iterator& other) const {
-                        return this->sub_iter != other.sub_iter;
-                    }
-
-                    bool operator==(const Iterator& other) const {
-                        return !(*this != other);
-                    }
-                
-            };
-
-            Iterator begin() {
-                return {std::begin(this->container),
-                        std::end(this->container),
-                        this->filter_func};
-            }
-
-            Iterator end() {
-                return {std::end(this->container),
-                        std::end(this->container),
-                        this->filter_func};
-            }
-
+  // Forward declarations of TakeWhile and takewhile
+  template <typename FilterFunc, typename Container>
+  class TakeWhile;
+
+  template <typename FilterFunc, typename Container>
+  TakeWhile<FilterFunc, Container> takewhile(FilterFunc, Container&&);
+
+  template <typename FilterFunc, typename T>
+  TakeWhile<FilterFunc, std::initializer_list<T>> takewhile(
+      FilterFunc, std::initializer_list<T>);
+
+  template <typename FilterFunc, typename Container>
+  class TakeWhile {
+   private:
+    Container container;
+    FilterFunc filter_func;
+
+    friend TakeWhile takewhile<FilterFunc, Container>(FilterFunc, Container&&);
+
+    template <typename FF, typename T>
+    friend TakeWhile<FF, std::initializer_list<T>> takewhile(
+        FF, std::initializer_list<T>);
+
+    TakeWhile(FilterFunc in_filter_func, Container&& in_container)
+        : container(std::forward<Container>(in_container)),
+          filter_func(in_filter_func) {}
+
+   public:
+    class Iterator : public std::iterator<std::input_iterator_tag,
+                         iterator_traits_deref<Container>> {
+     private:
+      using Holder = DerefHolder<iterator_deref<Container>>;
+      iterator_type<Container> sub_iter;
+      iterator_type<Container> sub_end;
+      Holder item;
+      FilterFunc* filter_func;
+
+      void inc_sub_iter() {
+        ++this->sub_iter;
+        if (this->sub_iter != this->sub_end) {
+          this->item.reset(*this->sub_iter);
+        }
+      }
+
+      void check_current() {
+        if (this->sub_iter != this->sub_end
+            && !(*this->filter_func)(this->item.get())) {
+          this->sub_iter = this->sub_end;
+        }
+      }
+
+     public:
+      Iterator(iterator_type<Container>&& iter, iterator_type<Container>&& end,
+          FilterFunc& in_filter_func)
+          : sub_iter{std::move(iter)},
+            sub_end{std::move(end)},
+            filter_func(&in_filter_func) {
+        if (this->sub_iter != this->sub_end) {
+          this->item.reset(*this->sub_iter);
+        }
+        this->check_current();
+      }
+
+      typename Holder::reference operator*() {
+        return this->item.get();
+      }
+
+      typename Holder::pointer operator->() {
+        return this->item.get_ptr();
+      }
+
+      Iterator& operator++() {
+        this->inc_sub_iter();
+        this->check_current();
+        return *this;
+      }
+
+      Iterator operator++(int) {
+        auto ret = *this;
+        ++*this;
+        return ret;
+      }
+
+      bool operator!=(const Iterator& other) const {
+        return this->sub_iter != other.sub_iter;
+      }
+
+      bool operator==(const Iterator& other) const {
+        return !(*this != other);
+      }
     };
 
-    template <typename FilterFunc, typename Container>
-    TakeWhile<FilterFunc, Container> takewhile(
-            FilterFunc filter_func, Container&& container) {
-        return {filter_func, std::forward<Container>(container)};
+    Iterator begin() {
+      return {std::begin(this->container), std::end(this->container),
+          this->filter_func};
     }
 
-    template <typename FilterFunc, typename T>
-    TakeWhile<FilterFunc, std::initializer_list<T>> takewhile(
-            FilterFunc filter_func, std::initializer_list<T> il)
-    {
-        return {filter_func, std::move(il)};
+    Iterator end() {
+      return {std::end(this->container), std::end(this->container),
+          this->filter_func};
     }
-
+  };
+
+  template <typename FilterFunc, typename Container>
+  TakeWhile<FilterFunc, Container> takewhile(
+      FilterFunc filter_func, Container&& container) {
+    return {filter_func, std::forward<Container>(container)};
+  }
+
+  template <typename FilterFunc, typename T>
+  TakeWhile<FilterFunc, std::initializer_list<T>> takewhile(
+      FilterFunc filter_func, std::initializer_list<T> il) {
+    return {filter_func, std::move(il)};
+  }
 }
 
 #endif
diff --git a/unique_everseen.hpp b/unique_everseen.hpp
index ec95eb34..b971ca62 100644
--- a/unique_everseen.hpp
+++ b/unique_everseen.hpp
@@ -10,48 +10,43 @@
 #include <unordered_set>
 #include <iterator>
 
-namespace iter 
-{
-    //the container type must be usable in an unordered_map to achieve constant
-    //performance checking if it has ever been seen
-    template <typename Container>
-    auto unique_everseen(Container&& container) 
-        -> Filter<std::function<bool(iterator_deref<Container>)>,Container>
-    {
-        using elem_t = iterator_deref<Container>;
-        std::unordered_set<typename std::decay<elem_t>::type> elem_seen;
+namespace iter {
+  // the container type must be usable in an unordered_map to achieve constant
+  // performance checking if it has ever been seen
+  template <typename Container>
+  auto unique_everseen(Container&& container)
+      -> Filter<std::function<bool(iterator_deref<Container>)>, Container> {
+    using elem_t = iterator_deref<Container>;
+    std::unordered_set<typename std::decay<elem_t>::type> elem_seen;
 
-        std::function<bool(elem_t)> func =
-        //has to be captured by value because it goes out of scope when the 
-        //function returns
-            [elem_seen](elem_t e) mutable
-            {
-                if (elem_seen.find(e) == std::end(elem_seen)){
-                    elem_seen.insert(e);
-                    return true;
-                } else {
-                    return false;
-                }
-            };
-        return filter(func, std::forward<Container>(container));
-    }
+    std::function<bool(elem_t)> func =
+        // has to be captured by value because it goes out of scope when the
+        // function returns
+        [elem_seen](elem_t e) mutable {
+          if (elem_seen.find(e) == std::end(elem_seen)) {
+            elem_seen.insert(e);
+            return true;
+          } else {
+            return false;
+          }
+        };
+    return filter(func, std::forward<Container>(container));
+  }
 
-    template <typename T>
-    auto unique_everseen(std::initializer_list<T> il) 
-        -> Filter<std::function<bool(T)>, std::initializer_list<T>>
-    {
-        std::unordered_set<T> elem_seen;
-        std::function<bool(T)> func = [elem_seen](const T& e) mutable
-            {
-                if (elem_seen.find(e) == std::end(elem_seen)){
-                    elem_seen.insert(e);
-                    return true;
-                } else {
-                    return false;
-                }
-            };
-        return filter(func, il);
-    }
+  template <typename T>
+  auto unique_everseen(std::initializer_list<T> il)
+      -> Filter<std::function<bool(T)>, std::initializer_list<T>> {
+    std::unordered_set<T> elem_seen;
+    std::function<bool(T)> func = [elem_seen](const T& e) mutable {
+      if (elem_seen.find(e) == std::end(elem_seen)) {
+        elem_seen.insert(e);
+        return true;
+      } else {
+        return false;
+      }
+    };
+    return filter(func, il);
+  }
 }
 
 #endif
diff --git a/unique_justseen.hpp b/unique_justseen.hpp
index 3eb39cc2..442e658e 100644
--- a/unique_justseen.hpp
+++ b/unique_justseen.hpp
@@ -10,38 +10,35 @@
 #include <initializer_list>
 #include <type_traits>
 
-namespace iter
-{
-    template <typename GroupByType>
-    struct GroupFrontGetter{
-        auto operator()(iterator_deref<GroupByType> gb) ->
-                decltype(*std::begin(gb.second)) {
-            return *std::begin(gb.second);
-        }
-    };
-
+namespace iter {
+  template <typename GroupByType>
+  struct GroupFrontGetter {
+    auto operator()(iterator_deref<GroupByType> gb)
+        -> decltype(*std::begin(gb.second)) {
+      return *std::begin(gb.second);
+    }
+  };
 
-    // gets first of each group.  since each group is decided based on equality
-    // with the previous item, this results in each item only appearing once
-    template <typename Container>
-    auto unique_justseen(Container&& container) ->
-        decltype(imap(GroupFrontGetter<decltype(
-                        groupby(std::forward<Container>(container)))>{},
-                groupby(std::forward<Container>(container)))) {
-        return imap(GroupFrontGetter<decltype(
+  // gets first of each group.  since each group is decided based on equality
+  // with the previous item, this results in each item only appearing once
+  template <typename Container>
+  auto unique_justseen(Container&& container) -> decltype(imap(
+      GroupFrontGetter<decltype(groupby(std::forward<Container>(container)))>{},
+      groupby(std::forward<Container>(container)))) {
+    return imap(GroupFrontGetter<decltype(
                     groupby(std::forward<Container>(container)))>{},
-                groupby(std::forward<Container>(container)));
-    }
+        groupby(std::forward<Container>(container)));
+  }
 
-    template <typename T>
-    auto unique_justseen(std::initializer_list<T> il) ->
-        decltype(imap(GroupFrontGetter<decltype(
-                        groupby(std::forward<std::initializer_list<T>>(il)))>{},
-                groupby(std::forward<std::initializer_list<T>>(il)))) {
-        return imap(GroupFrontGetter<decltype(
+  template <typename T>
+  auto unique_justseen(std::initializer_list<T> il)
+      -> decltype(imap(GroupFrontGetter<decltype(groupby(
+                           std::forward<std::initializer_list<T>>(il)))>{},
+          groupby(std::forward<std::initializer_list<T>>(il)))) {
+    return imap(GroupFrontGetter<decltype(
                     groupby(std::forward<std::initializer_list<T>>(il)))>{},
-                groupby(std::forward<std::initializer_list<T>>(il)));
-    }
+        groupby(std::forward<std::initializer_list<T>>(il)));
+  }
 }
 
 #endif
diff --git a/zip.hpp b/zip.hpp
index d8cf5457..f1cb9ae6 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -7,156 +7,141 @@
 #include <tuple>
 #include <utility>
 
-
 namespace iter {
-    template <typename... RestContainers>
-    class Zipped;
-
-    template <typename... Containers>
-    Zipped<Containers...> zip(Containers&&...);
-
-    // specialization for at least 1 template argument
-    template <typename Container, typename... RestContainers>
-    class Zipped <Container, RestContainers...> {
-        using ZipIterDeref =
-            std::tuple<iterator_deref<Container>,
-                iterator_deref<RestContainers>...>;
-
-        friend Zipped zip<Container, RestContainers...>(
-                Container&&, RestContainers&&...);
-
-        template <typename... RC>
-        friend class Zipped;
-
-        private:
-            Container container;
-            Zipped<RestContainers...> rest_zipped;
-            Zipped(Container&& in_container, RestContainers&&... rest)
-                : container(std::forward<Container>(in_container)),
-                rest_zipped{std::forward<RestContainers>(rest)...}
-            { }
-
-        public:
-            class Iterator :
-                public std::iterator<std::input_iterator_tag, ZipIterDeref>
-        {
-                private:
-                    using RestIter =
-                        typename Zipped<RestContainers...>::Iterator;
-
-                    iterator_type<Container> iter;
-                    RestIter rest_iter;
-                public:
-                    constexpr static const bool is_base_iter = false;
-                    Iterator(iterator_type<Container>&& it, RestIter&& rest)
-                        : iter{std::move(it)},
-                        rest_iter{std::move(rest)}
-                    { }
-
-                    Iterator& operator++() {
-                        ++this->iter;
-                        ++this->rest_iter;
-                        return *this;
-                    }
-
-                    Iterator operator++(int) {
-                        auto ret = *this;
-                        ++*this;
-                        return ret;
-                    }
-
-                    bool operator!=(const Iterator& other) const {
-                        return this->iter != other.iter &&
-                            (RestIter::is_base_iter ||
-                                this->rest_iter != other.rest_iter);
-                    }
-
-                    bool operator==(const Iterator& other) const {
-                        return !(*this != other);
-                    }
-
-                    auto operator*() ->
-                        decltype(std::tuple_cat(
-                                    std::tuple<iterator_deref<Container>>{
-                                        *this->iter},
-                                    *this->rest_iter))
-                    {
-                        return std::tuple_cat(
-                                std::tuple<iterator_deref<Container>>{
-                                    *this->iter},
-                                *this->rest_iter);
-                    }
-
-                    auto operator->() -> ArrowProxy<decltype(**this)> {
-                        return {**this};
-                    }
-
-            };
-
-            Iterator begin() {
-                return {std::begin(this->container),
-                    std::begin(this->rest_zipped)};
-            }
-
-            Iterator end() {
-                return {std::end(this->container),
-                    std::end(this->rest_zipped)};
-            }
+  template <typename... RestContainers>
+  class Zipped;
+
+  template <typename... Containers>
+  Zipped<Containers...> zip(Containers&&...);
+
+  // specialization for at least 1 template argument
+  template <typename Container, typename... RestContainers>
+  class Zipped<Container, RestContainers...> {
+    using ZipIterDeref = std::tuple<iterator_deref<Container>,
+        iterator_deref<RestContainers>...>;
+
+    friend Zipped zip<Container, RestContainers...>(
+        Container&&, RestContainers&&...);
+
+    template <typename... RC>
+    friend class Zipped;
+
+   private:
+    Container container;
+    Zipped<RestContainers...> rest_zipped;
+    Zipped(Container&& in_container, RestContainers&&... rest)
+        : container(std::forward<Container>(in_container)),
+          rest_zipped{std::forward<RestContainers>(rest)...} {}
+
+   public:
+    class Iterator
+        : public std::iterator<std::input_iterator_tag, ZipIterDeref> {
+     private:
+      using RestIter = typename Zipped<RestContainers...>::Iterator;
+
+      iterator_type<Container> iter;
+      RestIter rest_iter;
+
+     public:
+      constexpr static const bool is_base_iter = false;
+      Iterator(iterator_type<Container>&& it, RestIter&& rest)
+          : iter{std::move(it)}, rest_iter{std::move(rest)} {}
+
+      Iterator& operator++() {
+        ++this->iter;
+        ++this->rest_iter;
+        return *this;
+      }
+
+      Iterator operator++(int) {
+        auto ret = *this;
+        ++*this;
+        return ret;
+      }
+
+      bool operator!=(const Iterator& other) const {
+        return this->iter != other.iter
+               && (RestIter::is_base_iter
+                      || this->rest_iter != other.rest_iter);
+      }
+
+      bool operator==(const Iterator& other) const {
+        return !(*this != other);
+      }
+
+      auto operator*() -> decltype(
+          std::tuple_cat(std::tuple<iterator_deref<Container>>{*this->iter},
+              *this->rest_iter)) {
+        return std::tuple_cat(
+            std::tuple<iterator_deref<Container>>{*this->iter},
+            *this->rest_iter);
+      }
+
+      auto operator-> () -> ArrowProxy<decltype(**this)> {
+        return {**this};
+      }
     };
 
+    Iterator begin() {
+      return {std::begin(this->container), std::begin(this->rest_zipped)};
+    }
 
-    template <>
-    class Zipped<> {
-        public:
-            class Iterator
-                : public std::iterator<std::input_iterator_tag, std::tuple<>>
-            {
-                public:
-                    constexpr static const bool is_base_iter = true;
-
-                    Iterator& operator++() {
-                        return *this;
-                    }
-
-                    Iterator operator++(int) {
-                        return *this;
-                    }
-
-                    // if this were to return true, there would be no need
-                    // for the is_base_iter static class attribute.
-                    // However, returning false causes an empty zip() call
-                    // to reach the "end" immediately. Returning true here
-                    // instead results in an infinite loop in the zip() case
-                    bool operator!=(const Iterator&) const {
-                        return false;
-                    }
-
-                    bool operator==(const Iterator& other) const {
-                        return !(*this != other);
-                    }
-
-                    std::tuple<> operator*() {
-                        return std::tuple<>{};
-                    }
-
-                    auto operator->() -> ArrowProxy<decltype(**this)> {
-                        return {**this};
-                    }
-            };
-
-            Iterator begin() {
-                return {};
-            }
-
-            Iterator end() {
-                return {};
-            }
+    Iterator end() {
+      return {std::end(this->container), std::end(this->rest_zipped)};
+    }
+  };
+
+  template <>
+  class Zipped<> {
+   public:
+    class Iterator
+        : public std::iterator<std::input_iterator_tag, std::tuple<>> {
+     public:
+      constexpr static const bool is_base_iter = true;
+
+      Iterator& operator++() {
+        return *this;
+      }
+
+      Iterator operator++(int) {
+        return *this;
+      }
+
+      // if this were to return true, there would be no need
+      // for the is_base_iter static class attribute.
+      // However, returning false causes an empty zip() call
+      // to reach the "end" immediately. Returning true here
+      // instead results in an infinite loop in the zip() case
+      bool operator!=(const Iterator&) const {
+        return false;
+      }
+
+      bool operator==(const Iterator& other) const {
+        return !(*this != other);
+      }
+
+      std::tuple<> operator*() {
+        return std::tuple<>{};
+      }
+
+      auto operator-> () -> ArrowProxy<decltype(**this)> {
+        return {**this};
+      }
     };
 
-    template <typename... Containers>
-    Zipped<Containers...> zip(Containers&&... containers) {
-        return {std::forward<Containers>(containers)...};
+    Iterator begin() {
+      return {};
     }
+
+    Iterator end() {
+      return {};
+    }
+  };
+
+  template <typename... Containers>
+  Zipped<Containers...> zip(Containers&&... containers) {
+    return {std::forward<Containers>(containers)...};
+  }
 }
 
 #endif
diff --git a/zip_longest.hpp b/zip_longest.hpp
index 937602df..b7bff0ae 100644
--- a/zip_longest.hpp
+++ b/zip_longest.hpp
@@ -8,163 +8,146 @@
 #include <tuple>
 #include <utility>
 
-
 namespace iter {
 
-    template <typename Container>
-    using OptIterDeref = boost::optional<iterator_deref<Container>>;
-
-    template <typename... RestContainers>
-    class ZippedLongest;
-
-    template <typename... Containers>
-    ZippedLongest<Containers...> zip_longest(Containers&&...);
-
-    template <typename Container, typename... RestContainers>
-    class ZippedLongest <Container, RestContainers...> {
-        static_assert(!std::is_rvalue_reference<Container>::value,
-                "Itertools cannot be templated with rvalue references");
-
-        friend ZippedLongest zip_longest<Container, RestContainers...>(
-                Container&&, RestContainers&&...);
-
-        template <typename... Cs>
-        friend class ZippedLongest;
-
-        private:
-            using OptType = OptIterDeref<Container>;
-            using ZipIterDeref =
-                std::tuple<OptType, OptIterDeref<RestContainers>...>;
-
-            Container container;
-            ZippedLongest<RestContainers...> rest_zipped;
-            ZippedLongest(Container&& in_container, RestContainers&&... rest)
-                : container(std::forward<Container>(in_container)),
-                rest_zipped{std::forward<RestContainers>(rest)...}
-            { }
-
-        public:
-            class Iterator
-                : public std::iterator<std::input_iterator_tag, ZipIterDeref>
-            {
-                private:
-                    using RestIter =
-                        typename ZippedLongest<RestContainers...>::Iterator;
-
-                    iterator_type<Container> iter;
-                    iterator_type<Container> end;
-                    RestIter rest_iter;
-
-                public:
-                    Iterator(
-                            iterator_type<Container>&& it,
-                            iterator_type<Container>&& in_end,
-                            RestIter&& rest)
-                        : iter{std::move(it)},
-                        end{std::move(in_end)},
-                        rest_iter{std::move(rest)}
-                    { }
-
-                    Iterator& operator++() {
-                        if (this->iter != this->end) {
-                            ++this->iter;
-                        }
-                        ++this->rest_iter;
-                        return *this;
-                    }
-
-                    Iterator operator++(int) {
-                        auto ret = *this;
-                        ++*this;
-                        return ret;
-                    }
-
-                    bool operator!=(const Iterator& other) const {
-                        return this->iter != other.iter ||
-                            this->rest_iter != other.rest_iter;
-                    }
-
-                    bool operator==(const Iterator& other) const {
-                        return !(*this != other);
-                    }
-
-                    ZipIterDeref operator*() {
-                        if (this->iter != this->end) {
-                            return std::tuple_cat(
-                                    std::tuple<OptType>{{*this->iter}},
-                                    *this->rest_iter);
-                        } else {
-                            return std::tuple_cat(
-                                    std::tuple<OptType>{{}},
-                                    *this->rest_iter);
-                        }
-                    }
-
-                    ArrowProxy<ZipIterDeref> operator->() {
-                        return {**this};
-                    }
-
-            };
-
-            Iterator begin() {
-                return {std::begin(this->container),
-                    std::end(this->container),
-                    std::begin(this->rest_zipped)};
-            }
-
-            Iterator end() {
-                return {std::end(this->container),
-                    std::end(this->container),
-                    std::end(this->rest_zipped)};
-            }
+  template <typename Container>
+  using OptIterDeref = boost::optional<iterator_deref<Container>>;
+
+  template <typename... RestContainers>
+  class ZippedLongest;
+
+  template <typename... Containers>
+  ZippedLongest<Containers...> zip_longest(Containers&&...);
+
+  template <typename Container, typename... RestContainers>
+  class ZippedLongest<Container, RestContainers...> {
+    static_assert(!std::is_rvalue_reference<Container>::value,
+        "Itertools cannot be templated with rvalue references");
+
+    friend ZippedLongest zip_longest<Container, RestContainers...>(
+        Container&&, RestContainers&&...);
+
+    template <typename... Cs>
+    friend class ZippedLongest;
+
+   private:
+    using OptType = OptIterDeref<Container>;
+    using ZipIterDeref = std::tuple<OptType, OptIterDeref<RestContainers>...>;
+
+    Container container;
+    ZippedLongest<RestContainers...> rest_zipped;
+    ZippedLongest(Container&& in_container, RestContainers&&... rest)
+        : container(std::forward<Container>(in_container)),
+          rest_zipped{std::forward<RestContainers>(rest)...} {}
+
+   public:
+    class Iterator
+        : public std::iterator<std::input_iterator_tag, ZipIterDeref> {
+     private:
+      using RestIter = typename ZippedLongest<RestContainers...>::Iterator;
+
+      iterator_type<Container> iter;
+      iterator_type<Container> end;
+      RestIter rest_iter;
+
+     public:
+      Iterator(iterator_type<Container>&& it, iterator_type<Container>&& in_end,
+          RestIter&& rest)
+          : iter{std::move(it)},
+            end{std::move(in_end)},
+            rest_iter{std::move(rest)} {}
+
+      Iterator& operator++() {
+        if (this->iter != this->end) {
+          ++this->iter;
+        }
+        ++this->rest_iter;
+        return *this;
+      }
+
+      Iterator operator++(int) {
+        auto ret = *this;
+        ++*this;
+        return ret;
+      }
+
+      bool operator!=(const Iterator& other) const {
+        return this->iter != other.iter || this->rest_iter != other.rest_iter;
+      }
+
+      bool operator==(const Iterator& other) const {
+        return !(*this != other);
+      }
+
+      ZipIterDeref operator*() {
+        if (this->iter != this->end) {
+          return std::tuple_cat(
+              std::tuple<OptType>{{*this->iter}}, *this->rest_iter);
+        } else {
+          return std::tuple_cat(std::tuple<OptType>{{}}, *this->rest_iter);
+        }
+      }
+
+      ArrowProxy<ZipIterDeref> operator->() {
+        return {**this};
+      }
     };
 
+    Iterator begin() {
+      return {std::begin(this->container), std::end(this->container),
+          std::begin(this->rest_zipped)};
+    }
 
-    template <>
-    class ZippedLongest<> {
-        public:
-            class Iterator
-                : public std::iterator<std::input_iterator_tag, std::tuple<>> 
-            {
-                public:
-                    Iterator& operator++() {
-                        return *this;
-                    }
-
-                    constexpr Iterator operator++(int) const {
-                        return *this;
-                    }
-
-                    constexpr bool operator!=(const Iterator&) const {
-                        return false;
-                    }
-
-                    constexpr bool operator==(const Iterator&) const {
-                        return true;
-                    }
-
-                    constexpr std::tuple<> operator*() const {
-                        return {};
-                    }
-
-                    constexpr ArrowProxy<std::tuple<>> operator->() const {
-                        return {{}};
-                    }
-            };
-
-            constexpr Iterator begin() const {
-                return {};
-            }
-
-            constexpr Iterator end() const {
-                return {};
-            }
+    Iterator end() {
+      return {std::end(this->container), std::end(this->container),
+          std::end(this->rest_zipped)};
+    }
+  };
+
+  template <>
+  class ZippedLongest<> {
+   public:
+    class Iterator
+        : public std::iterator<std::input_iterator_tag, std::tuple<>> {
+     public:
+      Iterator& operator++() {
+        return *this;
+      }
+
+      constexpr Iterator operator++(int) const {
+        return *this;
+      }
+
+      constexpr bool operator!=(const Iterator&) const {
+        return false;
+      }
+
+      constexpr bool operator==(const Iterator&) const {
+        return true;
+      }
+
+      constexpr std::tuple<> operator*() const {
+        return {};
+      }
+
+      constexpr ArrowProxy<std::tuple<>> operator->() const {
+        return {{}};
+      }
     };
 
-    template <typename... Containers>
-    ZippedLongest<Containers...> zip_longest(Containers&&... containers) {
-        return {std::forward<Containers>(containers)...};
+    constexpr Iterator begin() const {
+      return {};
     }
+
+    constexpr Iterator end() const {
+      return {};
+    }
+  };
+
+  template <typename... Containers>
+  ZippedLongest<Containers...> zip_longest(Containers&&... containers) {
+    return {std::forward<Containers>(containers)...};
+  }
 }
 
 #endif

From 9de886f172487993bd620ccbfa4e11a03ace7353 Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Wed, 19 Aug 2015 21:59:13 -0700
Subject: [PATCH 1221/1866] omits unused template parameter names

---
 zip.hpp         | 2 +-
 zip_longest.hpp | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/zip.hpp b/zip.hpp
index f1cb9ae6..038808df 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -23,7 +23,7 @@ namespace iter {
     friend Zipped zip<Container, RestContainers...>(
         Container&&, RestContainers&&...);
 
-    template <typename... RC>
+    template <typename...>
     friend class Zipped;
 
    private:
diff --git a/zip_longest.hpp b/zip_longest.hpp
index b7bff0ae..7029bb50 100644
--- a/zip_longest.hpp
+++ b/zip_longest.hpp
@@ -27,7 +27,7 @@ namespace iter {
     friend ZippedLongest zip_longest<Container, RestContainers...>(
         Container&&, RestContainers&&...);
 
-    template <typename... Cs>
+    template <typename...>
     friend class ZippedLongest;
 
    private:

From c1bdd4b088a761dcc127f3c90289a1fb578ae624 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Wed, 19 Aug 2015 23:33:10 -0700
Subject: [PATCH 1222/1866] moves Accumulator into impl{ }

---
 accumulate.hpp | 199 +++++++++++++++++++++++++------------------------
 1 file changed, 100 insertions(+), 99 deletions(-)

diff --git a/accumulate.hpp b/accumulate.hpp
index 672212f6..c91319e8 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -11,126 +11,133 @@
 #include <memory>
 
 namespace iter {
-
-  // Forward declarations of Accumulator and accumulate
-  template <typename Container, typename AccumulateFunc>
-  class Accumulator;
+  namespace impl {
+    template <typename Container, typename AccumulateFunc>
+    class Accumulator;
+  }
 
   template <typename Container, typename AccumulateFunc>
-  Accumulator<Container, AccumulateFunc> accumulate(
+  impl::Accumulator<Container, AccumulateFunc> accumulate(
       Container&&, AccumulateFunc);
 
   template <typename T, typename AccumulateFunc>
-  Accumulator<std::initializer_list<T>, AccumulateFunc> accumulate(
+  impl::Accumulator<std::initializer_list<T>, AccumulateFunc> accumulate(
       std::initializer_list<T>, AccumulateFunc);
+}
 
-  template <typename Container, typename AccumulateFunc>
-  class Accumulator {
-   private:
-    Container container;
-    AccumulateFunc accumulate_func;
+template <typename Container, typename AccumulateFunc>
+class iter::impl::Accumulator {
+ private:
+  Container container;
+  AccumulateFunc accumulate_func;
 
-    friend Accumulator accumulate<Container, AccumulateFunc>(
-        Container&&, AccumulateFunc);
+  friend Accumulator iter::accumulate<Container, AccumulateFunc>(
+      Container&&, AccumulateFunc);
 
-    template <typename T, typename AF>
-    friend Accumulator<std::initializer_list<T>, AF> accumulate(
-        std::initializer_list<T>, AF);
+  template <typename T, typename AF>
+  friend Accumulator<std::initializer_list<T>, AF> iter::accumulate(
+      std::initializer_list<T>, AF);
 
-    // AccumVal must be default constructible
-    using AccumVal =
-        typename std::remove_reference<typename std::result_of<AccumulateFunc(
-            iterator_deref<Container>, iterator_deref<Container>)>::type>::type;
+  // AccumVal must be default constructible
+  using AccumVal =
+      typename std::remove_reference<typename std::result_of<AccumulateFunc(
+          iterator_deref<Container>, iterator_deref<Container>)>::type>::type;
 
-    Accumulator(Container&& in_container, AccumulateFunc in_accumulate_func)
-        : container(std::forward<Container>(in_container)),
-          accumulate_func(in_accumulate_func) {}
+  Accumulator(Container&& in_container, AccumulateFunc in_accumulate_func)
+      : container(std::forward<Container>(in_container)),
+        accumulate_func(in_accumulate_func) {}
 
-   public:
-    class Iterator : public std::iterator<std::input_iterator_tag, AccumVal> {
-     private:
-      iterator_type<Container> sub_iter;
-      iterator_type<Container> sub_end;
-      AccumulateFunc* accumulate_func;
-      std::unique_ptr<AccumVal> acc_val;
-
-     public:
-      Iterator(iterator_type<Container>&& iter, iterator_type<Container>&& end,
-          AccumulateFunc in_accumulate_func)
-          : sub_iter{std::move(iter)},
-            sub_end{std::move(end)},
-            accumulate_func(&in_accumulate_func),
-            // only get first value if not an end iterator
-            acc_val{!(iter != end) ? nullptr : new AccumVal(*iter)} {}
-
-      Iterator(const Iterator& other)
-          : sub_iter{other.sub_iter},
-            sub_end{other.sub_end},
-            accumulate_func{other.accumulate_func},
-            acc_val{other.acc_val ? new AccumVal(*other.acc_val) : nullptr} {}
-
-      Iterator& operator=(const Iterator& other) {
-        if (this == &other) return *this;
-        this->sub_iter = other.sub_iter;
-        this->sub_end = other.sub_end;
-        this->accumulate_func = other.accumulate_func;
-        this->acc_val.reset(
-            other.acc_val ? new AccumVal(*other.acc_val) : nullptr);
-        return *this;
-      }
-
-      Iterator(Iterator&&) = default;
-      Iterator& operator=(Iterator&&) = default;
+ public:
+  class Iterator : public std::iterator<std::input_iterator_tag, AccumVal> {
+   private:
+    iterator_type<Container> sub_iter;
+    iterator_type<Container> sub_end;
+    AccumulateFunc* accumulate_func;
+    std::unique_ptr<AccumVal> acc_val;
 
-      const AccumVal& operator*() const {
-        return *this->acc_val;
-      }
+   public:
+    Iterator(iterator_type<Container>&& iter, iterator_type<Container>&& end,
+        AccumulateFunc in_accumulate_func)
+        : sub_iter{std::move(iter)},
+          sub_end{std::move(end)},
+          accumulate_func(&in_accumulate_func),
+          // only get first value if not an end iterator
+          acc_val{!(iter != end) ? nullptr : new AccumVal(*iter)} {}
+
+    Iterator(const Iterator& other)
+        : sub_iter{other.sub_iter},
+          sub_end{other.sub_end},
+          accumulate_func{other.accumulate_func},
+          acc_val{other.acc_val ? new AccumVal(*other.acc_val) : nullptr} {}
+
+    Iterator& operator=(const Iterator& other) {
+      if (this == &other) return *this;
+      this->sub_iter = other.sub_iter;
+      this->sub_end = other.sub_end;
+      this->accumulate_func = other.accumulate_func;
+      this->acc_val.reset(
+          other.acc_val ? new AccumVal(*other.acc_val) : nullptr);
+      return *this;
+    }
 
-      const AccumVal* operator->() const {
-        return this->acc_val.get();
-      }
+    Iterator(Iterator&&) = default;
+    Iterator& operator=(Iterator&&) = default;
 
-      Iterator& operator++() {
-        ++this->sub_iter;
-        if (this->sub_iter != this->sub_end) {
-          *this->acc_val = (*accumulate_func)(*this->acc_val, *this->sub_iter);
-        }
-        return *this;
-      }
+    const AccumVal& operator*() const {
+      return *this->acc_val;
+    }
 
-      Iterator operator++(int) {
-        auto ret = *this;
-        ++*this;
-        return ret;
-      }
+    const AccumVal* operator->() const {
+      return this->acc_val.get();
+    }
 
-      bool operator!=(const Iterator& other) const {
-        return this->sub_iter != other.sub_iter;
+    Iterator& operator++() {
+      ++this->sub_iter;
+      if (this->sub_iter != this->sub_end) {
+        *this->acc_val = (*accumulate_func)(*this->acc_val, *this->sub_iter);
       }
+      return *this;
+    }
 
-      bool operator==(const Iterator& other) const {
-        return !(*this != other);
-      }
-    };
+    Iterator operator++(int) {
+      auto ret = *this;
+      ++*this;
+      return ret;
+    }
 
-    Iterator begin() {
-      return {std::begin(this->container), std::end(this->container),
-          this->accumulate_func};
+    bool operator!=(const Iterator& other) const {
+      return this->sub_iter != other.sub_iter;
     }
 
-    Iterator end() {
-      return {std::end(this->container), std::end(this->container),
-          this->accumulate_func};
+    bool operator==(const Iterator& other) const {
+      return !(*this != other);
     }
   };
 
-  // Helper function to instantiate an Accumulator
-  template <typename Container, typename AccumulateFunc>
-  Accumulator<Container, AccumulateFunc> accumulate(
-      Container&& container, AccumulateFunc accumulate_func) {
-    return {std::forward<Container>(container), accumulate_func};
+  Iterator begin() {
+    return {std::begin(this->container), std::end(this->container),
+        this->accumulate_func};
+  }
+
+  Iterator end() {
+    return {std::end(this->container), std::end(this->container),
+        this->accumulate_func};
   }
+};
 
+template <typename Container, typename AccumulateFunc>
+iter::impl::Accumulator<Container, AccumulateFunc> iter::accumulate(
+    Container&& container, AccumulateFunc accumulate_func) {
+  return {std::forward<Container>(container), accumulate_func};
+}
+
+template <typename T, typename AccumulateFunc>
+iter::impl::Accumulator<std::initializer_list<T>, AccumulateFunc>
+iter::accumulate(std::initializer_list<T> il, AccumulateFunc accumulate_func) {
+  return {std::move(il), accumulate_func};
+}
+
+namespace iter {
   template <typename Container>
   auto accumulate(Container&& container) -> decltype(accumulate(
       std::forward<Container>(container),
@@ -142,12 +149,6 @@ namespace iter {
             typename std::remove_reference<iterator_deref<Container>>::type>{});
   }
 
-  template <typename T, typename AccumulateFunc>
-  Accumulator<std::initializer_list<T>, AccumulateFunc> accumulate(
-      std::initializer_list<T> il, AccumulateFunc accumulate_func) {
-    return {std::move(il), accumulate_func};
-  }
-
   template <typename T>
   auto accumulate(std::initializer_list<T> il)
       -> decltype(accumulate(std::move(il), std::plus<T>{})) {

From b27c6ff408de3246b9610542a696470eb8e892e5 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Wed, 19 Aug 2015 23:33:31 -0700
Subject: [PATCH 1223/1866] moves Enumerable into impl { }

---
 enumerate.hpp | 162 +++++++++++++++++++++++++-------------------------
 1 file changed, 82 insertions(+), 80 deletions(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index c43996f7..f8cbc37e 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -10,105 +10,107 @@
 #include <type_traits>
 
 namespace iter {
+  namespace impl {
+    template <typename Container>
+    class Enumerable;
+  }
 
-  // Forward declarations of Enumerable and enumerate
   template <typename Container>
-  class Enumerable;
+  impl::Enumerable<Container> enumerate(Container&&);
 
-  template <typename Container>
-  Enumerable<Container> enumerate(Container&&);
+  template <typename T>
+  impl::Enumerable<std::initializer_list<T>> enumerate(
+      std::initializer_list<T>);
+}
+
+template <typename Container>
+class iter::impl::Enumerable {
+ private:
+  Container container;
 
+  // The only thing allowed to directly instantiate an Enumerable is
+  // the enumerate function
+  friend Enumerable iter::enumerate<Container>(Container&&);
   template <typename T>
-  Enumerable<std::initializer_list<T>> enumerate(std::initializer_list<T>);
+  friend Enumerable<std::initializer_list<T>> iter::enumerate(
+      std::initializer_list<T>);
 
-  template <typename Container>
-  class Enumerable {
-   private:
-    Container container;
+  // for IterYield
+  using BasePair = std::pair<std::size_t, iterator_deref<Container>>;
 
-    // The only thing allowed to directly instantiate an Enumerable is
-    // the enumerate function
-    friend Enumerable enumerate<Container>(Container&&);
-    template <typename T>
-    friend Enumerable<std::initializer_list<T>> enumerate(
-        std::initializer_list<T>);
+  // Value constructor for use only in the enumerate function
+  Enumerable(Container&& in_container)
+      : container(std::forward<Container>(in_container)) {}
 
-    // for IterYield
-    using BasePair = std::pair<std::size_t, iterator_deref<Container>>;
+ public:
+  // "yielded" by the Enumerable::Iterator.  Has a .index, and a
+  // .element referencing the value yielded by the subiterator
+  class IterYield : public BasePair {
+   public:
+    using BasePair::BasePair;
+    typename BasePair::first_type& index = BasePair::first;
+    typename BasePair::second_type& element = BasePair::second;
+  };
 
-    // Value constructor for use only in the enumerate function
-    Enumerable(Container&& in_container)
-        : container(std::forward<Container>(in_container)) {}
+  //  Holds an iterator of the contained type and a size_t for the
+  //  index.  Each call to ++ increments both of these data members.
+  //  Each dereference returns an IterYield.
+  class Iterator : public std::iterator<std::input_iterator_tag, IterYield> {
+   private:
+    iterator_type<Container> sub_iter;
+    std::size_t index;
 
    public:
-    // "yielded" by the Enumerable::Iterator.  Has a .index, and a
-    // .element referencing the value yielded by the subiterator
-    class IterYield : public BasePair {
-     public:
-      using BasePair::BasePair;
-      typename BasePair::first_type& index = BasePair::first;
-      typename BasePair::second_type& element = BasePair::second;
-    };
-
-    //  Holds an iterator of the contained type and a size_t for the
-    //  index.  Each call to ++ increments both of these data members.
-    //  Each dereference returns an IterYield.
-    class Iterator : public std::iterator<std::input_iterator_tag, IterYield> {
-     private:
-      iterator_type<Container> sub_iter;
-      std::size_t index;
-
-     public:
-      Iterator(iterator_type<Container>&& si)
-          : sub_iter{std::move(si)}, index{0} {}
-
-      IterYield operator*() {
-        return {this->index, *this->sub_iter};
-      }
-
-      ArrowProxy<IterYield> operator->() {
-        return {**this};
-      }
-
-      Iterator& operator++() {
-        ++this->sub_iter;
-        ++this->index;
-        return *this;
-      }
-
-      Iterator operator++(int) {
-        auto ret = *this;
-        ++*this;
-        return ret;
-      }
-
-      bool operator!=(const Iterator& other) const {
-        return this->sub_iter != other.sub_iter;
-      }
-
-      bool operator==(const Iterator& other) const {
-        return !(*this != other);
-      }
-    };
-
-    Iterator begin() {
-      return {std::begin(this->container)};
+    Iterator(iterator_type<Container>&& si)
+        : sub_iter{std::move(si)}, index{0} {}
+
+    IterYield operator*() {
+      return {this->index, *this->sub_iter};
+    }
+
+    ArrowProxy<IterYield> operator->() {
+      return {**this};
+    }
+
+    Iterator& operator++() {
+      ++this->sub_iter;
+      ++this->index;
+      return *this;
+    }
+
+    Iterator operator++(int) {
+      auto ret = *this;
+      ++*this;
+      return ret;
+    }
+
+    bool operator!=(const Iterator& other) const {
+      return this->sub_iter != other.sub_iter;
     }
 
-    Iterator end() {
-      return {std::end(this->container)};
+    bool operator==(const Iterator& other) const {
+      return !(*this != other);
     }
   };
 
-  template <typename Container>
-  Enumerable<Container> enumerate(Container&& container) {
-    return {std::forward<Container>(container)};
+  Iterator begin() {
+    return {std::begin(this->container)};
   }
 
-  template <typename T>
-  Enumerable<std::initializer_list<T>> enumerate(std::initializer_list<T> il) {
-    return {std::move(il)};
+  Iterator end() {
+    return {std::end(this->container)};
   }
+};
+
+template <typename Container>
+iter::impl::Enumerable<Container> iter::enumerate(Container&& container) {
+  return {std::forward<Container>(container)};
+}
+
+template <typename T>
+iter::impl::Enumerable<std::initializer_list<T>> iter::enumerate(
+    std::initializer_list<T> il) {
+  return {std::move(il)};
 }
 
 #endif

From f48d5dd834a91bacd8908977b5fd770d025a0a85 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 20 Aug 2015 09:17:55 -0700
Subject: [PATCH 1224/1866] moves all chain details into impl { }

Chained<A, B...>, Chained<A>, ChainedFromIterable, and ChainMaker
---
 chain.hpp | 484 ++++++++++++++++++++++++++++--------------------------
 1 file changed, 247 insertions(+), 237 deletions(-)

diff --git a/chain.hpp b/chain.hpp
index c2a7db9a..7c5308ea 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -10,293 +10,303 @@
 #include <type_traits>
 
 namespace iter {
-  // rather than a chain function, use a callable object to support
-  // from_iterable
-  class ChainMaker;
-
-  template <typename Container, typename... RestContainers>
-  class Chained {
-    static_assert(are_same<iterator_deref<Container>,
-                      iterator_deref<RestContainers>...>::value,
-        "All chained iterables must have iterators that "
-        "dereference to the same type, including cv-qualifiers "
-        "and references.");
-
-    friend class ChainMaker;
-    template <typename C, typename... RC>
-    friend class Chained;
+  namespace impl {
+    template <typename Container, typename... RestContainers>
+    class Chained;
 
+    template <typename Container>
+    class Chained<Container>;
+
+    template <typename Container>
+    class ChainedFromIterable;
+
+    // rather than a chain function, use a callable object to support
+    // .from_iterable()
+    class ChainMaker;
+  }
+
+  extern const impl::ChainMaker chain;
+}
+
+template <typename Container, typename... RestContainers>
+class iter::impl::Chained {
+  static_assert(are_same<iterator_deref<Container>,
+                    iterator_deref<RestContainers>...>::value,
+      "All chained iterables must have iterators that "
+      "dereference to the same type, including cv-qualifiers "
+      "and references.");
+
+  friend class ChainMaker;
+  template <typename, typename...>
+  friend class Chained;
+
+ private:
+  Container container;
+  Chained<RestContainers...> rest_chained;
+  Chained(Container&& in_container, RestContainers&&... rest)
+      : container(std::forward<Container>(in_container)),
+        rest_chained{std::forward<RestContainers>(rest)...} {}
+
+ public:
+  class Iterator : public std::iterator<std::input_iterator_tag,
+                       iterator_traits_deref<Container>> {
    private:
-    Container container;
-    Chained<RestContainers...> rest_chained;
-    Chained(Container&& in_container, RestContainers&&... rest)
-        : container(std::forward<Container>(in_container)),
-          rest_chained{std::forward<RestContainers>(rest)...} {}
+    using RestIter = typename Chained<RestContainers...>::Iterator;
+    iterator_type<Container> sub_iter;
+    iterator_type<Container> sub_end;
+    RestIter rest_iter;
+    bool at_end;
 
    public:
-    class Iterator : public std::iterator<std::input_iterator_tag,
-                         iterator_traits_deref<Container>> {
-     private:
-      using RestIter = typename Chained<RestContainers...>::Iterator;
-      iterator_type<Container> sub_iter;
-      iterator_type<Container> sub_end;
-      RestIter rest_iter;
-      bool at_end;
-
-     public:
-      Iterator(iterator_type<Container>&& s_begin,
-          iterator_type<Container>&& s_end, RestIter&& in_rest_iter)
-          : sub_iter{std::move(s_begin)},
-            sub_end{std::move(s_end)},
-            rest_iter{std::move(in_rest_iter)},
-            at_end{!(sub_iter != sub_end)} {}
-
-      Iterator& operator++() {
-        if (this->at_end) {
-          ++this->rest_iter;
-        } else {
-          ++this->sub_iter;
-          if (!(this->sub_iter != this->sub_end)) {
-            this->at_end = true;
-          }
+    Iterator(iterator_type<Container>&& s_begin,
+        iterator_type<Container>&& s_end, RestIter&& in_rest_iter)
+        : sub_iter{std::move(s_begin)},
+          sub_end{std::move(s_end)},
+          rest_iter{std::move(in_rest_iter)},
+          at_end{!(sub_iter != sub_end)} {}
+
+    Iterator& operator++() {
+      if (this->at_end) {
+        ++this->rest_iter;
+      } else {
+        ++this->sub_iter;
+        if (!(this->sub_iter != this->sub_end)) {
+          this->at_end = true;
         }
-        return *this;
-      }
-
-      Iterator operator++(int) {
-        auto ret = *this;
-        ++*this;
-        return ret;
-      }
-
-      bool operator!=(const Iterator& other) const {
-        return this->sub_iter != other.sub_iter
-               || this->rest_iter != other.rest_iter;
       }
+      return *this;
+    }
 
-      bool operator==(const Iterator& other) const {
-        return !(*this != other);
-      }
+    Iterator operator++(int) {
+      auto ret = *this;
+      ++*this;
+      return ret;
+    }
 
-      iterator_deref<Container> operator*() {
-        return this->at_end ? *this->rest_iter : *this->sub_iter;
-      }
+    bool operator!=(const Iterator& other) const {
+      return this->sub_iter != other.sub_iter
+             || this->rest_iter != other.rest_iter;
+    }
 
-      iterator_arrow<Container> operator->() {
-        return this->at_end ? apply_arrow(this->rest_iter)
-                            : apply_arrow(this->sub_iter);
-      }
-    };
+    bool operator==(const Iterator& other) const {
+      return !(*this != other);
+    }
 
-    Iterator begin() {
-      return {std::begin(this->container), std::end(this->container),
-          std::begin(this->rest_chained)};
+    iterator_deref<Container> operator*() {
+      return this->at_end ? *this->rest_iter : *this->sub_iter;
     }
 
-    Iterator end() {
-      return {std::end(this->container), std::end(this->container),
-          std::end(this->rest_chained)};
+    iterator_arrow<Container> operator->() {
+      return this->at_end ? apply_arrow(this->rest_iter)
+                          : apply_arrow(this->sub_iter);
     }
   };
-  template <typename Container>
-  class Chained<Container> {
-    friend class ChainMaker;
-    template <typename C, typename... RC>
-    friend class Chained;
 
+  Iterator begin() {
+    return {std::begin(this->container), std::end(this->container),
+        std::begin(this->rest_chained)};
+  }
+
+  Iterator end() {
+    return {std::end(this->container), std::end(this->container),
+        std::end(this->rest_chained)};
+  }
+};
+template <typename Container>
+class iter::impl::Chained<Container> {
+  friend class ChainMaker;
+  template <typename, typename...>
+  friend class Chained;
+
+ private:
+  Container container;
+  Chained(Container&& in_container)
+      : container(std::forward<Container>(in_container)) {}
+
+ public:
+  class Iterator : public std::iterator<std::input_iterator_tag,
+                       iterator_traits_deref<Container>> {
    private:
-    Container container;
-    Chained(Container&& in_container)
-        : container(std::forward<Container>(in_container)) {}
+    iterator_type<Container> sub_iter;
+    iterator_type<Container> sub_end;
 
    public:
-    class Iterator : public std::iterator<std::input_iterator_tag,
-                         iterator_traits_deref<Container>> {
-     private:
-      iterator_type<Container> sub_iter;
-      iterator_type<Container> sub_end;
-
-     public:
-      Iterator(const iterator_type<Container>& s_begin,
-          const iterator_type<Container>& s_end)
-          : sub_iter{s_begin}, sub_end{s_end} {}
-
-      Iterator& operator++() {
-        ++this->sub_iter;
-        return *this;
-      }
-
-      Iterator operator++(int) {
-        auto ret = *this;
-        ++*this;
-        return ret;
-      }
+    Iterator(const iterator_type<Container>& s_begin,
+        const iterator_type<Container>& s_end)
+        : sub_iter{s_begin}, sub_end{s_end} {}
 
-      bool operator!=(const Iterator& other) const {
-        return this->sub_iter != other.sub_iter;
-      }
+    Iterator& operator++() {
+      ++this->sub_iter;
+      return *this;
+    }
 
-      bool operator==(const Iterator& other) const {
-        return !(*this != other);
-      }
+    Iterator operator++(int) {
+      auto ret = *this;
+      ++*this;
+      return ret;
+    }
 
-      iterator_deref<Container> operator*() {
-        return *this->sub_iter;
-      }
+    bool operator!=(const Iterator& other) const {
+      return this->sub_iter != other.sub_iter;
+    }
 
-      iterator_arrow<Container> operator->() {
-        return apply_arrow(this->sub_iter);
-      }
-    };
+    bool operator==(const Iterator& other) const {
+      return !(*this != other);
+    }
 
-    Iterator begin() {
-      return {std::begin(this->container), std::end(this->container)};
+    iterator_deref<Container> operator*() {
+      return *this->sub_iter;
     }
 
-    Iterator end() {
-      return {std::end(this->container), std::end(this->container)};
+    iterator_arrow<Container> operator->() {
+      return apply_arrow(this->sub_iter);
     }
   };
 
-  template <typename Container>
-  class ChainedFromIterable {
+  Iterator begin() {
+    return {std::begin(this->container), std::end(this->container)};
+  }
+
+  Iterator end() {
+    return {std::end(this->container), std::end(this->container)};
+  }
+};
+
+template <typename Container>
+class iter::impl::ChainedFromIterable {
+ private:
+  Container container;
+  friend class ChainMaker;
+  ChainedFromIterable(Container&& in_container)
+      : container(std::forward<Container>(in_container)) {}
+
+ public:
+  class Iterator : public std::iterator<std::input_iterator_tag,
+                       iterator_traits_deref<iterator_deref<Container>>> {
    private:
-    Container container;
-    friend class ChainMaker;
-    ChainedFromIterable(Container&& in_container)
-        : container(std::forward<Container>(in_container)) {}
+    using SubContainer = iterator_deref<Container>;
+    using SubIter = iterator_type<SubContainer>;
 
-   public:
-    class Iterator : public std::iterator<std::input_iterator_tag,
-                         iterator_traits_deref<iterator_deref<Container>>> {
-     private:
-      using SubContainer = iterator_deref<Container>;
-      using SubIter = iterator_type<SubContainer>;
-
-      iterator_type<Container> top_level_iter;
-      iterator_type<Container> top_level_end;
-      std::unique_ptr<SubIter> sub_iter_p;
-      std::unique_ptr<SubIter> sub_end_p;
-
-      static std::unique_ptr<SubIter> clone_sub_pointer(
-          const SubIter* sub_iter) {
-        return std::unique_ptr<SubIter>{
-            sub_iter ? new SubIter{*sub_iter} : nullptr};
-      }
+    iterator_type<Container> top_level_iter;
+    iterator_type<Container> top_level_end;
+    std::unique_ptr<SubIter> sub_iter_p;
+    std::unique_ptr<SubIter> sub_end_p;
 
-      bool sub_iters_differ(const Iterator& other) const {
-        if (this->sub_iter_p == other.sub_iter_p) {
-          return false;
-        }
-        if (this->sub_iter_p == nullptr || other.sub_iter_p == nullptr) {
-          // since the first check tests if they're the same,
-          // this will return if only one is nullptr
-          return true;
-        }
-        return *this->sub_iter_p != *other.sub_iter_p;
-      }
+    static std::unique_ptr<SubIter> clone_sub_pointer(const SubIter* sub_iter) {
+      return std::unique_ptr<SubIter>{
+          sub_iter ? new SubIter{*sub_iter} : nullptr};
+    }
 
-     public:
-      Iterator(iterator_type<Container>&& top_iter,
-          iterator_type<Container>&& top_end)
-          : top_level_iter{std::move(top_iter)},
-            top_level_end{std::move(top_end)},
-            sub_iter_p{!(top_iter != top_end)
-                           ?  // iter == end ?
-                           nullptr
-                           : new SubIter{std::begin(*top_iter)}},
-            sub_end_p{!(top_iter != top_end)
-                          ?  // iter == end ?
-                          nullptr
-                          : new SubIter{std::end(*top_iter)}} {}
-
-      Iterator(const Iterator& other)
-          : top_level_iter{other.top_level_iter},
-            top_level_end{other.top_level_end},
-            sub_iter_p{clone_sub_pointer(other.sub_iter_p.get())},
-            sub_end_p{clone_sub_pointer(other.sub_end_p.get())} {}
-
-      Iterator& operator=(const Iterator& other) {
-        if (this == &other) return *this;
-
-        this->top_level_iter = other.top_level_iter;
-        this->top_level_end = other.top_level_end;
-        this->sub_iter_p = clone_sub_pointer(other.sub_iter_p.get());
-        this->sub_end_p = clone_sub_pointer(other.sub_end_p.get());
-
-        return *this;
+    bool sub_iters_differ(const Iterator& other) const {
+      if (this->sub_iter_p == other.sub_iter_p) {
+        return false;
       }
-
-      Iterator(Iterator&&) = default;
-      Iterator& operator=(Iterator&&) = default;
-      ~Iterator() = default;
-
-      Iterator& operator++() {
-        ++*this->sub_iter_p;
-        if (!(*this->sub_iter_p != *this->sub_end_p)) {
-          ++this->top_level_iter;
-          if (this->top_level_iter != this->top_level_end) {
-            sub_iter_p.reset(new SubIter{std::begin(*this->top_level_iter)});
-            sub_end_p.reset(new SubIter{std::end(*this->top_level_iter)});
-          } else {
-            sub_iter_p.reset(nullptr);
-            sub_end_p.reset(nullptr);
-          }
-        }
-        return *this;
+      if (this->sub_iter_p == nullptr || other.sub_iter_p == nullptr) {
+        // since the first check tests if they're the same,
+        // this will return if only one is nullptr
+        return true;
       }
+      return *this->sub_iter_p != *other.sub_iter_p;
+    }
 
-      Iterator operator++(int) {
-        auto ret = *this;
-        ++*this;
-        return ret;
-      }
+   public:
+    Iterator(
+        iterator_type<Container>&& top_iter, iterator_type<Container>&& top_end)
+        : top_level_iter{std::move(top_iter)},
+          top_level_end{std::move(top_end)},
+          sub_iter_p{!(top_iter != top_end)
+                         ?  // iter == end ?
+                         nullptr
+                         : new SubIter{std::begin(*top_iter)}},
+          sub_end_p{!(top_iter != top_end) ?  // iter == end ?
+                        nullptr
+                                           : new SubIter{std::end(*top_iter)}} {
+    }
 
-      bool operator!=(const Iterator& other) const {
-        return this->top_level_iter != other.top_level_iter
-               || this->sub_iters_differ(other);
-      }
+    Iterator(const Iterator& other)
+        : top_level_iter{other.top_level_iter},
+          top_level_end{other.top_level_end},
+          sub_iter_p{clone_sub_pointer(other.sub_iter_p.get())},
+          sub_end_p{clone_sub_pointer(other.sub_end_p.get())} {}
 
-      bool operator==(const Iterator& other) const {
-        return !(*this != other);
-      }
+    Iterator& operator=(const Iterator& other) {
+      if (this == &other) return *this;
 
-      iterator_deref<iterator_deref<Container>> operator*() {
-        return **this->sub_iter_p;
-      }
+      this->top_level_iter = other.top_level_iter;
+      this->top_level_end = other.top_level_end;
+      this->sub_iter_p = clone_sub_pointer(other.sub_iter_p.get());
+      this->sub_end_p = clone_sub_pointer(other.sub_end_p.get());
 
-      iterator_arrow<iterator_deref<Container>> operator->() {
-        return apply_arrow(*this->sub_iter_p);
+      return *this;
+    }
+
+    Iterator(Iterator&&) = default;
+    Iterator& operator=(Iterator&&) = default;
+    ~Iterator() = default;
+
+    Iterator& operator++() {
+      ++*this->sub_iter_p;
+      if (!(*this->sub_iter_p != *this->sub_end_p)) {
+        ++this->top_level_iter;
+        if (this->top_level_iter != this->top_level_end) {
+          sub_iter_p.reset(new SubIter{std::begin(*this->top_level_iter)});
+          sub_end_p.reset(new SubIter{std::end(*this->top_level_iter)});
+        } else {
+          sub_iter_p.reset(nullptr);
+          sub_end_p.reset(nullptr);
+        }
       }
-    };
+      return *this;
+    }
 
-    Iterator begin() {
-      return {std::begin(this->container), std::end(this->container)};
+    Iterator operator++(int) {
+      auto ret = *this;
+      ++*this;
+      return ret;
     }
 
-    Iterator end() {
-      return {std::end(this->container), std::end(this->container)};
+    bool operator!=(const Iterator& other) const {
+      return this->top_level_iter != other.top_level_iter
+             || this->sub_iters_differ(other);
     }
-  };
 
-  class ChainMaker {
-   public:
-    // expose regular call operator to provide usual chain()
-    template <typename... Containers>
-    Chained<Containers...> operator()(Containers&&... cs) const {
-      return {std::forward<Containers>(cs)...};
+    bool operator==(const Iterator& other) const {
+      return !(*this != other);
     }
 
-    // chain.from_iterable
-    template <typename Container>
-    ChainedFromIterable<Container> from_iterable(Container&& container) const {
-      return {std::forward<Container>(container)};
+    iterator_deref<iterator_deref<Container>> operator*() {
+      return **this->sub_iter_p;
+    }
+
+    iterator_arrow<iterator_deref<Container>> operator->() {
+      return apply_arrow(*this->sub_iter_p);
     }
   };
 
-  namespace {
-    constexpr auto chain = ChainMaker{};
+  Iterator begin() {
+    return {std::begin(this->container), std::end(this->container)};
   }
-}
+
+  Iterator end() {
+    return {std::end(this->container), std::end(this->container)};
+  }
+};
+
+class iter::impl::ChainMaker {
+ public:
+  // expose regular call operator to provide usual chain()
+  template <typename... Containers>
+  Chained<Containers...> operator()(Containers&&... cs) const {
+    return {std::forward<Containers>(cs)...};
+  }
+
+  // chain.from_iterable()
+  template <typename Container>
+  ChainedFromIterable<Container> from_iterable(Container&& container) const {
+    return {std::forward<Container>(container)};
+  }
+};
+
+constexpr iter::impl::ChainMaker iter::chain{};
 
 #endif

From 2cea1fc939eccbf62b2330cb2c27fd81c8ebe430 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 20 Aug 2015 09:22:16 -0700
Subject: [PATCH 1225/1866] moves Combinator into impl { }

---
 combinations.hpp | 202 ++++++++++++++++++++++++-----------------------
 1 file changed, 102 insertions(+), 100 deletions(-)

diff --git a/combinations.hpp b/combinations.hpp
index 74b93829..83be1851 100644
--- a/combinations.hpp
+++ b/combinations.hpp
@@ -10,139 +10,141 @@
 #include <initializer_list>
 
 namespace iter {
-  template <typename Container>
-  class Combinator;
+  namespace impl {
+    template <typename Container>
+    class Combinator;
+  }
 
   template <typename Container>
-  Combinator<Container> combinations(Container&&, std::size_t);
+  impl::Combinator<Container> combinations(Container&&, std::size_t);
 
   template <typename T>
-  Combinator<std::initializer_list<T>> combinations(
+  impl::Combinator<std::initializer_list<T>> combinations(
       std::initializer_list<T>, std::size_t);
+}
 
-  template <typename Container>
-  class Combinator {
-   private:
-    Container container;
-    std::size_t length;
+template <typename Container>
+class iter::impl::Combinator {
+ private:
+  Container container;
+  std::size_t length;
 
-    friend Combinator combinations<Container>(Container&&, std::size_t);
-    template <typename T>
-    friend Combinator<std::initializer_list<T>> combinations(
-        std::initializer_list<T>, std::size_t);
+  friend Combinator iter::combinations<Container>(Container&&, std::size_t);
+  template <typename T>
+  friend Combinator<std::initializer_list<T>> iter::combinations(
+      std::initializer_list<T>, std::size_t);
 
-    Combinator(Container&& in_container, std::size_t in_length)
-        : container(std::forward<Container>(in_container)), length{in_length} {}
+  Combinator(Container&& in_container, std::size_t in_length)
+      : container(std::forward<Container>(in_container)), length{in_length} {}
 
-    using IndexVector = std::vector<iterator_type<Container>>;
-    using CombIteratorDeref = IterIterWrapper<IndexVector>;
+  using IndexVector = std::vector<iterator_type<Container>>;
+  using CombIteratorDeref = IterIterWrapper<IndexVector>;
+
+ public:
+  class Iterator
+      : public std::iterator<std::input_iterator_tag, CombIteratorDeref> {
+   private:
+    constexpr static const int COMPLETE = -1;
+    typename std::remove_reference<Container>::type* container_p;
+    CombIteratorDeref indices;
+    int steps{};
 
    public:
-    class Iterator
-        : public std::iterator<std::input_iterator_tag, CombIteratorDeref> {
-     private:
-      constexpr static const int COMPLETE = -1;
-      typename std::remove_reference<Container>::type* container_p;
-      CombIteratorDeref indices;
-      int steps{};
-
-     public:
-      Iterator(Container& in_container, std::size_t n)
-          : container_p{&in_container}, indices{n} {
-        if (n == 0) {
+    Iterator(Container& in_container, std::size_t n)
+        : container_p{&in_container}, indices{n} {
+      if (n == 0) {
+        this->steps = COMPLETE;
+        return;
+      }
+      size_t inc = 0;
+      for (auto& iter : this->indices.get()) {
+        auto it = std::begin(*this->container_p);
+        dumb_advance(it, std::end(*this->container_p), inc);
+        if (it != std::end(*this->container_p)) {
+          iter = it;
+          ++inc;
+        } else {
           this->steps = COMPLETE;
-          return;
-        }
-        size_t inc = 0;
-        for (auto& iter : this->indices.get()) {
-          auto it = std::begin(*this->container_p);
-          dumb_advance(it, std::end(*this->container_p), inc);
-          if (it != std::end(*this->container_p)) {
-            iter = it;
-            ++inc;
-          } else {
-            this->steps = COMPLETE;
-            break;
-          }
+          break;
         }
       }
+    }
 
-      CombIteratorDeref& operator*() {
-        return this->indices;
-      }
+    CombIteratorDeref& operator*() {
+      return this->indices;
+    }
 
-      CombIteratorDeref* operator->() {
-        return &this->indices;
-      }
+    CombIteratorDeref* operator->() {
+      return &this->indices;
+    }
 
-      Iterator& operator++() {
-        for (auto iter = indices.get().rbegin(); iter != indices.get().rend();
-             ++iter) {
-          ++(*iter);
-
-          // what we have to check here is if the distance between
-          // the index and the end of indices is >= the distance
-          // between the item and end of item
-          auto dist = std::distance(this->indices.get().rbegin(), iter);
-
-          if (!(dumb_next(*iter, dist) != std::end(*this->container_p))) {
-            if ((iter + 1) != indices.get().rend()) {
-              size_t inc = 1;
-              for (auto down = iter; down != indices.get().rbegin() - 1;
-                   --down) {
-                (*down) = dumb_next(*(iter + 1), 1 + inc);
-                ++inc;
-              }
-            } else {
-              this->steps = COMPLETE;
-              break;
+    Iterator& operator++() {
+      for (auto iter = indices.get().rbegin(); iter != indices.get().rend();
+           ++iter) {
+        ++(*iter);
+
+        // what we have to check here is if the distance between
+        // the index and the end of indices is >= the distance
+        // between the item and end of item
+        auto dist = std::distance(this->indices.get().rbegin(), iter);
+
+        if (!(dumb_next(*iter, dist) != std::end(*this->container_p))) {
+          if ((iter + 1) != indices.get().rend()) {
+            size_t inc = 1;
+            for (auto down = iter; down != indices.get().rbegin() - 1; --down) {
+              (*down) = dumb_next(*(iter + 1), 1 + inc);
+              ++inc;
             }
           } else {
+            this->steps = COMPLETE;
             break;
           }
-          // we break because none of the rest of the items need
-          // to be incremented
-        }
-        if (this->steps != COMPLETE) {
-          ++this->steps;
+        } else {
+          break;
         }
-        return *this;
+        // we break because none of the rest of the items need
+        // to be incremented
       }
-
-      Iterator operator++(int) {
-        auto ret = *this;
-        ++*this;
-        return ret;
-      }
-
-      bool operator!=(const Iterator& other) const {
-        return !(*this == other);
+      if (this->steps != COMPLETE) {
+        ++this->steps;
       }
+      return *this;
+    }
 
-      bool operator==(const Iterator& other) const {
-        return this->steps == other.steps;
-      }
-    };
+    Iterator operator++(int) {
+      auto ret = *this;
+      ++*this;
+      return ret;
+    }
 
-    Iterator begin() {
-      return {this->container, this->length};
+    bool operator!=(const Iterator& other) const {
+      return !(*this == other);
     }
 
-    Iterator end() {
-      return {this->container, 0};
+    bool operator==(const Iterator& other) const {
+      return this->steps == other.steps;
     }
   };
 
-  template <typename Container>
-  Combinator<Container> combinations(
-      Container&& container, std::size_t length) {
-    return {std::forward<Container>(container), length};
+  Iterator begin() {
+    return {this->container, this->length};
   }
 
-  template <typename T>
-  Combinator<std::initializer_list<T>> combinations(
-      std::initializer_list<T> il, std::size_t length) {
-    return {std::move(il), length};
+  Iterator end() {
+    return {this->container, 0};
   }
+};
+
+template <typename Container>
+iter::impl::Combinator<Container> iter::combinations(
+    Container&& container, std::size_t length) {
+  return {std::forward<Container>(container), length};
+}
+
+template <typename T>
+iter::impl::Combinator<std::initializer_list<T>> iter::combinations(
+    std::initializer_list<T> il, std::size_t length) {
+  return {std::move(il), length};
 }
+
 #endif

From 75478b90707255ee205fb4510598100d3daf6b10 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 20 Aug 2015 09:24:49 -0700
Subject: [PATCH 1226/1866] moves CombinatorWithReplacement into impl { }

---
 combinations_with_replacement.hpp | 173 +++++++++++++++---------------
 1 file changed, 87 insertions(+), 86 deletions(-)

diff --git a/combinations_with_replacement.hpp b/combinations_with_replacement.hpp
index d579d8ef..64c139ba 100644
--- a/combinations_with_replacement.hpp
+++ b/combinations_with_replacement.hpp
@@ -10,123 +10,124 @@
 #include <initializer_list>
 
 namespace iter {
+  namespace impl {
+    template <typename Container>
+    class CombinatorWithReplacement;
+  }
 
   template <typename Container>
-  class CombinatorWithReplacement;
-
-  template <typename Container>
-  CombinatorWithReplacement<Container> combinations_with_replacement(
+  impl::CombinatorWithReplacement<Container> combinations_with_replacement(
       Container&&, std::size_t);
 
   template <typename T>
-  CombinatorWithReplacement<std::initializer_list<T>>
+  impl::CombinatorWithReplacement<std::initializer_list<T>>
       combinations_with_replacement(std::initializer_list<T>, std::size_t);
+}
 
-  template <typename Container>
-  class CombinatorWithReplacement {
-   private:
-    Container container;
-    std::size_t length;
+template <typename Container>
+class iter::impl::CombinatorWithReplacement {
+ private:
+  Container container;
+  std::size_t length;
 
-    friend CombinatorWithReplacement combinations_with_replacement<Container>(
-        Container&&, std::size_t);
-    template <typename T>
-    friend CombinatorWithReplacement<std::initializer_list<T>>
-        combinations_with_replacement(std::initializer_list<T>, std::size_t);
+  friend CombinatorWithReplacement
+  iter::combinations_with_replacement<Container>(Container&&, std::size_t);
+  template <typename T>
+  friend CombinatorWithReplacement<std::initializer_list<T>>
+      iter::combinations_with_replacement(
+          std::initializer_list<T>, std::size_t);
 
-    CombinatorWithReplacement(Container&& in_container, std::size_t n)
-        : container(std::forward<Container>(in_container)), length{n} {}
+  CombinatorWithReplacement(Container&& in_container, std::size_t n)
+      : container(std::forward<Container>(in_container)), length{n} {}
 
-    using IndexVector = std::vector<iterator_type<Container>>;
-    using CombIteratorDeref = IterIterWrapper<IndexVector>;
+  using IndexVector = std::vector<iterator_type<Container>>;
+  using CombIteratorDeref = IterIterWrapper<IndexVector>;
+
+ public:
+  class Iterator
+      : public std::iterator<std::input_iterator_tag, CombIteratorDeref> {
+   private:
+    constexpr static const int COMPLETE = -1;
+    typename std::remove_reference<Container>::type* container_p;
+    CombIteratorDeref indices;
+    int steps;
 
    public:
-    class Iterator
-        : public std::iterator<std::input_iterator_tag, CombIteratorDeref> {
-     private:
-      constexpr static const int COMPLETE = -1;
-      typename std::remove_reference<Container>::type* container_p;
-      CombIteratorDeref indices;
-      int steps;
-
-     public:
-      Iterator(Container& in_container, std::size_t n)
-          : container_p{&in_container},
-            indices(n, std::begin(in_container)),
-            steps{(std::begin(in_container) != std::end(in_container) && n)
-                      ? 0
-                      : COMPLETE} {}
-
-      CombIteratorDeref& operator*() {
-        return this->indices;
-      }
+    Iterator(Container& in_container, std::size_t n)
+        : container_p{&in_container},
+          indices(n, std::begin(in_container)),
+          steps{(std::begin(in_container) != std::end(in_container) && n)
+                    ? 0
+                    : COMPLETE} {}
+
+    CombIteratorDeref& operator*() {
+      return this->indices;
+    }
 
-      CombIteratorDeref* operator->() {
-        return &this->indices;
-      }
+    CombIteratorDeref* operator->() {
+      return &this->indices;
+    }
 
-      Iterator& operator++() {
-        for (auto iter = indices.get().rbegin(); iter != indices.get().rend();
-             ++iter) {
-          ++(*iter);
-          if (!(*iter != std::end(*this->container_p))) {
-            if ((iter + 1) != indices.get().rend()) {
-              for (auto down = iter; down != indices.get().rbegin() - 1;
-                   --down) {
-                (*down) = dumb_next(*(iter + 1));
-              }
-            } else {
-              this->steps = COMPLETE;
-              break;
+    Iterator& operator++() {
+      for (auto iter = indices.get().rbegin(); iter != indices.get().rend();
+           ++iter) {
+        ++(*iter);
+        if (!(*iter != std::end(*this->container_p))) {
+          if ((iter + 1) != indices.get().rend()) {
+            for (auto down = iter; down != indices.get().rbegin() - 1; --down) {
+              (*down) = dumb_next(*(iter + 1));
             }
           } else {
-            // we break because none of the rest of the items
-            // need to be incremented
+            this->steps = COMPLETE;
             break;
           }
+        } else {
+          // we break because none of the rest of the items
+          // need to be incremented
+          break;
         }
-        if (this->steps != COMPLETE) {
-          ++this->steps;
-        }
-        return *this;
-      }
-
-      Iterator operator++(int) {
-        auto ret = *this;
-        ++*this;
-        return ret;
       }
-
-      bool operator!=(const Iterator& other) const {
-        return !(*this == other);
+      if (this->steps != COMPLETE) {
+        ++this->steps;
       }
+      return *this;
+    }
 
-      bool operator==(const Iterator& other) const {
-        return this->steps == other.steps;
-      }
-    };
+    Iterator operator++(int) {
+      auto ret = *this;
+      ++*this;
+      return ret;
+    }
 
-    Iterator begin() {
-      return {this->container, this->length};
+    bool operator!=(const Iterator& other) const {
+      return !(*this == other);
     }
 
-    Iterator end() {
-      return {this->container, 0};
+    bool operator==(const Iterator& other) const {
+      return this->steps == other.steps;
     }
   };
 
-  template <typename Container>
-  CombinatorWithReplacement<Container> combinations_with_replacement(
-      Container&& container, std::size_t length) {
-    return {std::forward<Container>(container), length};
+  Iterator begin() {
+    return {this->container, this->length};
   }
 
-  template <typename T>
-  CombinatorWithReplacement<std::initializer_list<T>>
-  combinations_with_replacement(
-      std::initializer_list<T> il, std::size_t length) {
-    return {std::move(il), length};
+  Iterator end() {
+    return {this->container, 0};
   }
+};
+
+template <typename Container>
+iter::impl::CombinatorWithReplacement<Container>
+iter::combinations_with_replacement(Container&& container, std::size_t length) {
+  return {std::forward<Container>(container), length};
+}
+
+template <typename T>
+iter::impl::CombinatorWithReplacement<std::initializer_list<T>>
+iter::combinations_with_replacement(
+    std::initializer_list<T> il, std::size_t length) {
+  return {std::move(il), length};
 }
 
 #endif

From dc360f824bf8d18667f10cab6e80697e1c7a1038 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 20 Aug 2015 09:39:46 -0700
Subject: [PATCH 1227/1866] moves Compressed into impl { }

---
 compress.hpp | 220 +++++++++++++++++++++++++--------------------------
 1 file changed, 109 insertions(+), 111 deletions(-)

diff --git a/compress.hpp b/compress.hpp
index 5089228d..d6ef8096 100644
--- a/compress.hpp
+++ b/compress.hpp
@@ -8,156 +8,154 @@
 #include <initializer_list>
 
 namespace iter {
-
-  // Forward declarations of Compressed and compress
-  template <typename Container, typename Selector>
-  class Compressed;
+  namespace impl {
+    template <typename Container, typename Selector>
+    class Compressed;
+  }
 
   template <typename Container, typename Selector>
-  Compressed<Container, Selector> compress(Container&&, Selector&&);
+  impl::Compressed<Container, Selector> compress(Container&&, Selector&&);
 
   template <typename T, typename Selector>
-  Compressed<std::initializer_list<T>, Selector> compress(
+  impl::Compressed<std::initializer_list<T>, Selector> compress(
       std::initializer_list<T>, Selector&&);
 
   template <typename Container, typename T>
-  Compressed<Container, std::initializer_list<T>> compress(
+  impl::Compressed<Container, std::initializer_list<T>> compress(
       Container&&, std::initializer_list<T>);
 
   template <typename T, typename U>
-  Compressed<std::initializer_list<T>, std::initializer_list<U>> compress(
+  impl::Compressed<std::initializer_list<T>, std::initializer_list<U>> compress(
       std::initializer_list<T>, std::initializer_list<U>);
+}
 
-  template <typename Container, typename Selector>
-  class Compressed {
-   private:
-    Container container;
-    Selector selectors;
+template <typename Container, typename Selector>
+class iter::impl::Compressed {
+ private:
+  Container container;
+  Selector selectors;
 
-    // The only thing allowed to directly instantiate an Compressed is
-    // the compress function
-    friend Compressed compress<Container, Selector>(Container&&, Selector&&);
+  friend Compressed iter::compress<Container, Selector>(
+      Container&&, Selector&&);
 
-    template <typename T, typename Sel>
-    friend Compressed<std::initializer_list<T>, Sel> compress(
-        std::initializer_list<T>, Sel&&);
+  template <typename T, typename Sel>
+  friend Compressed<std::initializer_list<T>, Sel> iter::compress(
+      std::initializer_list<T>, Sel&&);
 
-    template <typename Con, typename T>
-    friend Compressed<Con, std::initializer_list<T>> compress(
-        Con&&, std::initializer_list<T>);
+  template <typename Con, typename T>
+  friend Compressed<Con, std::initializer_list<T>> iter::compress(
+      Con&&, std::initializer_list<T>);
 
-    template <typename T, typename U>
-    friend Compressed<std::initializer_list<T>, std::initializer_list<U>>
-        compress(std::initializer_list<T>, std::initializer_list<U>);
+  template <typename T, typename U>
+  friend Compressed<std::initializer_list<T>, std::initializer_list<U>>
+      iter::compress(std::initializer_list<T>, std::initializer_list<U>);
 
-    // Selector::Iterator type
-    using selector_iter_type = decltype(std::begin(selectors));
+  // Selector::Iterator type
+  using selector_iter_type = decltype(std::begin(selectors));
 
-    // Value constructor for use only in the compress function
-    Compressed(Container&& in_container, Selector&& in_selectors)
-        : container(std::forward<Container>(in_container)),
-          selectors(std::forward<Selector>(in_selectors)) {}
+  Compressed(Container&& in_container, Selector&& in_selectors)
+      : container(std::forward<Container>(in_container)),
+        selectors(std::forward<Selector>(in_selectors)) {}
 
-   public:
-    class Iterator : public std::iterator<std::input_iterator_tag,
-                         iterator_traits_deref<Container>> {
-     private:
-      iterator_type<Container> sub_iter;
-      iterator_type<Container> sub_end;
-
-      selector_iter_type selector_iter;
-      selector_iter_type selector_end;
-
-      void increment_iterators() {
-        ++this->sub_iter;
-        ++this->selector_iter;
-      }
+ public:
+  class Iterator : public std::iterator<std::input_iterator_tag,
+                       iterator_traits_deref<Container>> {
+   private:
+    iterator_type<Container> sub_iter;
+    iterator_type<Container> sub_end;
 
-      void skip_failures() {
-        while (this->sub_iter != this->sub_end
-               && this->selector_iter != this->selector_end
-               && !*this->selector_iter) {
-          this->increment_iterators();
-        }
-      }
+    selector_iter_type selector_iter;
+    selector_iter_type selector_end;
 
-     public:
-      Iterator(iterator_type<Container>&& cont_iter,
-          iterator_type<Container>&& cont_end, selector_iter_type&& sel_iter,
-          selector_iter_type&& sel_end)
-          : sub_iter{std::move(cont_iter)},
-            sub_end{std::move(cont_end)},
-            selector_iter{std::move(sel_iter)},
-            selector_end{std::move(sel_end)} {
-        this->skip_failures();
-      }
+    void increment_iterators() {
+      ++this->sub_iter;
+      ++this->selector_iter;
+    }
 
-      iterator_deref<Container> operator*() {
-        return *this->sub_iter;
+    void skip_failures() {
+      while (this->sub_iter != this->sub_end
+             && this->selector_iter != this->selector_end
+             && !*this->selector_iter) {
+        this->increment_iterators();
       }
+    }
 
-      iterator_arrow<Container> operator->() {
-        return apply_arrow(this->sub_iter);
-      }
+   public:
+    Iterator(iterator_type<Container>&& cont_iter,
+        iterator_type<Container>&& cont_end, selector_iter_type&& sel_iter,
+        selector_iter_type&& sel_end)
+        : sub_iter{std::move(cont_iter)},
+          sub_end{std::move(cont_end)},
+          selector_iter{std::move(sel_iter)},
+          selector_end{std::move(sel_end)} {
+      this->skip_failures();
+    }
 
-      Iterator& operator++() {
-        this->increment_iterators();
-        this->skip_failures();
-        return *this;
-      }
+    iterator_deref<Container> operator*() {
+      return *this->sub_iter;
+    }
 
-      Iterator operator++(int) {
-        auto ret = *this;
-        ++*this;
-        return ret;
-      }
+    iterator_arrow<Container> operator->() {
+      return apply_arrow(this->sub_iter);
+    }
 
-      bool operator!=(const Iterator& other) const {
-        return this->sub_iter != other.sub_iter
-               && this->selector_iter != other.selector_iter;
-      }
+    Iterator& operator++() {
+      this->increment_iterators();
+      this->skip_failures();
+      return *this;
+    }
 
-      bool operator==(const Iterator& other) const {
-        return !(*this != other);
-      }
-    };
+    Iterator operator++(int) {
+      auto ret = *this;
+      ++*this;
+      return ret;
+    }
 
-    Iterator begin() {
-      return {std::begin(this->container), std::end(this->container),
-          std::begin(this->selectors), std::end(this->selectors)};
+    bool operator!=(const Iterator& other) const {
+      return this->sub_iter != other.sub_iter
+             && this->selector_iter != other.selector_iter;
     }
 
-    Iterator end() {
-      return {std::end(this->container), std::end(this->container),
-          std::end(this->selectors), std::end(this->selectors)};
+    bool operator==(const Iterator& other) const {
+      return !(*this != other);
     }
   };
 
-  // Helper function to instantiate an Compressed
-  template <typename Container, typename Selector>
-  Compressed<Container, Selector> compress(
-      Container&& container, Selector&& selectors) {
-    return {
-        std::forward<Container>(container), std::forward<Selector>(selectors)};
+  Iterator begin() {
+    return {std::begin(this->container), std::end(this->container),
+        std::begin(this->selectors), std::end(this->selectors)};
   }
 
-  template <typename T, typename Selector>
-  Compressed<std::initializer_list<T>, Selector> compress(
-      std::initializer_list<T> data, Selector&& selectors) {
-    return {std::move(data), std::forward<Selector>(selectors)};
+  Iterator end() {
+    return {std::end(this->container), std::end(this->container),
+        std::end(this->selectors), std::end(this->selectors)};
   }
+};
 
-  template <typename Container, typename T>
-  Compressed<Container, std::initializer_list<T>> compress(
-      Container&& container, std::initializer_list<T> selectors) {
-    return {std::forward<Container>(container), std::move(selectors)};
-  }
+template <typename Container, typename Selector>
+iter::impl::Compressed<Container, Selector> iter::compress(
+    Container&& container, Selector&& selectors) {
+  return {
+      std::forward<Container>(container), std::forward<Selector>(selectors)};
+}
 
-  template <typename T, typename U>
-  Compressed<std::initializer_list<T>, std::initializer_list<U>> compress(
-      std::initializer_list<T> data, std::initializer_list<U> selectors) {
-    return {std::move(data), std::move(selectors)};
-  }
+template <typename T, typename Selector>
+iter::impl::Compressed<std::initializer_list<T>, Selector> iter::compress(
+    std::initializer_list<T> data, Selector&& selectors) {
+  return {std::move(data), std::forward<Selector>(selectors)};
+}
+
+template <typename Container, typename T>
+iter::impl::Compressed<Container, std::initializer_list<T>> iter::compress(
+    Container&& container, std::initializer_list<T> selectors) {
+  return {std::forward<Container>(container), std::move(selectors)};
+}
+
+template <typename T, typename U>
+iter::impl::Compressed<std::initializer_list<T>, std::initializer_list<U>>
+iter::compress(
+    std::initializer_list<T> data, std::initializer_list<U> selectors) {
+  return {std::move(data), std::move(selectors)};
 }
 
 #endif

From 209424b8c0cbf9ccbda8f9fd0493e8533500bcf6 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 20 Aug 2015 21:04:30 -0700
Subject: [PATCH 1228/1866] moves Cycler into impl { }

---
 cycle.hpp | 125 +++++++++++++++++++++++++++---------------------------
 1 file changed, 63 insertions(+), 62 deletions(-)

diff --git a/cycle.hpp b/cycle.hpp
index 84e0c314..07356032 100644
--- a/cycle.hpp
+++ b/cycle.hpp
@@ -8,92 +8,93 @@
 #include <initializer_list>
 
 namespace iter {
+  namespace impl {
+    template <typename Container>
+    class Cycler;
+  }
 
   template <typename Container>
-  class Cycle;
+  impl::Cycler<Container> cycle(Container&&);
 
-  template <typename Container>
-  Cycle<Container> cycle(Container&&);
+  template <typename T>
+  impl::Cycler<std::initializer_list<T>> cycle(std::initializer_list<T>);
+}
 
+template <typename Container>
+class iter::impl::Cycler {
+ private:
+  friend Cycler iter::cycle<Container>(Container&&);
   template <typename T>
-  Cycle<std::initializer_list<T>> cycle(std::initializer_list<T>);
+  friend Cycler<std::initializer_list<T>> iter::cycle(std::initializer_list<T>);
 
-  template <typename Container>
-  class Cycle {
-   private:
-    friend Cycle cycle<Container>(Container&&);
-    template <typename T>
-    friend Cycle<std::initializer_list<T>> cycle(std::initializer_list<T>);
+  Container container;
 
-    Container container;
+  Cycler(Container&& in_container)
+      : container(std::forward<Container>(in_container)) {}
 
-    Cycle(Container&& in_container)
-        : container(std::forward<Container>(in_container)) {}
+ public:
+  class Iterator : public std::iterator<std::input_iterator_tag,
+                       iterator_traits_deref<Container>> {
+   private:
+    iterator_type<Container> sub_iter;
+    iterator_type<Container> begin;
+    iterator_type<Container> end;
 
    public:
-    class Iterator : public std::iterator<std::input_iterator_tag,
-                         iterator_traits_deref<Container>> {
-     private:
-      using iter_type = iterator_type<Container>;
-      iterator_type<Container> sub_iter;
-      iterator_type<Container> begin;
-      iterator_type<Container> end;
-
-     public:
-      Iterator(const iterator_type<Container>& iter,
-          iterator_type<Container>&& in_end)
-          : sub_iter{iter}, begin{iter}, end{std::move(in_end)} {}
-
-      iterator_deref<Container> operator*() {
-        return *this->sub_iter;
-      }
+    Iterator(
+        const iterator_type<Container>& iter, iterator_type<Container>&& in_end)
+        : sub_iter{iter}, begin{iter}, end{std::move(in_end)} {}
 
-      iterator_arrow<Container> operator->() {
-        return apply_arrow(this->sub_iter);
-      }
-
-      Iterator& operator++() {
-        ++this->sub_iter;
-        // reset to beginning upon reaching the end
-        if (!(this->sub_iter != this->end)) {
-          this->sub_iter = this->begin;
-        }
-        return *this;
-      }
+    iterator_deref<Container> operator*() {
+      return *this->sub_iter;
+    }
 
-      Iterator operator++(int) {
-        auto ret = *this;
-        ++*this;
-        return ret;
-      }
+    iterator_arrow<Container> operator->() {
+      return apply_arrow(this->sub_iter);
+    }
 
-      bool operator!=(const Iterator& other) const {
-        return this->sub_iter != other.sub_iter;
+    Iterator& operator++() {
+      ++this->sub_iter;
+      // reset to beginning upon reaching the end
+      if (!(this->sub_iter != this->end)) {
+        this->sub_iter = this->begin;
       }
+      return *this;
+    }
 
-      bool operator==(const Iterator& other) const {
-        return !(*this != other);
-      }
-    };
+    Iterator operator++(int) {
+      auto ret = *this;
+      ++*this;
+      return ret;
+    }
 
-    Iterator begin() {
-      return {std::begin(this->container), std::end(this->container)};
+    bool operator!=(const Iterator& other) const {
+      return this->sub_iter != other.sub_iter;
     }
 
-    Iterator end() {
-      return {std::end(this->container), std::end(this->container)};
+    bool operator==(const Iterator& other) const {
+      return !(*this != other);
     }
   };
 
-  template <typename Container>
-  Cycle<Container> cycle(Container&& container) {
-    return {std::forward<Container>(container)};
+  Iterator begin() {
+    return {std::begin(this->container), std::end(this->container)};
   }
 
-  template <typename T>
-  Cycle<std::initializer_list<T>> cycle(std::initializer_list<T> il) {
-    return {std::move(il)};
+  Iterator end() {
+    return {std::end(this->container), std::end(this->container)};
   }
+};
+
+template <typename Container>
+iter::impl::Cycler<Container> iter::cycle(Container&& container) {
+  return {std::forward<Container>(container)};
+}
+
+template <typename T>
+iter::impl::Cycler<std::initializer_list<T>> iter::cycle(
+    std::initializer_list<T> il) {
+  return {std::move(il)};
 }
 
 #endif

From e5838b2f0b4ddf606b58b6c4aa8f9f0010c64e55 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 20 Aug 2015 21:18:35 -0700
Subject: [PATCH 1229/1866] moves Dropper into impl{ }

---
 dropwhile.hpp | 174 +++++++++++++++++++++++++-------------------------
 1 file changed, 88 insertions(+), 86 deletions(-)

diff --git a/dropwhile.hpp b/dropwhile.hpp
index 073234de..9efbdbc3 100644
--- a/dropwhile.hpp
+++ b/dropwhile.hpp
@@ -8,120 +8,122 @@
 #include <initializer_list>
 
 namespace iter {
+  namespace impl {
+    template <typename FilterFunc, typename Container>
+    class Dropper;
+  }
 
   template <typename FilterFunc, typename Container>
-  class DropWhile;
-
-  template <typename FilterFunc, typename Container>
-  DropWhile<FilterFunc, Container> dropwhile(FilterFunc, Container&&);
+  impl::Dropper<FilterFunc, Container> dropwhile(FilterFunc, Container&&);
 
   template <typename FilterFunc, typename T>
-  DropWhile<FilterFunc, std::initializer_list<T>> dropwhile(
+  impl::Dropper<FilterFunc, std::initializer_list<T>> dropwhile(
       FilterFunc, std::initializer_list<T>);
+}
 
-  template <typename FilterFunc, typename Container>
-  class DropWhile {
-   private:
-    Container container;
-    FilterFunc filter_func;
-
-    friend DropWhile dropwhile<FilterFunc, Container>(FilterFunc, Container&&);
-
-    template <typename FF, typename T>
-    friend DropWhile<FF, std::initializer_list<T>> dropwhile(
-        FF, std::initializer_list<T>);
+template <typename FilterFunc, typename Container>
+class iter::impl::Dropper {
+ private:
+  Container container;
+  FilterFunc filter_func;
 
-    DropWhile(FilterFunc in_filter_func, Container&& in_container)
-        : container(std::forward<Container>(in_container)),
-          filter_func(in_filter_func) {}
+  friend Dropper iter::dropwhile<FilterFunc, Container>(
+      FilterFunc, Container&&);
 
-   public:
-    class Iterator : public std::iterator<std::input_iterator_tag,
-                         iterator_traits_deref<Container>> {
-     private:
-      using Holder = DerefHolder<iterator_deref<Container>>;
-      iterator_type<Container> sub_iter;
-      iterator_type<Container> sub_end;
-      Holder item;
-      FilterFunc* filter_func;
-
-      void inc_sub_iter() {
-        ++this->sub_iter;
-        if (this->sub_iter != this->sub_end) {
-          this->item.reset(*this->sub_iter);
-        }
-      }
+  template <typename FF, typename T>
+  friend Dropper<FF, std::initializer_list<T>> iter::dropwhile(
+      FF, std::initializer_list<T>);
 
-      // skip all values for which the predicate is true
-      void skip_passes() {
-        while (this->sub_iter != this->sub_end
-               && (*this->filter_func)(this->item.get())) {
-          this->inc_sub_iter();
-        }
-      }
+  Dropper(FilterFunc in_filter_func, Container&& in_container)
+      : container(std::forward<Container>(in_container)),
+        filter_func(in_filter_func) {}
 
-     public:
-      Iterator(iterator_type<Container>&& iter, iterator_type<Container>&& end,
-          FilterFunc& in_filter_func)
-          : sub_iter{std::move(iter)},
-            sub_end{std::move(end)},
-            filter_func(&in_filter_func) {
-        if (this->sub_iter != this->sub_end) {
-          this->item.reset(*this->sub_iter);
-        }
-        this->skip_passes();
+ public:
+  class Iterator : public std::iterator<std::input_iterator_tag,
+                       iterator_traits_deref<Container>> {
+   private:
+    using Holder = DerefHolder<iterator_deref<Container>>;
+    iterator_type<Container> sub_iter;
+    iterator_type<Container> sub_end;
+    Holder item;
+    FilterFunc* filter_func;
+
+    void inc_sub_iter() {
+      ++this->sub_iter;
+      if (this->sub_iter != this->sub_end) {
+        this->item.reset(*this->sub_iter);
       }
+    }
 
-      typename Holder::reference operator*() {
-        return this->item.get();
+    // skip all values for which the predicate is true
+    void skip_passes() {
+      while (this->sub_iter != this->sub_end
+             && (*this->filter_func)(this->item.get())) {
+        this->inc_sub_iter();
       }
+    }
 
-      typename Holder::pointer operator->() {
-        return this->item.get_ptr();
+   public:
+    Iterator(iterator_type<Container>&& iter, iterator_type<Container>&& end,
+        FilterFunc& in_filter_func)
+        : sub_iter{std::move(iter)},
+          sub_end{std::move(end)},
+          filter_func(&in_filter_func) {
+      if (this->sub_iter != this->sub_end) {
+        this->item.reset(*this->sub_iter);
       }
+      this->skip_passes();
+    }
 
-      Iterator& operator++() {
-        this->inc_sub_iter();
-        return *this;
-      }
+    typename Holder::reference operator*() {
+      return this->item.get();
+    }
 
-      Iterator operator++(int) {
-        auto ret = *this;
-        ++*this;
-        return ret;
-      }
+    typename Holder::pointer operator->() {
+      return this->item.get_ptr();
+    }
 
-      bool operator!=(const Iterator& other) const {
-        return this->sub_iter != other.sub_iter;
-      }
+    Iterator& operator++() {
+      this->inc_sub_iter();
+      return *this;
+    }
 
-      bool operator==(const Iterator& other) const {
-        return !(*this != other);
-      }
-    };
+    Iterator operator++(int) {
+      auto ret = *this;
+      ++*this;
+      return ret;
+    }
 
-    Iterator begin() {
-      return {std::begin(this->container), std::end(this->container),
-          this->filter_func};
+    bool operator!=(const Iterator& other) const {
+      return this->sub_iter != other.sub_iter;
     }
 
-    Iterator end() {
-      return {std::end(this->container), std::end(this->container),
-          this->filter_func};
+    bool operator==(const Iterator& other) const {
+      return !(*this != other);
     }
   };
 
-  template <typename FilterFunc, typename Container>
-  DropWhile<FilterFunc, Container> dropwhile(
-      FilterFunc filter_func, Container&& container) {
-    return {filter_func, std::forward<Container>(container)};
+  Iterator begin() {
+    return {std::begin(this->container), std::end(this->container),
+        this->filter_func};
   }
 
-  template <typename FilterFunc, typename T>
-  DropWhile<FilterFunc, std::initializer_list<T>> dropwhile(
-      FilterFunc filter_func, std::initializer_list<T> il) {
-    return {filter_func, std::move(il)};
+  Iterator end() {
+    return {std::end(this->container), std::end(this->container),
+        this->filter_func};
   }
+};
+
+template <typename FilterFunc, typename Container>
+iter::impl::Dropper<FilterFunc, Container> iter::dropwhile(
+    FilterFunc filter_func, Container&& container) {
+  return {filter_func, std::forward<Container>(container)};
+}
+
+template <typename FilterFunc, typename T>
+iter::impl::Dropper<FilterFunc, std::initializer_list<T>> iter::dropwhile(
+    FilterFunc filter_func, std::initializer_list<T> il) {
+  return {filter_func, std::move(il)};
 }
 
 #endif

From 99cae928d3b501a1a1dd7ad8ab1432af15760854 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 20 Aug 2015 21:26:56 -0700
Subject: [PATCH 1230/1866] moves Filtered into impl { }

---
 filter.hpp | 189 +++++++++++++++++++++++++++--------------------------
 1 file changed, 95 insertions(+), 94 deletions(-)

diff --git a/filter.hpp b/filter.hpp
index 89e38531..9a7b203f 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -8,125 +8,126 @@
 #include <initializer_list>
 
 namespace iter {
-
-  // Forward declarations of Filter and filter
-  template <typename FilterFunc, typename Container>
-  class Filter;
+  namespace impl {
+    template <typename FilterFunc, typename Container>
+    class Filtered;
+  }
 
   template <typename FilterFunc, typename Container>
-  Filter<FilterFunc, Container> filter(FilterFunc, Container&&);
+  impl::Filtered<FilterFunc, Container> filter(FilterFunc, Container&&);
 
   template <typename FilterFunc, typename T>
-  Filter<FilterFunc, std::initializer_list<T>> filter(
+  impl::Filtered<FilterFunc, std::initializer_list<T>> filter(
       FilterFunc, std::initializer_list<T>);
+}
 
-  template <typename FilterFunc, typename Container>
-  class Filter {
-   private:
-    Container container;
-    FilterFunc filter_func;
-
-    // The filter function is the only thing allowed to create a Filter
-    friend Filter filter<FilterFunc, Container>(FilterFunc, Container&&);
-
-    template <typename FF, typename T>
-    friend Filter<FF, std::initializer_list<T>> filter(
-        FF, std::initializer_list<T>);
-
-    // Value constructor for use only in the filter function
-    Filter(FilterFunc in_filter_func, Container&& in_container)
-        : container(std::forward<Container>(in_container)),
-          filter_func(in_filter_func) {}
-
-   public:
-    class Iterator : public std::iterator<std::input_iterator_tag,
-                         iterator_traits_deref<Container>> {
-     protected:
-      using Holder = DerefHolder<iterator_deref<Container>>;
-      iterator_type<Container> sub_iter;
-      iterator_type<Container> sub_end;
-      Holder item;
-      FilterFunc* filter_func;
-
-      void inc_sub_iter() {
-        ++this->sub_iter;
-        if (this->sub_iter != this->sub_end) {
-          this->item.reset(*this->sub_iter);
-        }
-      }
-
-      // increment until the iterator points to is true on the
-      // predicate.  Called by constructor and operator++
-      void skip_failures() {
-        while (this->sub_iter != this->sub_end
-               && !(*this->filter_func)(this->item.get())) {
-          this->inc_sub_iter();
-        }
-      }
-
-     public:
-      Iterator(iterator_type<Container> iter, iterator_type<Container> end,
-          FilterFunc& in_filter_func)
-          : sub_iter{iter}, sub_end{end}, filter_func(&in_filter_func) {
-        if (this->sub_iter != this->sub_end) {
-          this->item.reset(*this->sub_iter);
-        }
-        this->skip_failures();
+template <typename FilterFunc, typename Container>
+class iter::impl::Filtered {
+ private:
+  Container container;
+  FilterFunc filter_func;
+
+  // The filter function is the only thing allowed to create a Filtered
+  friend Filtered iter::filter<FilterFunc, Container>(FilterFunc, Container&&);
+
+  template <typename FF, typename T>
+  friend Filtered<FF, std::initializer_list<T>> iter::filter(
+      FF, std::initializer_list<T>);
+
+  // Value constructor for use only in the filter function
+  Filtered(FilterFunc in_filter_func, Container&& in_container)
+      : container(std::forward<Container>(in_container)),
+        filter_func(in_filter_func) {}
+
+ public:
+  class Iterator : public std::iterator<std::input_iterator_tag,
+                       iterator_traits_deref<Container>> {
+   protected:
+    using Holder = DerefHolder<iterator_deref<Container>>;
+    iterator_type<Container> sub_iter;
+    iterator_type<Container> sub_end;
+    Holder item;
+    FilterFunc* filter_func;
+
+    void inc_sub_iter() {
+      ++this->sub_iter;
+      if (this->sub_iter != this->sub_end) {
+        this->item.reset(*this->sub_iter);
       }
+    }
 
-      typename Holder::reference operator*() {
-        return this->item.get();
+    // increment until the iterator points to is true on the
+    // predicate.  Called by constructor and operator++
+    void skip_failures() {
+      while (this->sub_iter != this->sub_end
+             && !(*this->filter_func)(this->item.get())) {
+        this->inc_sub_iter();
       }
+    }
 
-      typename Holder::pointer operator->() {
-        return this->item.get_ptr();
+   public:
+    Iterator(iterator_type<Container> iter, iterator_type<Container> end,
+        FilterFunc& in_filter_func)
+        : sub_iter{iter}, sub_end{end}, filter_func(&in_filter_func) {
+      if (this->sub_iter != this->sub_end) {
+        this->item.reset(*this->sub_iter);
       }
+      this->skip_failures();
+    }
 
-      Iterator& operator++() {
-        this->inc_sub_iter();
-        this->skip_failures();
-        return *this;
-      }
+    typename Holder::reference operator*() {
+      return this->item.get();
+    }
 
-      Iterator operator++(int) {
-        auto ret = *this;
-        ++*this;
-        return ret;
-      }
+    typename Holder::pointer operator->() {
+      return this->item.get_ptr();
+    }
 
-      bool operator!=(const Iterator& other) const {
-        return this->sub_iter != other.sub_iter;
-      }
+    Iterator& operator++() {
+      this->inc_sub_iter();
+      this->skip_failures();
+      return *this;
+    }
 
-      bool operator==(const Iterator& other) const {
-        return !(*this != other);
-      }
-    };
+    Iterator operator++(int) {
+      auto ret = *this;
+      ++*this;
+      return ret;
+    }
 
-    Iterator begin() {
-      return {std::begin(this->container), std::end(this->container),
-          this->filter_func};
+    bool operator!=(const Iterator& other) const {
+      return this->sub_iter != other.sub_iter;
     }
 
-    Iterator end() {
-      return {std::end(this->container), std::end(this->container),
-          this->filter_func};
+    bool operator==(const Iterator& other) const {
+      return !(*this != other);
     }
   };
 
-  // Helper function to instantiate a Filter
-  template <typename FilterFunc, typename Container>
-  Filter<FilterFunc, Container> filter(
-      FilterFunc filter_func, Container&& container) {
-    return {filter_func, std::forward<Container>(container)};
+  Iterator begin() {
+    return {std::begin(this->container), std::end(this->container),
+        this->filter_func};
   }
 
-  template <typename FilterFunc, typename T>
-  Filter<FilterFunc, std::initializer_list<T>> filter(
-      FilterFunc filter_func, std::initializer_list<T> il) {
-    return {filter_func, std::move(il)};
+  Iterator end() {
+    return {std::end(this->container), std::end(this->container),
+        this->filter_func};
   }
+};
 
+template <typename FilterFunc, typename Container>
+iter::impl::Filtered<FilterFunc, Container> iter::filter(
+    FilterFunc filter_func, Container&& container) {
+  return {filter_func, std::forward<Container>(container)};
+}
+
+template <typename FilterFunc, typename T>
+iter::impl::Filtered<FilterFunc, std::initializer_list<T>> iter::filter(
+    FilterFunc filter_func, std::initializer_list<T> il) {
+  return {filter_func, std::move(il)};
+}
+
+namespace iter {
   namespace detail {
 
     template <typename T>

From 7268b1b8f0ffe0602ae36bddf364959a87b3fbd7 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 20 Aug 2015 21:32:26 -0700
Subject: [PATCH 1231/1866] resolves chain link error

---
 chain.hpp | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/chain.hpp b/chain.hpp
index 7c5308ea..0e8c3343 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -24,8 +24,6 @@ namespace iter {
     // .from_iterable()
     class ChainMaker;
   }
-
-  extern const impl::ChainMaker chain;
 }
 
 template <typename Container, typename... RestContainers>
@@ -307,6 +305,10 @@ class iter::impl::ChainMaker {
   }
 };
 
-constexpr iter::impl::ChainMaker iter::chain{};
+namespace iter {
+  namespace {
+    constexpr auto chain = impl::ChainMaker{};
+  }
+}
 
 #endif

From c1ecea13acec919791fadcbf25783902fcd2d92e Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 20 Aug 2015 21:33:35 -0700
Subject: [PATCH 1232/1866] adjusts for Filtered rename

---
 unique_everseen.hpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/unique_everseen.hpp b/unique_everseen.hpp
index b971ca62..23b951c4 100644
--- a/unique_everseen.hpp
+++ b/unique_everseen.hpp
@@ -15,7 +15,8 @@ namespace iter {
   // performance checking if it has ever been seen
   template <typename Container>
   auto unique_everseen(Container&& container)
-      -> Filter<std::function<bool(iterator_deref<Container>)>, Container> {
+      -> impl::Filtered<std::function<bool(iterator_deref<Container>)>,
+          Container> {
     using elem_t = iterator_deref<Container>;
     std::unordered_set<typename std::decay<elem_t>::type> elem_seen;
 
@@ -35,7 +36,7 @@ namespace iter {
 
   template <typename T>
   auto unique_everseen(std::initializer_list<T> il)
-      -> Filter<std::function<bool(T)>, std::initializer_list<T>> {
+      -> impl::Filtered<std::function<bool(T)>, std::initializer_list<T>> {
     std::unordered_set<T> elem_seen;
     std::function<bool(T)> func = [elem_seen](const T& e) mutable {
       if (elem_seen.find(e) == std::end(elem_seen)) {

From 65917212349b0ddc6f50f32c898ce3cd535e6d42 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 20 Aug 2015 21:49:47 -0700
Subject: [PATCH 1233/1866] moves GroupProducer into impl { }

---
 groupby.hpp | 456 ++++++++++++++++++++++++++--------------------------
 1 file changed, 231 insertions(+), 225 deletions(-)

diff --git a/groupby.hpp b/groupby.hpp
index c6d758a1..8262652b 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -12,301 +12,307 @@
 #include <initializer_list>
 
 namespace iter {
-
-  template <typename Container, typename KeyFunc>
-  class GroupBy;
-
+  namespace impl {
+    template <typename Container, typename KeyFunc>
+    class GroupProducer;
+  }
   template <typename Container, typename KeyFunc>
-  GroupBy<Container, KeyFunc> groupby(Container&&, KeyFunc);
+  impl::GroupProducer<Container, KeyFunc> groupby(Container&&, KeyFunc);
 
   template <typename T, typename KeyFunc>
-  GroupBy<std::initializer_list<T>, KeyFunc> groupby(
+  impl::GroupProducer<std::initializer_list<T>, KeyFunc> groupby(
       std::initializer_list<T>, KeyFunc);
+}
 
-  template <typename Container, typename KeyFunc>
-  class GroupBy {
-   private:
-    Container container;
-    KeyFunc key_func;
+template <typename Container, typename KeyFunc>
+class iter::impl::GroupProducer {
+ private:
+  Container container;
+  KeyFunc key_func;
 
-    friend GroupBy groupby<Container, KeyFunc>(Container&&, KeyFunc);
+  friend GroupProducer iter::groupby<Container, KeyFunc>(Container&&, KeyFunc);
 
-    template <typename T, typename KF>
-    friend GroupBy<std::initializer_list<T>, KF> groupby(
-        std::initializer_list<T>, KF);
+  template <typename T, typename KF>
+  friend GroupProducer<std::initializer_list<T>, KF> iter::groupby(
+      std::initializer_list<T>, KF);
 
-    using key_func_ret =
-        typename std::result_of<KeyFunc(iterator_deref<Container>)>::type;
+  using key_func_ret =
+      typename std::result_of<KeyFunc(iterator_deref<Container>)>::type;
 
-    GroupBy(Container&& in_container, KeyFunc in_key_func)
-        : container(std::forward<Container>(in_container)),
-          key_func(in_key_func) {}
+  GroupProducer(Container&& in_container, KeyFunc in_key_func)
+      : container(std::forward<Container>(in_container)),
+        key_func(in_key_func) {}
 
-   public:
-    GroupBy() = delete;
-    GroupBy(const GroupBy&) = delete;
-    GroupBy& operator=(const GroupBy&) = delete;
-    GroupBy& operator=(GroupBy&&) = delete;
+ public:
+  GroupProducer() = delete;
+  GroupProducer(const GroupProducer&) = delete;
+  GroupProducer& operator=(const GroupProducer&) = delete;
+  GroupProducer& operator=(GroupProducer&&) = delete;
 
-    GroupBy(GroupBy&&) = default;
+  GroupProducer(GroupProducer&&) = default;
 
-    class Iterator;
-    class Group;
+  class Iterator;
+  class Group;
 
-   private:
-    using KeyGroupPair = std::pair<key_func_ret, Group>;
-    using Holder = DerefHolder<iterator_deref<Container>>;
+ private:
+  using KeyGroupPair = std::pair<key_func_ret, Group>;
+  using Holder = DerefHolder<iterator_deref<Container>>;
 
-   public:
-    class Iterator
-        : public std::iterator<std::input_iterator_tag, KeyGroupPair> {
-     private:
-      iterator_type<Container> sub_iter;
-      iterator_type<Container> sub_end;
-      Holder item;
-      KeyFunc* key_func;
+ public:
+  class Iterator : public std::iterator<std::input_iterator_tag, KeyGroupPair> {
+   private:
+    iterator_type<Container> sub_iter;
+    iterator_type<Container> sub_end;
+    Holder item;
+    KeyFunc* key_func;
 
-      std::unique_ptr<KeyGroupPair> current_key_group_pair;
+    std::unique_ptr<KeyGroupPair> current_key_group_pair;
 
-     public:
-      Iterator(iterator_type<Container>&& si, iterator_type<Container>&& end,
-          KeyFunc& in_key_func)
-          : sub_iter{std::move(si)},
-            sub_end{std::move(end)},
-            key_func(&in_key_func) {
-        if (this->sub_iter != this->sub_end) {
-          this->item.reset(*this->sub_iter);
-        }
+   public:
+    Iterator(iterator_type<Container>&& si, iterator_type<Container>&& end,
+        KeyFunc& in_key_func)
+        : sub_iter{std::move(si)},
+          sub_end{std::move(end)},
+          key_func(&in_key_func) {
+      if (this->sub_iter != this->sub_end) {
+        this->item.reset(*this->sub_iter);
       }
+    }
 
-      Iterator(const Iterator& other)
-          : sub_iter{other.sub_iter},
-            sub_end{other.sub_end},
-            item{other.item},
-            key_func{other.key_func} {}
-
-      Iterator& operator=(const Iterator& other) {
-        if (this == &other) return *this;
-        this->sub_iter = other.sub_iter;
-        this->sub_end = other.sub_end;
-        this->item = other.item;
-        this->key_func = other.key_func;
-        this->current_key_group_pair.reset();
-        return *this;
-      }
+    Iterator(const Iterator& other)
+        : sub_iter{other.sub_iter},
+          sub_end{other.sub_end},
+          item{other.item},
+          key_func{other.key_func} {}
+
+    Iterator& operator=(const Iterator& other) {
+      if (this == &other) return *this;
+      this->sub_iter = other.sub_iter;
+      this->sub_end = other.sub_end;
+      this->item = other.item;
+      this->key_func = other.key_func;
+      this->current_key_group_pair.reset();
+      return *this;
+    }
 
-      ~Iterator() = default;
+    ~Iterator() = default;
 
-      // NOTE the implicitly generated move constructor would
-      // be wrong
+    // NOTE the implicitly generated move constructor would
+    // be wrong
 
-      KeyGroupPair& operator*() {
-        set_key_group_pair();
-        return *this->current_key_group_pair;
-      }
+    KeyGroupPair& operator*() {
+      set_key_group_pair();
+      return *this->current_key_group_pair;
+    }
 
-      KeyGroupPair* operator->() {
-        set_key_group_pair();
-        return this->current_key_group_pair.get();
-      }
+    KeyGroupPair* operator->() {
+      set_key_group_pair();
+      return this->current_key_group_pair.get();
+    }
 
-      Iterator& operator++() {
-        if (!this->current_key_group_pair) {
-          this->set_key_group_pair();
-        }
-        this->current_key_group_pair.reset();
-        return *this;
+    Iterator& operator++() {
+      if (!this->current_key_group_pair) {
+        this->set_key_group_pair();
       }
+      this->current_key_group_pair.reset();
+      return *this;
+    }
 
-      Iterator operator++(int) {
-        auto ret = *this;
-        ++*this;
-        return ret;
-      }
+    Iterator operator++(int) {
+      auto ret = *this;
+      ++*this;
+      return ret;
+    }
 
-      bool operator!=(const Iterator& other) const {
-        return this->sub_iter != other.sub_iter;
-      }
+    bool operator!=(const Iterator& other) const {
+      return this->sub_iter != other.sub_iter;
+    }
 
-      bool operator==(const Iterator& other) const {
-        return !(*this != other);
-      }
+    bool operator==(const Iterator& other) const {
+      return !(*this != other);
+    }
 
-      void increment_iterator() {
+    void increment_iterator() {
+      if (this->sub_iter != this->sub_end) {
+        ++this->sub_iter;
         if (this->sub_iter != this->sub_end) {
-          ++this->sub_iter;
-          if (this->sub_iter != this->sub_end) {
-            this->item.reset(*this->sub_iter);
-          }
+          this->item.reset(*this->sub_iter);
         }
       }
+    }
 
-      bool exhausted() const {
-        return !(this->sub_iter != this->sub_end);
-      }
+    bool exhausted() const {
+      return !(this->sub_iter != this->sub_end);
+    }
 
-      typename Holder::reference get() {
-        return this->item.get();
-      }
+    typename Holder::reference get() {
+      return this->item.get();
+    }
 
-      typename Holder::pointer get_ptr() {
-        return this->item.get_ptr();
-      }
+    typename Holder::pointer get_ptr() {
+      return this->item.get_ptr();
+    }
 
-      key_func_ret next_key() {
-        return (*this->key_func)(this->item.get());
-      }
+    key_func_ret next_key() {
+      return (*this->key_func)(this->item.get());
+    }
 
-      void set_key_group_pair() {
-        if (!this->current_key_group_pair) {
-          this->current_key_group_pair.reset(
-              new KeyGroupPair((*this->key_func)(this->item.get()),
-                  Group{*this, this->next_key()}));
-        }
+    void set_key_group_pair() {
+      if (!this->current_key_group_pair) {
+        this->current_key_group_pair.reset(
+            new KeyGroupPair((*this->key_func)(this->item.get()),
+                Group{*this, this->next_key()}));
       }
-    };
+    }
+  };
 
-    class Group {
-     private:
-      friend Iterator;
-      friend class GroupIterator;
-      Iterator& owner;
-      key_func_ret key;
-
-      // completed is set if a Group is iterated through
-      // completely.  It is checked in the destructor, and
-      // if the Group has not been completed, the destructor
-      // exhausts it.  This ensures that the next Group starts
-      // at the correct position when the user short-circuits
-      // iteration over a Group.
-      // The move constructor sets the rvalue's completed
-      // attribute to true, so its destructor doesn't do anything
-      // when called.
-      bool completed = false;
-
-      Group(Iterator& in_owner, key_func_ret in_key)
-          : owner(in_owner), key(in_key) {}
+  class Group {
+   private:
+    friend Iterator;
+    friend class GroupIterator;
+    Iterator& owner;
+    key_func_ret key;
+
+    // completed is set if a Group is iterated through
+    // completely.  It is checked in the destructor, and
+    // if the Group has not been completed, the destructor
+    // exhausts it.  This ensures that the next Group starts
+    // at the correct position when the user short-circuits
+    // iteration over a Group.
+    // The move constructor sets the rvalue's completed
+    // attribute to true, so its destructor doesn't do anything
+    // when called.
+    bool completed = false;
+
+    Group(Iterator& in_owner, key_func_ret in_key)
+        : owner(in_owner), key(in_key) {}
 
-     public:
-      ~Group() {
-        if (!this->completed) {
-          for (auto iter = this->begin(), end = this->end(); iter != end;
-               ++iter) {
-          }
+   public:
+    ~Group() {
+      if (!this->completed) {
+        for (auto iter = this->begin(), end = this->end(); iter != end;
+             ++iter) {
         }
       }
+    }
 
-      // move-constructible, non-copy-constructible,
-      // non-assignable
-      Group() = delete;
-      Group(const Group&) = default;
-      Group& operator=(const Group&) = delete;
-      Group& operator=(Group&&) = delete;
-
-      Group(Group&& other)
-          : owner{other.owner}, key{other.key}, completed{other.completed} {
-        other.completed = true;
-      }
-
-      class GroupIterator : public std::iterator<std::input_iterator_tag,
-                                iterator_traits_deref<Container>> {
-       private:
-        typename std::remove_reference<key_func_ret>::type* key;
-        Group* group_p;
+    // move-constructible, non-copy-constructible,
+    // non-assignable
+    Group() = delete;
+    Group(const Group&) = default;
+    Group& operator=(const Group&) = delete;
+    Group& operator=(Group&&) = delete;
 
-        bool not_at_end() {
-          return !this->group_p->owner.exhausted()
-                 && this->group_p->owner.next_key() == *this->key;
-        }
+    Group(Group&& other)
+        : owner{other.owner}, key{other.key}, completed{other.completed} {
+      other.completed = true;
+    }
 
-       public:
-        GroupIterator(Group* in_group_p, key_func_ret& in_key)
-            : key{&in_key}, group_p{in_group_p} {}
+    class GroupIterator : public std::iterator<std::input_iterator_tag,
+                              iterator_traits_deref<Container>> {
+     private:
+      typename std::remove_reference<key_func_ret>::type* key;
+      Group* group_p;
 
-        bool operator!=(const GroupIterator& other) const {
-          return !(*this == other);
-        }
+      bool not_at_end() {
+        return !this->group_p->owner.exhausted()
+               && this->group_p->owner.next_key() == *this->key;
+      }
 
-        bool operator==(const GroupIterator& other) const {
-          return this->group_p == other.group_p;
-        }
+     public:
+      GroupIterator(Group* in_group_p, key_func_ret& in_key)
+          : key{&in_key}, group_p{in_group_p} {}
 
-        GroupIterator& operator++() {
-          this->group_p->owner.increment_iterator();
-          if (!this->not_at_end()) {
-            this->group_p->completed = true;
-            this->group_p = nullptr;
-          }
-          return *this;
-        }
+      bool operator!=(const GroupIterator& other) const {
+        return !(*this == other);
+      }
 
-        GroupIterator operator++(int) {
-          auto ret = *this;
-          ++*this;
-          return ret;
-        }
+      bool operator==(const GroupIterator& other) const {
+        return this->group_p == other.group_p;
+      }
 
-        iterator_deref<Container> operator*() {
-          return this->group_p->owner.get();
+      GroupIterator& operator++() {
+        this->group_p->owner.increment_iterator();
+        if (!this->not_at_end()) {
+          this->group_p->completed = true;
+          this->group_p = nullptr;
         }
+        return *this;
+      }
 
-        typename Holder::pointer operator->() {
-          return this->group_p->owner.get_ptr();
-        }
-      };
+      GroupIterator operator++(int) {
+        auto ret = *this;
+        ++*this;
+        return ret;
+      }
 
-      GroupIterator begin() {
-        return {this, key};
+      iterator_deref<Container> operator*() {
+        return this->group_p->owner.get();
       }
 
-      GroupIterator end() {
-        return {nullptr, key};
+      typename Holder::pointer operator->() {
+        return this->group_p->owner.get_ptr();
       }
     };
 
-    Iterator begin() {
-      return {std::begin(this->container), std::end(this->container),
-          this->key_func};
+    GroupIterator begin() {
+      return {this, key};
     }
 
-    Iterator end() {
-      return {
-          std::end(this->container), std::end(this->container), this->key_func};
+    GroupIterator end() {
+      return {nullptr, key};
     }
   };
 
-  // Takes something and returns it, used for default key of comparing
-  // items in the sequence directly
-  template <typename Container>
-  class ItemReturner {
-   public:
-    iterator_deref<Container> operator()(iterator_deref<Container> item) const {
-      return item;
-    }
-  };
+  Iterator begin() {
+    return {
+        std::begin(this->container), std::end(this->container), this->key_func};
+  }
 
-  template <typename Container, typename KeyFunc>
-  GroupBy<Container, KeyFunc> groupby(Container&& container, KeyFunc key_func) {
-    return {std::forward<Container>(container), key_func};
+  Iterator end() {
+    return {
+        std::end(this->container), std::end(this->container), this->key_func};
   }
+};
 
-  template <typename Container>
-  auto groupby(Container&& container) -> decltype(
-      groupby(std::forward<Container>(container), ItemReturner<Container>())) {
-    return groupby(
-        std::forward<Container>(container), ItemReturner<Container>());
+template <typename Container, typename KeyFunc>
+iter::impl::GroupProducer<Container, KeyFunc> iter::groupby(
+    Container&& container, KeyFunc key_func) {
+  return {std::forward<Container>(container), key_func};
+}
+
+template <typename T, typename KeyFunc>
+iter::impl::GroupProducer<std::initializer_list<T>, KeyFunc> iter::groupby(
+    std::initializer_list<T> il, KeyFunc key_func) {
+  return {std::move(il), key_func};
+}
+
+namespace iter {
+  namespace detail {
+    // Takes something and returns it, used for default key of comparing
+    // items in the sequence directly
+    template <typename Container>
+    class ItemReturner {
+     public:
+      iterator_deref<Container> operator()(
+          iterator_deref<Container> item) const {
+        return item;
+      }
+    };
   }
 
-  template <typename T, typename KeyFunc>
-  GroupBy<std::initializer_list<T>, KeyFunc> groupby(
-      std::initializer_list<T> il, KeyFunc key_func) {
-    return {std::move(il), key_func};
+  template <typename Container>
+  auto groupby(Container&& container) -> decltype(groupby(
+      std::forward<Container>(container), detail::ItemReturner<Container>())) {
+    return groupby(
+        std::forward<Container>(container), detail::ItemReturner<Container>());
   }
 
   template <typename T>
-  auto groupby(std::initializer_list<T> il) -> decltype(
-      groupby(std::move(il), ItemReturner<std::initializer_list<T>>())) {
-    return groupby(std::move(il), ItemReturner<std::initializer_list<T>>());
+  auto groupby(std::initializer_list<T> il) -> decltype(groupby(
+      std::move(il), detail::ItemReturner<std::initializer_list<T>>())) {
+    return groupby(
+        std::move(il), detail::ItemReturner<std::initializer_list<T>>());
   }
 }
 

From a8164f8efd078a8b8f273df8cfc60ab71244e420 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 20 Aug 2015 21:52:13 -0700
Subject: [PATCH 1234/1866] moves Grouper into impl { }

---
 grouper.hpp | 165 ++++++++++++++++++++++++++--------------------------
 1 file changed, 84 insertions(+), 81 deletions(-)

diff --git a/grouper.hpp b/grouper.hpp
index 0c6abd09..cb674111 100644
--- a/grouper.hpp
+++ b/grouper.hpp
@@ -13,113 +13,116 @@
 #include <initializer_list>
 
 namespace iter {
-  template <typename Container>
-  class Grouper;
+  namespace impl {
+    template <typename Container>
+    class Grouper;
+  }
 
   template <typename Container>
-  Grouper<Container> grouper(Container&&, std::size_t);
+  impl::Grouper<Container> grouper(Container&&, std::size_t);
 
   template <typename T>
-  Grouper<std::initializer_list<T>> grouper(
+  impl::Grouper<std::initializer_list<T>> grouper(
       std::initializer_list<T>, std::size_t);
+}
 
-  template <typename Container>
-  class Grouper {
-   private:
-    Container container;
-    std::size_t group_size;
-
-    Grouper(Container&& c, std::size_t sz)
-        : container(std::forward<Container>(c)), group_size{sz} {}
+template <typename Container>
+class iter::impl::Grouper {
+ private:
+  Container container;
+  std::size_t group_size;
 
-    friend Grouper grouper<Container>(Container&&, std::size_t);
-    template <typename T>
-    friend Grouper<std::initializer_list<T>> grouper(
-        std::initializer_list<T>, std::size_t);
+  Grouper(Container&& c, std::size_t sz)
+      : container(std::forward<Container>(c)), group_size{sz} {}
 
-    using IndexVector = std::vector<iterator_type<Container>>;
-    using DerefVec = IterIterWrapper<IndexVector>;
+  friend Grouper iter::grouper<Container>(Container&&, std::size_t);
+  template <typename T>
+  friend Grouper<std::initializer_list<T>> iter::grouper(
+      std::initializer_list<T>, std::size_t);
 
-   public:
-    class Iterator : public std::iterator<std::input_iterator_tag, DerefVec> {
-     private:
-      iterator_type<Container> sub_iter;
-      iterator_type<Container> sub_end;
-      DerefVec group;
-      std::size_t group_size = 0;
-
-      bool done() const {
-        return this->group.empty();
-      }
+  using IndexVector = std::vector<iterator_type<Container>>;
+  using DerefVec = IterIterWrapper<IndexVector>;
 
-      void refill_group() {
-        this->group.get().clear();
-        std::size_t i{0};
-        while (i < group_size && this->sub_iter != this->sub_end) {
-          group.get().push_back(this->sub_iter);
-          ++this->sub_iter;
-          ++i;
-        }
-      }
+ public:
+  class Iterator : public std::iterator<std::input_iterator_tag, DerefVec> {
+   private:
+    iterator_type<Container> sub_iter;
+    iterator_type<Container> sub_end;
+    DerefVec group;
+    std::size_t group_size = 0;
 
-     public:
-      Iterator(iterator_type<Container>&& in_iter,
-          iterator_type<Container>&& in_end, std::size_t s)
-          : sub_iter{std::move(in_iter)},
-            sub_end{std::move(in_end)},
-            group_size{s} {
-        this->group.get().reserve(this->group_size);
-        this->refill_group();
-      }
+    bool done() const {
+      return this->group.empty();
+    }
 
-      Iterator& operator++() {
-        this->refill_group();
-        return *this;
+    void refill_group() {
+      this->group.get().clear();
+      std::size_t i{0};
+      while (i < group_size && this->sub_iter != this->sub_end) {
+        group.get().push_back(this->sub_iter);
+        ++this->sub_iter;
+        ++i;
       }
+    }
 
-      Iterator operator++(int) {
-        auto ret = *this;
-        ++*this;
-        return ret;
-      }
+   public:
+    Iterator(iterator_type<Container>&& in_iter,
+        iterator_type<Container>&& in_end, std::size_t s)
+        : sub_iter{std::move(in_iter)},
+          sub_end{std::move(in_end)},
+          group_size{s} {
+      this->group.get().reserve(this->group_size);
+      this->refill_group();
+    }
 
-      bool operator!=(const Iterator& other) const {
-        return !(*this == other);
-      }
+    Iterator& operator++() {
+      this->refill_group();
+      return *this;
+    }
 
-      bool operator==(const Iterator& other) const {
-        return this->done() == other.done()
-               && (this->done() || !(this->sub_iter != other.sub_iter));
-      }
+    Iterator operator++(int) {
+      auto ret = *this;
+      ++*this;
+      return ret;
+    }
 
-      DerefVec& operator*() {
-        return this->group;
-      }
+    bool operator!=(const Iterator& other) const {
+      return !(*this == other);
+    }
 
-      DerefVec* operator->() {
-        return &this->group;
-      }
-    };
+    bool operator==(const Iterator& other) const {
+      return this->done() == other.done()
+             && (this->done() || !(this->sub_iter != other.sub_iter));
+    }
 
-    Iterator begin() {
-      return {
-          std::begin(this->container), std::end(this->container), group_size};
+    DerefVec& operator*() {
+      return this->group;
     }
 
-    Iterator end() {
-      return {std::end(this->container), std::end(this->container), group_size};
+    DerefVec* operator->() {
+      return &this->group;
     }
   };
 
-  template <typename Container>
-  Grouper<Container> grouper(Container&& container, std::size_t group_size) {
-    return {std::forward<Container>(container), group_size};
+  Iterator begin() {
+    return {std::begin(this->container), std::end(this->container), group_size};
   }
 
-  template <typename T>
-  Grouper<std::initializer_list<T>> grouper(
-      std::initializer_list<T> il, std::size_t group_size) {
-    return {std::move(il), group_size};
+  Iterator end() {
+    return {std::end(this->container), std::end(this->container), group_size};
   }
+};
+
+template <typename Container>
+iter::impl::Grouper<Container> iter::grouper(
+    Container&& container, std::size_t group_size) {
+  return {std::forward<Container>(container), group_size};
+}
+
+template <typename T>
+iter::impl::Grouper<std::initializer_list<T>> iter::grouper(
+    std::initializer_list<T> il, std::size_t group_size) {
+  return {std::move(il), group_size};
 }
+
 #endif

From 71e3620205fb7cc5e28547de2146aa9952af9da3 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 20 Aug 2015 22:03:59 -0700
Subject: [PATCH 1235/1866] Renames grouper() to chunked()

I've wanted to do this from the beginning.  It's not a very useful tool
to begin with imo, but the name grouper() doesn't tell you anything.
---
 README.md                                   |  8 +--
 grouper.hpp => chunked.hpp                  | 64 ++++++++++-----------
 itertools.hpp                               |  2 +-
 test/SConstruct                             |  2 +-
 test/{test_grouper.cpp => test_chunked.cpp} | 28 ++++-----
 5 files changed, 52 insertions(+), 52 deletions(-)
 rename grouper.hpp => chunked.hpp (59%)
 rename test/{test_grouper.cpp => test_chunked.cpp} (63%)

diff --git a/README.md b/README.md
index 02a6ba6e..26678192 100644
--- a/README.md
+++ b/README.md
@@ -31,7 +31,7 @@ evaluation wherever possible.
 [reversed](#reversed)<br />
 [slice](#slice)<br />
 [sliding\_window](#sliding_window)<br />
-[grouper](#grouper)<br />
+[chunked](#chunked)<br />
 
 ##### Combinatoric fuctions
 [product](#product)<br />
@@ -611,16 +611,16 @@ for (auto&& sec : sliding_window(v,4)) {
     cout << '\n';
 }
 ```
-grouper
+chunked
 ------
 
-grouper is very similar to sliding window, except instead of the
+chunked is very similar to sliding window, except instead of the
 section sliding by only 1 it goes the length of the full section.
 
 Example usage:
 ```c++
 vector<int> v {1,2,3,4,5,6,7,8,9};
-for (auto&& sec : grouper(v,4))
+for (auto&& sec : chunked(v,4))
 //each section will have 4 elements
 //except the last one may be cut short
 {
diff --git a/grouper.hpp b/chunked.hpp
similarity index 59%
rename from grouper.hpp
rename to chunked.hpp
index cb674111..5b5981aa 100644
--- a/grouper.hpp
+++ b/chunked.hpp
@@ -1,5 +1,5 @@
-#ifndef ITER_GROUPER_HPP_
-#define ITER_GROUPER_HPP_
+#ifndef ITER_CHUNKED_HPP_
+#define ITER_CHUNKED_HPP_
 
 #include "iterbase.hpp"
 #include "iteratoriterator.hpp"
@@ -15,29 +15,29 @@
 namespace iter {
   namespace impl {
     template <typename Container>
-    class Grouper;
+    class Chunker;
   }
 
   template <typename Container>
-  impl::Grouper<Container> grouper(Container&&, std::size_t);
+  impl::Chunker<Container> chunked(Container&&, std::size_t);
 
   template <typename T>
-  impl::Grouper<std::initializer_list<T>> grouper(
+  impl::Chunker<std::initializer_list<T>> chunked(
       std::initializer_list<T>, std::size_t);
 }
 
 template <typename Container>
-class iter::impl::Grouper {
+class iter::impl::Chunker {
  private:
   Container container;
-  std::size_t group_size;
+  std::size_t chunk_size;
 
-  Grouper(Container&& c, std::size_t sz)
-      : container(std::forward<Container>(c)), group_size{sz} {}
+  Chunker(Container&& c, std::size_t sz)
+      : container(std::forward<Container>(c)), chunk_size{sz} {}
 
-  friend Grouper iter::grouper<Container>(Container&&, std::size_t);
+  friend Chunker iter::chunked<Container>(Container&&, std::size_t);
   template <typename T>
-  friend Grouper<std::initializer_list<T>> iter::grouper(
+  friend Chunker<std::initializer_list<T>> iter::chunked(
       std::initializer_list<T>, std::size_t);
 
   using IndexVector = std::vector<iterator_type<Container>>;
@@ -48,18 +48,18 @@ class iter::impl::Grouper {
    private:
     iterator_type<Container> sub_iter;
     iterator_type<Container> sub_end;
-    DerefVec group;
-    std::size_t group_size = 0;
+    DerefVec chunk;
+    std::size_t chunk_size = 0;
 
     bool done() const {
-      return this->group.empty();
+      return this->chunk.empty();
     }
 
-    void refill_group() {
-      this->group.get().clear();
+    void refill_chunk() {
+      this->chunk.get().clear();
       std::size_t i{0};
-      while (i < group_size && this->sub_iter != this->sub_end) {
-        group.get().push_back(this->sub_iter);
+      while (i < chunk_size && this->sub_iter != this->sub_end) {
+        chunk.get().push_back(this->sub_iter);
         ++this->sub_iter;
         ++i;
       }
@@ -70,13 +70,13 @@ class iter::impl::Grouper {
         iterator_type<Container>&& in_end, std::size_t s)
         : sub_iter{std::move(in_iter)},
           sub_end{std::move(in_end)},
-          group_size{s} {
-      this->group.get().reserve(this->group_size);
-      this->refill_group();
+          chunk_size{s} {
+      this->chunk.get().reserve(this->chunk_size);
+      this->refill_chunk();
     }
 
     Iterator& operator++() {
-      this->refill_group();
+      this->refill_chunk();
       return *this;
     }
 
@@ -96,33 +96,33 @@ class iter::impl::Grouper {
     }
 
     DerefVec& operator*() {
-      return this->group;
+      return this->chunk;
     }
 
     DerefVec* operator->() {
-      return &this->group;
+      return &this->chunk;
     }
   };
 
   Iterator begin() {
-    return {std::begin(this->container), std::end(this->container), group_size};
+    return {std::begin(this->container), std::end(this->container), chunk_size};
   }
 
   Iterator end() {
-    return {std::end(this->container), std::end(this->container), group_size};
+    return {std::end(this->container), std::end(this->container), chunk_size};
   }
 };
 
 template <typename Container>
-iter::impl::Grouper<Container> iter::grouper(
-    Container&& container, std::size_t group_size) {
-  return {std::forward<Container>(container), group_size};
+iter::impl::Chunker<Container> iter::chunked(
+    Container&& container, std::size_t chunk_size) {
+  return {std::forward<Container>(container), chunk_size};
 }
 
 template <typename T>
-iter::impl::Grouper<std::initializer_list<T>> iter::grouper(
-    std::initializer_list<T> il, std::size_t group_size) {
-  return {std::move(il), group_size};
+iter::impl::Chunker<std::initializer_list<T>> iter::chunked(
+    std::initializer_list<T> il, std::size_t chunk_size) {
+  return {std::move(il), chunk_size};
 }
 
 #endif
diff --git a/itertools.hpp b/itertools.hpp
index dddbb293..104e5b77 100644
--- a/itertools.hpp
+++ b/itertools.hpp
@@ -13,7 +13,7 @@
 #include "filter.hpp"
 #include "filterfalse.hpp"
 #include "groupby.hpp"
-#include "grouper.hpp"
+#include "chunked.hpp"
 #include "imap.hpp"
 #include "sliding_window.hpp"
 #include "permutations.hpp"
diff --git a/test/SConstruct b/test/SConstruct
index 350942bb..a37669b5 100644
--- a/test/SConstruct
+++ b/test/SConstruct
@@ -17,6 +17,7 @@ progs = Split(
     '''
     accumulate
     chain
+    chunked
     combinations
     combinations_with_replacement
     compress
@@ -27,7 +28,6 @@ progs = Split(
     filter
     filterfalse
     groupby
-    grouper
     imap
     permutations
     powerset
diff --git a/test/test_grouper.cpp b/test/test_chunked.cpp
similarity index 63%
rename from test/test_grouper.cpp
rename to test/test_chunked.cpp
index bc09bc30..e77429b0 100644
--- a/test/test_grouper.cpp
+++ b/test/test_chunked.cpp
@@ -1,4 +1,4 @@
-#include <grouper.hpp>
+#include <chunked.hpp>
 
 #include <vector>
 #include <array>
@@ -8,14 +8,14 @@
 #include "helpers.hpp"
 #include "catch.hpp"
 
-using iter::grouper;
+using iter::chunked;
 using Vec = std::vector<int>;
 using ResVec = std::vector<Vec>;
 
-TEST_CASE("grouper: basic test", "[grouper]") {
+TEST_CASE("chunked: basic test", "[chunked]") {
     Vec ns = {1,2,3,4,5,6};
     ResVec results;
-    for (auto&& g : grouper(ns, 2)) {
+    for (auto&& g : chunked(ns, 2)) {
         results.emplace_back(std::begin(g), std::end(g));
     }
 
@@ -24,10 +24,10 @@ TEST_CASE("grouper: basic test", "[grouper]") {
     REQUIRE( results == rc );
 }
 
-TEST_CASE("grouper: len(iterable) % groupsize != 0", "[grouper]") {
+TEST_CASE("chunked: len(iterable) % groupsize != 0", "[chunked]") {
     Vec ns = {1,2,3,4,5,6,7};
     ResVec results;
-    for (auto&& g : grouper(ns, 3)) {
+    for (auto&& g : chunked(ns, 3)) {
         results.emplace_back(std::begin(g), std::end(g));
     }
 
@@ -36,9 +36,9 @@ TEST_CASE("grouper: len(iterable) % groupsize != 0", "[grouper]") {
     REQUIRE( results == rc );
 }
 
-TEST_CASE("grouper: iterators can be compared", "[grouper]") {
+TEST_CASE("chunked: iterators can be compared", "[chunked]") {
     Vec ns = {1,2,3,4,5,6,7};
-    auto g = grouper(ns, 3);
+    auto g = chunked(ns, 3);
     auto it = std::begin(g);
     REQUIRE( it == std::begin(g) );
     REQUIRE_FALSE( it != std::begin(g) );
@@ -47,20 +47,20 @@ TEST_CASE("grouper: iterators can be compared", "[grouper]") {
     REQUIRE_FALSE( it == std::begin(g) );
 }
 
-TEST_CASE("grouper: size 0 is empty", "[grouper]") {
+TEST_CASE("chunked: size 0 is empty", "[chunked]") {
     Vec ns{1, 2, 3};
-    auto g = grouper(ns, 0);
+    auto g = chunked(ns, 0);
     REQUIRE( std::begin(g) == std::end(g) );
 }
 
-TEST_CASE("grouper: empty iterable gives empty grouper", "[grouper]") {
+TEST_CASE("chunked: empty iterable gives empty chunked", "[chunked]") {
     Vec ns{};
-    auto g = grouper(ns, 1);
+    auto g = chunked(ns, 1);
     REQUIRE( std::begin(g) == std::end(g) );
 }
 
-TEST_CASE("grouper: iterator meets requirements", "[grouper]") {
+TEST_CASE("chunked: iterator meets requirements", "[chunked]") {
     std::string s{};
-    auto c = grouper(s, 1);
+    auto c = chunked(s, 1);
     REQUIRE( itertest::IsIterator<decltype(std::begin(c))>::value );
 }

From 1f501304bfb2ab620972745f1758df9a49546469 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 20 Aug 2015 22:09:01 -0700
Subject: [PATCH 1236/1866] moves IMapper into impl { }

---
 imap.hpp | 125 +++++++++++++++++++++++++++----------------------------
 1 file changed, 61 insertions(+), 64 deletions(-)

diff --git a/imap.hpp b/imap.hpp
index c65a7035..54f82595 100644
--- a/imap.hpp
+++ b/imap.hpp
@@ -8,9 +8,7 @@
 #include <tuple>
 
 namespace iter {
-
   namespace detail {
-
     template <std::size_t Index, typename Functor, typename Tup>
     struct Expander {
       template <typename... Ts>
@@ -58,87 +56,86 @@ namespace iter {
 
   }  // end detail
 
-  // Forward declarations of IMap and imap
-  template <typename MapFunc, typename... Containers>
-  class IMap;
+  namespace impl {
+    template <typename MapFunc, typename... Containers>
+    class IMapper;
+  }
 
   template <typename MapFunc, typename... Containers>
-  IMap<MapFunc, Containers...> imap(MapFunc, Containers&&...);
+  impl::IMapper<MapFunc, Containers...> imap(MapFunc, Containers&&...);
+}
 
-  template <typename MapFunc, typename... Containers>
-  class IMap {
-    // The imap function is the only thing allowed to create a IMap
-    friend IMap imap<MapFunc, Containers...>(MapFunc, Containers&&...);
+template <typename MapFunc, typename... Containers>
+class iter::impl::IMapper {
+  // The imap function is the only thing allowed to create a IMapper
+  friend IMapper iter::imap<MapFunc, Containers...>(MapFunc, Containers&&...);
 
-    using ZippedType = decltype(zip(std::declval<Containers>()...));
-    using ZippedIterType = iterator_type<ZippedType>;
+  using ZippedType = decltype(zip(std::declval<Containers>()...));
+  using ZippedIterType = iterator_type<ZippedType>;
 
-   private:
-    MapFunc map_func;
-    ZippedType zipped;
+ private:
+  MapFunc map_func;
+  ZippedType zipped;
 
-    using IMapIterDeref =
-        decltype(detail::call_with_tuple(map_func, *std::begin(zipped)));
+  using IMapIterDeref =
+      decltype(detail::call_with_tuple(map_func, *std::begin(zipped)));
 
-    // Value constructor for use only in the imap function
-    IMap(MapFunc in_map_func, Containers&&... in_containers)
-        : map_func(in_map_func),
-          zipped(zip(std::forward<Containers>(in_containers)...)) {}
+  IMapper(MapFunc in_map_func, Containers&&... in_containers)
+      : map_func(in_map_func),
+        zipped(zip(std::forward<Containers>(in_containers)...)) {}
 
-   public:
-    class Iterator : public std::iterator<std::input_iterator_tag,
-                         typename std::remove_reference<IMapIterDeref>::type> {
-     private:
-      MapFunc* map_func;
-      ZippedIterType zipiter;
-
-     public:
-      Iterator(MapFunc& in_map_func, ZippedIterType&& in_zipiter)
-          : map_func(&in_map_func), zipiter(std::move(in_zipiter)) {}
-
-      IMapIterDeref operator*() {
-        return detail::call_with_tuple(*this->map_func, *(this->zipiter));
-      }
+ public:
+  class Iterator : public std::iterator<std::input_iterator_tag,
+                       typename std::remove_reference<IMapIterDeref>::type> {
+   private:
+    MapFunc* map_func;
+    ZippedIterType zipiter;
 
-      ArrowProxy<IMapIterDeref> operator->() {
-        return {**this};
-      }
+   public:
+    Iterator(MapFunc& in_map_func, ZippedIterType&& in_zipiter)
+        : map_func(&in_map_func), zipiter(std::move(in_zipiter)) {}
 
-      Iterator& operator++() {
-        ++this->zipiter;
-        return *this;
-      }
+    IMapIterDeref operator*() {
+      return detail::call_with_tuple(*this->map_func, *(this->zipiter));
+    }
 
-      Iterator operator++(int) {
-        auto ret = *this;
-        ++*this;
-        return ret;
-      }
+    ArrowProxy<IMapIterDeref> operator->() {
+      return {**this};
+    }
 
-      bool operator!=(const Iterator& other) const {
-        return this->zipiter != other.zipiter;
-      }
+    Iterator& operator++() {
+      ++this->zipiter;
+      return *this;
+    }
 
-      bool operator==(const Iterator& other) const {
-        return !(*this != other);
-      }
-    };
+    Iterator operator++(int) {
+      auto ret = *this;
+      ++*this;
+      return ret;
+    }
 
-    Iterator begin() {
-      return {this->map_func, this->zipped.begin()};
+    bool operator!=(const Iterator& other) const {
+      return this->zipiter != other.zipiter;
     }
 
-    Iterator end() {
-      return {this->map_func, this->zipped.end()};
+    bool operator==(const Iterator& other) const {
+      return !(*this != other);
     }
   };
 
-  // Helper function to instantiate a IMap
-  template <typename MapFunc, typename... Containers>
-  IMap<MapFunc, Containers...> imap(
-      MapFunc map_func, Containers&&... containers) {
-    return {map_func, std::forward<Containers>(containers)...};
+  Iterator begin() {
+    return {this->map_func, this->zipped.begin()};
   }
+
+  Iterator end() {
+    return {this->map_func, this->zipped.end()};
+  }
+};
+
+template <typename MapFunc, typename... Containers>
+iter::impl::IMapper<MapFunc, Containers...> iter::imap(
+    MapFunc map_func, Containers&&... containers) {
+  return {map_func, std::forward<Containers>(containers)...};
 }
 
-#endif  // #ifndef ITER_IMAP_H_
+#endif

From 877ef601dd38b36463e2997ece427f64ce230f3a Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 20 Aug 2015 22:16:50 -0700
Subject: [PATCH 1237/1866] makes Permuter ctor private, moves into impl { }

---
 permutations.hpp | 152 ++++++++++++++++++++++++++---------------------
 1 file changed, 84 insertions(+), 68 deletions(-)

diff --git a/permutations.hpp b/permutations.hpp
index 772c11d7..9e970121 100644
--- a/permutations.hpp
+++ b/permutations.hpp
@@ -11,95 +11,111 @@
 #include <iterator>
 
 namespace iter {
-
+  namespace impl {
+    template <typename Container>
+    class Permuter;
+  }
   template <typename Container>
-  class Permuter {
-   private:
-    Container container;
+  impl::Permuter<Container> permutations(Container&&);
 
-    using IndexVector = std::vector<iterator_type<Container>>;
-    using Permutable = IterIterWrapper<IndexVector>;
+  template <typename T>
+  impl::Permuter<std::initializer_list<T>> permutations(
+      std::initializer_list<T>);
+}
 
-   public:
-    Permuter(Container&& in_container)
-        : container(std::forward<Container>(in_container)) {}
-
-    class Iterator : public std::iterator<std::input_iterator_tag, Permutable> {
-     private:
-      static constexpr const int COMPLETE = -1;
-      static bool cmp_iters(const iterator_type<Container>& lhs,
-          const iterator_type<Container>& rhs) noexcept {
-        return *lhs < *rhs;
-      }
+template <typename Container>
+class iter::impl::Permuter {
+ private:
+  Container container;
 
-      Permutable working_set;
-      int steps{};
-
-     public:
-      Iterator(iterator_type<Container>&& sub_iter,
-          iterator_type<Container>&& sub_end)
-          : steps{sub_iter != sub_end ? 0 : COMPLETE} {
-        // done like this instead of using vector ctor with
-        // two iterators because that causes a substitution
-        // failure when the iterator is minimal
-        while (sub_iter != sub_end) {
-          this->working_set.get().push_back(sub_iter);
-          ++sub_iter;
-        }
-        std::sort(std::begin(working_set.get()), std::end(working_set.get()),
-            cmp_iters);
-      }
+  using IndexVector = std::vector<iterator_type<Container>>;
+  using Permutable = IterIterWrapper<IndexVector>;
 
-      Permutable& operator*() {
-        return this->working_set;
-      }
+  friend Permuter iter::permutations<Container>(Container&&);
+  template <typename T>
+  friend Permuter<std::initializer_list<T>> iter::permutations(
+      std::initializer_list<T>);
 
-      Permutable* operator->() {
-        return &this->working_set;
-      }
+  Permuter(Container&& in_container)
+      : container(std::forward<Container>(in_container)) {}
 
-      Iterator& operator++() {
-        ++this->steps;
-        if (!std::next_permutation(std::begin(working_set.get()),
-                std::end(working_set.get()), cmp_iters)) {
-          this->steps = COMPLETE;
-        }
-        return *this;
-      }
+ public:
+  class Iterator : public std::iterator<std::input_iterator_tag, Permutable> {
+   private:
+    static constexpr const int COMPLETE = -1;
+    static bool cmp_iters(const iterator_type<Container>& lhs,
+        const iterator_type<Container>& rhs) noexcept {
+      return *lhs < *rhs;
+    }
 
-      Iterator operator++(int) {
-        auto ret = *this;
-        ++*this;
-        return ret;
-      }
+    Permutable working_set;
+    int steps{};
 
-      bool operator!=(const Iterator& other) const {
-        return !(*this == other);
+   public:
+    Iterator(
+        iterator_type<Container>&& sub_iter, iterator_type<Container>&& sub_end)
+        : steps{sub_iter != sub_end ? 0 : COMPLETE} {
+      // done like this instead of using vector ctor with
+      // two iterators because that causes a substitution
+      // failure when the iterator is minimal
+      while (sub_iter != sub_end) {
+        this->working_set.get().push_back(sub_iter);
+        ++sub_iter;
       }
+      std::sort(std::begin(working_set.get()), std::end(working_set.get()),
+          cmp_iters);
+    }
+
+    Permutable& operator*() {
+      return this->working_set;
+    }
 
-      bool operator==(const Iterator& other) const {
-        return this->steps == other.steps;
+    Permutable* operator->() {
+      return &this->working_set;
+    }
+
+    Iterator& operator++() {
+      ++this->steps;
+      if (!std::next_permutation(std::begin(working_set.get()),
+              std::end(working_set.get()), cmp_iters)) {
+        this->steps = COMPLETE;
       }
-    };
+      return *this;
+    }
 
-    Iterator begin() {
-      return {std::begin(this->container), std::end(this->container)};
+    Iterator operator++(int) {
+      auto ret = *this;
+      ++*this;
+      return ret;
     }
 
-    Iterator end() {
-      return {std::end(this->container), std::end(this->container)};
+    bool operator!=(const Iterator& other) const {
+      return !(*this == other);
+    }
+
+    bool operator==(const Iterator& other) const {
+      return this->steps == other.steps;
     }
   };
 
-  template <typename Container>
-  Permuter<Container> permutations(Container&& container) {
-    return {std::forward<Container>(container)};
+  Iterator begin() {
+    return {std::begin(this->container), std::end(this->container)};
   }
 
-  template <typename T>
-  Permuter<std::initializer_list<T>> permutations(std::initializer_list<T> il) {
-    return {std::move(il)};
+  Iterator end() {
+    return {std::end(this->container), std::end(this->container)};
   }
+};
+
+template <typename Container>
+iter::impl::Permuter<Container> iter::permutations(Container&& container) {
+  return {std::forward<Container>(container)};
+}
+
+template <typename T>
+iter::impl::Permuter<std::initializer_list<T>> iter::permutations(
+    std::initializer_list<T> il) {
+  return {std::move(il)};
 }
 
 #endif

From 5a6aaaa079810b12e987c45b75178fcd63150506 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 20 Aug 2015 22:23:11 -0700
Subject: [PATCH 1238/1866] makes Powersetter ctor private, moves into impl {}

---
 powerset.hpp | 147 ++++++++++++++++++++++++++++-----------------------
 1 file changed, 82 insertions(+), 65 deletions(-)

diff --git a/powerset.hpp b/powerset.hpp
index dda2f4fe..d69d94d5 100644
--- a/powerset.hpp
+++ b/powerset.hpp
@@ -12,87 +12,104 @@
 #include <type_traits>
 
 namespace iter {
+  namespace impl {
+    template <typename Container>
+    class Powersetter;
+  }
   template <typename Container>
-  class Powersetter {
-   private:
-    Container container;
-    using CombinatorType =
-        decltype(combinations(std::declval<Container&>(), 0));
+  impl::Powersetter<Container> powerset(Container&&);
 
-   public:
-    Powersetter(Container&& in_container)
-        : container(std::forward<Container>(in_container)) {}
-
-    class Iterator
-        : public std::iterator<std::input_iterator_tag, CombinatorType> {
-     private:
-      typename std::remove_reference<Container>::type* container_p;
-      std::size_t set_size;
-      std::shared_ptr<CombinatorType> comb;
-      iterator_type<CombinatorType> comb_iter;
-      iterator_type<CombinatorType> comb_end;
-
-     public:
-      Iterator(Container& in_container, std::size_t sz)
-          : container_p{&in_container},
-            set_size{sz},
-            comb{new CombinatorType(combinations(in_container, sz))},
-            comb_iter{std::begin(*comb)},
-            comb_end{std::end(*comb)} {}
-
-      Iterator& operator++() {
-        ++this->comb_iter;
-        if (this->comb_iter == this->comb_end) {
-          ++this->set_size;
-          this->comb.reset(new CombinatorType(
-              combinations(*this->container_p, this->set_size)));
-          this->comb_iter = std::begin(*this->comb);
-          this->comb_end = std::end(*this->comb);
-        }
-        return *this;
-      }
+  template <typename T>
+  impl::Powersetter<std::initializer_list<T>> powerset(
+      std::initializer_list<T>);
+}
 
-      Iterator operator++(int) {
-        auto ret = *this;
-        ++*this;
-        return ret;
-      }
+template <typename Container>
+class iter::impl::Powersetter {
+ private:
+  Container container;
+  using CombinatorType = decltype(combinations(std::declval<Container&>(), 0));
 
-      iterator_deref<CombinatorType> operator*() {
-        return *this->comb_iter;
-      }
+  friend Powersetter iter::powerset<Container>(Container&&);
+  template <typename T>
+  friend Powersetter<std::initializer_list<T>> iter::powerset(
+      std::initializer_list<T>);
 
-      iterator_arrow<CombinatorType> operator->() {
-        apply_arrow(this->comb_iter);
-      }
+  Powersetter(Container&& in_container)
+      : container(std::forward<Container>(in_container)) {}
 
-      bool operator!=(const Iterator& other) const {
-        return !(*this == other);
-      }
+ public:
+  class Iterator
+      : public std::iterator<std::input_iterator_tag, CombinatorType> {
+   private:
+    typename std::remove_reference<Container>::type* container_p;
+    std::size_t set_size;
+    std::shared_ptr<CombinatorType> comb;
+    iterator_type<CombinatorType> comb_iter;
+    iterator_type<CombinatorType> comb_end;
 
-      bool operator==(const Iterator& other) const {
-        return this->set_size == other.set_size
-               && this->comb_iter == other.comb_iter;
+   public:
+    Iterator(Container& in_container, std::size_t sz)
+        : container_p{&in_container},
+          set_size{sz},
+          comb{new CombinatorType(combinations(in_container, sz))},
+          comb_iter{std::begin(*comb)},
+          comb_end{std::end(*comb)} {}
+
+    Iterator& operator++() {
+      ++this->comb_iter;
+      if (this->comb_iter == this->comb_end) {
+        ++this->set_size;
+        this->comb.reset(new CombinatorType(
+            combinations(*this->container_p, this->set_size)));
+        this->comb_iter = std::begin(*this->comb);
+        this->comb_end = std::end(*this->comb);
       }
-    };
+      return *this;
+    }
+
+    Iterator operator++(int) {
+      auto ret = *this;
+      ++*this;
+      return ret;
+    }
+
+    iterator_deref<CombinatorType> operator*() {
+      return *this->comb_iter;
+    }
+
+    iterator_arrow<CombinatorType> operator->() {
+      apply_arrow(this->comb_iter);
+    }
 
-    Iterator begin() {
-      return {this->container, 0};
+    bool operator!=(const Iterator& other) const {
+      return !(*this == other);
     }
 
-    Iterator end() {
-      return {this->container, dumb_size(this->container) + 1};
+    bool operator==(const Iterator& other) const {
+      return this->set_size == other.set_size
+             && this->comb_iter == other.comb_iter;
     }
   };
 
-  template <typename Container>
-  Powersetter<Container> powerset(Container&& container) {
-    return {std::forward<Container>(container)};
+  Iterator begin() {
+    return {this->container, 0};
   }
 
-  template <typename T>
-  Powersetter<std::initializer_list<T>> powerset(std::initializer_list<T> il) {
-    return {std::move(il)};
+  Iterator end() {
+    return {this->container, dumb_size(this->container) + 1};
   }
+};
+
+template <typename Container>
+iter::impl::Powersetter<Container> iter::powerset(Container&& container) {
+  return {std::forward<Container>(container)};
 }
+
+template <typename T>
+iter::impl::Powersetter<std::initializer_list<T>> iter::powerset(
+    std::initializer_list<T> il) {
+  return {std::move(il)};
+}
+
 #endif

From b0595940a6c0f217c8223fa5d6f25044dc3e0f1e Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 20 Aug 2015 22:32:06 -0700
Subject: [PATCH 1239/1866] moves Productor into impl { }

---
 product.hpp | 219 +++++++++++++++++++++++++++-------------------------
 1 file changed, 113 insertions(+), 106 deletions(-)

diff --git a/product.hpp b/product.hpp
index 77f01e33..c8b41a64 100644
--- a/product.hpp
+++ b/product.hpp
@@ -9,151 +9,158 @@
 #include <array>
 
 namespace iter {
-  template <typename... RestContainers>
-  class Productor;
+  namespace impl {
+    template <typename... Containers>
+    class Productor;
 
-  template <typename... Containers>
-  Productor<Containers...> product(Containers&&...);
+    template <typename Container, typename... RestContainers>
+    class Productor<Container, RestContainers...>;
 
-  // specialization for at least 1 template argument
-  template <typename Container, typename... RestContainers>
-  class Productor<Container, RestContainers...> {
-    static_assert(!std::is_rvalue_reference<Container>::value,
-        "Itertools cannot be templated with rvalue references");
+    template <>
+    class Productor<>;
+  }
 
-    friend Productor product<Container, RestContainers...>(
-        Container&&, RestContainers&&...);
+  template <typename... Containers>
+  impl::Productor<Containers...> product(Containers&&...);
+}
 
-    template <typename... RC>
-    friend class Productor;
+// specialization for at least 1 template argument
+template <typename Container, typename... RestContainers>
+class iter::impl::Productor<Container, RestContainers...> {
+  static_assert(!std::is_rvalue_reference<Container>::value,
+      "Itertools cannot be templated with rvalue references");
 
-    using ProdIterDeref = std::tuple<iterator_deref<Container>,
-        iterator_deref<RestContainers>...>;
+  friend Productor iter::product<Container, RestContainers...>(
+      Container&&, RestContainers&&...);
 
-   private:
-    Container container;
-    Productor<RestContainers...> rest_products;
-    Productor(Container&& in_container, RestContainers&&... rest)
-        : container(std::forward<Container>(in_container)),
-          rest_products{std::forward<RestContainers>(rest)...} {}
+  template <typename... RC>
+  friend class Productor;
 
-   public:
-    class Iterator
-        : public std::iterator<std::input_iterator_tag, ProdIterDeref> {
-     private:
-      using RestIter = typename Productor<RestContainers...>::Iterator;
+  using ProdIterDeref =
+      std::tuple<iterator_deref<Container>, iterator_deref<RestContainers>...>;
 
-      iterator_type<Container> iter;
-      iterator_type<Container> begin;
+ private:
+  Container container;
+  Productor<RestContainers...> rest_products;
+  Productor(Container&& in_container, RestContainers&&... rest)
+      : container(std::forward<Container>(in_container)),
+        rest_products{std::forward<RestContainers>(rest)...} {}
 
-      RestIter rest_iter;
-      RestIter rest_end;
+ public:
+  class Iterator
+      : public std::iterator<std::input_iterator_tag, ProdIterDeref> {
+   private:
+    using RestIter = typename Productor<RestContainers...>::Iterator;
 
-     public:
-      constexpr static const bool is_base_iter = false;
-      Iterator(const iterator_type<Container>& it, RestIter&& rest,
-          RestIter&& in_rest_end)
-          : iter{it}, begin{it}, rest_iter{rest}, rest_end{in_rest_end} {}
+    iterator_type<Container> iter;
+    iterator_type<Container> begin;
 
-      void reset() {
-        this->iter = this->begin;
-      }
+    RestIter rest_iter;
+    RestIter rest_end;
 
-      Iterator& operator++() {
-        ++this->rest_iter;
-        if (!(this->rest_iter != this->rest_end)) {
-          this->rest_iter.reset();
-          ++this->iter;
-        }
-        return *this;
-      }
+   public:
+    constexpr static const bool is_base_iter = false;
+    Iterator(const iterator_type<Container>& it, RestIter&& rest,
+        RestIter&& in_rest_end)
+        : iter{it}, begin{it}, rest_iter{rest}, rest_end{in_rest_end} {}
 
-      Iterator operator++(int) {
-        auto ret = *this;
-        ++*this;
-        return ret;
-      }
+    void reset() {
+      this->iter = this->begin;
+    }
 
-      bool operator!=(const Iterator& other) const {
-        return this->iter != other.iter
-               && (RestIter::is_base_iter
-                      || this->rest_iter != other.rest_iter);
+    Iterator& operator++() {
+      ++this->rest_iter;
+      if (!(this->rest_iter != this->rest_end)) {
+        this->rest_iter.reset();
+        ++this->iter;
       }
+      return *this;
+    }
 
-      bool operator==(const Iterator& other) const {
-        return !(*this != other);
-      }
+    Iterator operator++(int) {
+      auto ret = *this;
+      ++*this;
+      return ret;
+    }
 
-      ProdIterDeref operator*() {
-        return std::tuple_cat(
-            std::tuple<iterator_deref<Container>>{*this->iter},
-            *this->rest_iter);
-      }
+    bool operator!=(const Iterator& other) const {
+      return this->iter != other.iter
+             && (RestIter::is_base_iter || this->rest_iter != other.rest_iter);
+    }
 
-      ArrowProxy<ProdIterDeref> operator->() {
-        return {**this};
-      }
-    };
+    bool operator==(const Iterator& other) const {
+      return !(*this != other);
+    }
 
-    Iterator begin() {
-      return {std::begin(this->container), std::begin(this->rest_products),
-          std::end(this->rest_products)};
+    ProdIterDeref operator*() {
+      return std::tuple_cat(
+          std::tuple<iterator_deref<Container>>{*this->iter}, *this->rest_iter);
     }
 
-    Iterator end() {
-      return {std::end(this->container), std::end(this->rest_products),
-          std::end(this->rest_products)};
+    ArrowProxy<ProdIterDeref> operator->() {
+      return {**this};
     }
   };
 
-  template <>
-  class Productor<> {
-   public:
-    class Iterator
-        : public std::iterator<std::input_iterator_tag, std::tuple<>> {
-     public:
-      constexpr static const bool is_base_iter = true;
+  Iterator begin() {
+    return {std::begin(this->container), std::begin(this->rest_products),
+        std::end(this->rest_products)};
+  }
 
-      void reset() {}
+  Iterator end() {
+    return {std::end(this->container), std::end(this->rest_products),
+        std::end(this->rest_products)};
+  }
+};
 
-      Iterator& operator++() {
-        return *this;
-      }
+template <>
+class iter::impl::Productor<> {
+ public:
+  class Iterator : public std::iterator<std::input_iterator_tag, std::tuple<>> {
+   public:
+    constexpr static const bool is_base_iter = true;
 
-      Iterator operator++(int) {
-        auto ret = *this;
-        ++*this;
-        return ret;
-      }
+    void reset() {}
 
-      // see note in zip about base case operator!=
-      bool operator!=(const Iterator&) const {
-        return false;
-      }
+    Iterator& operator++() {
+      return *this;
+    }
 
-      bool operator==(const Iterator& other) const {
-        return !(*this != other);
-      }
+    Iterator operator++(int) {
+      auto ret = *this;
+      ++*this;
+      return ret;
+    }
 
-      std::tuple<> operator*() const {
-        return {};
-      }
-    };
+    // see note in zip about base case operator!=
+    bool operator!=(const Iterator&) const {
+      return false;
+    }
 
-    Iterator begin() {
-      return {};
+    bool operator==(const Iterator& other) const {
+      return !(*this != other);
     }
 
-    Iterator end() {
+    std::tuple<> operator*() const {
       return {};
     }
   };
 
-  template <typename... Containers>
-  Productor<Containers...> product(Containers&&... containers) {
-    return {std::forward<Containers>(containers)...};
+  Iterator begin() {
+    return {};
   }
 
+  Iterator end() {
+    return {};
+  }
+};
+
+template <typename... Containers>
+iter::impl::Productor<Containers...> iter::product(Containers&&... containers) {
+  return {std::forward<Containers>(containers)...};
+}
+
+namespace iter {
   constexpr std::array<std::tuple<>, 1> product() {
     return {{}};
   }

From 0a067822cb2098ab38325784bc857ad6974bf1df Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 20 Aug 2015 22:40:51 -0700
Subject: [PATCH 1240/1866] moves Range into impl { }

---
 range.hpp | 384 +++++++++++++++++++++++++++---------------------------
 1 file changed, 195 insertions(+), 189 deletions(-)

diff --git a/range.hpp b/range.hpp
index fb955e02..90465250 100644
--- a/range.hpp
+++ b/range.hpp
@@ -9,238 +9,244 @@
 #include <cassert>
 
 namespace iter {
+  namespace impl {
+    template <typename T>
+    class Range;
+  }
 
-  template <typename T, bool IsFloat = std::is_floating_point<T>::value>
-  class RangeIterData;
-
-  // everything except floats
   template <typename T>
-  class RangeIterData<T, false> {
-   private:
-    T value_{};
-    T step_{};
-
-   public:
-    constexpr RangeIterData() noexcept = default;
-    constexpr RangeIterData(T in_value, T in_step) noexcept : value_{in_value},
-                                                              step_{in_step} {}
+  constexpr impl::Range<T> range(T) noexcept;
+  template <typename T>
+  constexpr impl::Range<T> range(T, T) noexcept;
+  template <typename T>
+  constexpr impl::Range<T> range(T, T, T) noexcept;
+}
 
-    constexpr T value() const noexcept {
-      return this->value_;
-    }
+namespace iter {
+  namespace detail {
+    template <typename T, bool IsFloat = std::is_floating_point<T>::value>
+    class RangeIterData;
 
-    constexpr T step() const noexcept {
-      return this->step_;
-    }
+    // everything except floats
+    template <typename T>
+    class RangeIterData<T, false> {
+     private:
+      T value_{};
+      T step_{};
 
-    void inc() noexcept {
-      this->value_ += step_;
-    }
+     public:
+      constexpr RangeIterData() noexcept = default;
+      constexpr RangeIterData(T in_value, T in_step) noexcept
+          : value_{in_value},
+            step_{in_step} {}
 
-    constexpr bool operator==(const RangeIterData& other) const noexcept {
-      return this->value_ == other.value_;
-    }
+      constexpr T value() const noexcept {
+        return this->value_;
+      }
 
-    constexpr bool operator!=(const RangeIterData& other) const noexcept {
-      return !(*this == other);
-    }
-  };
+      constexpr T step() const noexcept {
+        return this->step_;
+      }
 
-  // float data
-  template <typename T>
-  class RangeIterData<T, true> {
-   private:
-    T start_{};
-    T value_{};
-    T step_{};
-    unsigned long steps_taken{};
+      void inc() noexcept {
+        this->value_ += step_;
+      }
 
-   public:
-    constexpr RangeIterData() noexcept = default;
-    constexpr RangeIterData(T in_start, T in_step) noexcept : start_{in_start},
-                                                              value_{in_start},
-                                                              step_{in_step} {}
+      constexpr bool operator==(const RangeIterData& other) const noexcept {
+        return this->value_ == other.value_;
+      }
 
-    constexpr T value() const noexcept {
-      return this->value_;
-    }
+      constexpr bool operator!=(const RangeIterData& other) const noexcept {
+        return !(*this == other);
+      }
+    };
 
-    constexpr T step() const noexcept {
-      return this->step_;
-    }
+    // float data
+    template <typename T>
+    class RangeIterData<T, true> {
+     private:
+      T start_{};
+      T value_{};
+      T step_{};
+      unsigned long steps_taken{};
 
-    void inc() noexcept {
-      ++this->steps_taken;
-      value_ = this->start_ + (this->step_ * this->steps_taken);
-    }
+     public:
+      constexpr RangeIterData() noexcept = default;
+      constexpr RangeIterData(T in_start, T in_step) noexcept
+          : start_{in_start},
+            value_{in_start},
+            step_{in_step} {}
+
+      constexpr T value() const noexcept {
+        return this->value_;
+      }
 
-    constexpr bool operator==(const RangeIterData& other) const noexcept {
-      // if the difference between the two values is less than the
-      // step size, they are considered equal
-      return (this->value_ < other.value_ ? other.value_ - this->value_
-                                          : this->value_ - other.value_)
-             < this->step_;
-    }
+      constexpr T step() const noexcept {
+        return this->step_;
+      }
 
-    constexpr bool operator!=(const RangeIterData& other) const noexcept {
-      return !(*this == other);
-    }
-  };
+      void inc() noexcept {
+        ++this->steps_taken;
+        value_ = this->start_ + (this->step_ * this->steps_taken);
+      }
 
-  template <typename T>
-  class Range;
+      constexpr bool operator==(const RangeIterData& other) const noexcept {
+        // if the difference between the two values is less than the
+        // step size, they are considered equal
+        return (this->value_ < other.value_ ? other.value_ - this->value_
+                                            : this->value_ - other.value_)
+               < this->step_;
+      }
 
-  template <typename T>
-  constexpr Range<T> range(T) noexcept;
-  template <typename T>
-  constexpr Range<T> range(T, T) noexcept;
-  template <typename T>
-  constexpr Range<T> range(T, T, T) noexcept;
+      constexpr bool operator!=(const RangeIterData& other) const noexcept {
+        return !(*this == other);
+      }
+    };
+  }
+}
 
-  // General version for everything not a float
-  template <typename T>
-  class Range {
-    friend Range range<T>(T);
-    friend Range range<T>(T, T);
-    friend Range range<T>(T, T, T);
+template <typename T>
+class iter::impl::Range {
+  friend Range iter::range<T>(T);
+  friend Range iter::range<T>(T, T);
+  friend Range iter::range<T>(T, T, T);
 
-   private:
-    const T start;
-    const T stop;
-    const T step;
+ private:
+  const T start;
+  const T stop;
+  const T step;
 
-    constexpr Range(T in_stop) noexcept : start{0}, stop{in_stop}, step{1} {}
+  constexpr Range(T in_stop) noexcept : start{0}, stop{in_stop}, step{1} {}
 
-    constexpr Range(T in_start, T in_stop, T in_step = 1) noexcept
-        : start{in_start},
-          stop{in_stop},
-          step{in_step} {}
+  constexpr Range(T in_start, T in_stop, T in_step = 1) noexcept
+      : start{in_start},
+        stop{in_stop},
+        step{in_step} {}
 
-   public:
-    // the reference type here is T, which doesn't strictly follow all
-    // of the rules, but std::vector<bool>::iterator::reference isn't
-    // a reference type either, this isn't any worse
+ public:
+  // the reference type here is T, which doesn't strictly follow all
+  // of the rules, but std::vector<bool>::iterator::reference isn't
+  // a reference type either, this isn't any worse
 
-    class Iterator : public std::iterator<std::forward_iterator_tag, T,
-                         std::ptrdiff_t, T*, T> {
-     private:
-      RangeIterData<T> data;
-      bool is_end;
-
-      // compare unsigned values
-      static bool not_equal_to_impl(const Iterator& iter,
-          const Iterator& end_iter, std::true_type) noexcept {
-        assert(!iter.is_end);
-        assert(end_iter.is_end);
-        return iter.data.value() < end_iter.data.value();
-      }
+  class Iterator : public std::iterator<std::forward_iterator_tag, T,
+                       std::ptrdiff_t, T*, T> {
+   private:
+     detail::RangeIterData<T> data;
+    bool is_end;
+
+    // compare unsigned values
+    static bool not_equal_to_impl(const Iterator& iter,
+        const Iterator& end_iter, std::true_type) noexcept {
+      assert(!iter.is_end);
+      assert(end_iter.is_end);
+      return iter.data.value() < end_iter.data.value();
+    }
 
-      // compare signed values
-      static bool not_equal_to_impl(const Iterator& iter,
-          const Iterator& end_iter, std::false_type) noexcept {
-        assert(!iter.is_end);
-        assert(end_iter.is_end);
-        return !(iter.data.step() > 0
-                   && iter.data.value() >= end_iter.data.value())
-               && !(iter.data.step() < 0
-                      && iter.data.value() <= end_iter.data.value());
-      }
+    // compare signed values
+    static bool not_equal_to_impl(const Iterator& iter,
+        const Iterator& end_iter, std::false_type) noexcept {
+      assert(!iter.is_end);
+      assert(end_iter.is_end);
+      return !(iter.data.step() > 0
+                 && iter.data.value() >= end_iter.data.value())
+             && !(iter.data.step() < 0
+                    && iter.data.value() <= end_iter.data.value());
+    }
 
-      static bool not_equal_to_end(
-          const Iterator& lhs, const Iterator& rhs) noexcept {
-        if (rhs.is_end) {
-          return not_equal_to_impl(lhs, rhs, std::is_unsigned<T>{});
-        } else {
-          return not_equal_to_impl(rhs, lhs, std::is_unsigned<T>{});
-        }
+    static bool not_equal_to_end(
+        const Iterator& lhs, const Iterator& rhs) noexcept {
+      if (rhs.is_end) {
+        return not_equal_to_impl(lhs, rhs, std::is_unsigned<T>{});
+      } else {
+        return not_equal_to_impl(rhs, lhs, std::is_unsigned<T>{});
       }
+    }
 
-     public:
-      constexpr Iterator() noexcept = default;
+   public:
+    constexpr Iterator() noexcept = default;
 
-      constexpr Iterator(T in_value, T in_step, bool in_is_end) noexcept
-          : data(in_value, in_step),
-            is_end{in_is_end} {}
+    constexpr Iterator(T in_value, T in_step, bool in_is_end) noexcept
+        : data(in_value, in_step),
+          is_end{in_is_end} {}
 
-      constexpr T operator*() const noexcept {
-        return this->data.value();
-      }
+    constexpr T operator*() const noexcept {
+      return this->data.value();
+    }
 
-      constexpr ArrowProxy<T> operator->() const noexcept {
-        return {**this};
-      }
+    constexpr ArrowProxy<T> operator->() const noexcept {
+      return {**this};
+    }
 
-      Iterator& operator++() noexcept {
-        this->data.inc();
-        return *this;
-      }
+    Iterator& operator++() noexcept {
+      this->data.inc();
+      return *this;
+    }
 
-      Iterator operator++(int) noexcept {
-        auto ret = *this;
-        ++*this;
-        return ret;
-      }
+    Iterator operator++(int) noexcept {
+      auto ret = *this;
+      ++*this;
+      return ret;
+    }
 
-      // This operator would more accurately read as "in bounds"
-      // or "incomplete" because exact comparison with the end
-      // isn't good enough for the purposes of this Iterator.
-      // There are two odd cases that need to be handled
-      //
-      // 1) The Range is infinite, such as
-      // Range (-1, 0, -1) which would go forever down toward
-      // infinitely (theoretically).  If this occurs, the Range
-      // will instead effectively be empty
-      //
-      // 2) (stop - start) % step != 0.  For
-      // example Range(1, 10, 2).  The iterator will never be
-      // exactly equal to the stop value.
-      //
-      // Another way to think about it is that the "end"
-      // iterator represents the range of values that are invalid
-      // So, if an iterator is not equal to that, it is valid
-      //
-      // Two end iterators will compare equal
-      //
-      // Two non-end iterators will compare by their stored values
-      bool operator!=(const Iterator& other) const noexcept {
-        if (this->is_end && other.is_end) {
-          return false;
-        }
-
-        if (!this->is_end && !other.is_end) {
-          return this->data != other.data;
-        }
-        return not_equal_to_end(*this, other);
+    // This operator would more accurately read as "in bounds"
+    // or "incomplete" because exact comparison with the end
+    // isn't good enough for the purposes of this Iterator.
+    // There are two odd cases that need to be handled
+    //
+    // 1) The Range is infinite, such as
+    // Range (-1, 0, -1) which would go forever down toward
+    // infinitely (theoretically).  If this occurs, the Range
+    // will instead effectively be empty
+    //
+    // 2) (stop - start) % step != 0.  For
+    // example Range(1, 10, 2).  The iterator will never be
+    // exactly equal to the stop value.
+    //
+    // Another way to think about it is that the "end"
+    // iterator represents the range of values that are invalid
+    // So, if an iterator is not equal to that, it is valid
+    //
+    // Two end iterators will compare equal
+    //
+    // Two non-end iterators will compare by their stored values
+    bool operator!=(const Iterator& other) const noexcept {
+      if (this->is_end && other.is_end) {
+        return false;
       }
 
-      bool operator==(const Iterator& other) const noexcept {
-        return !(*this != other);
+      if (!this->is_end && !other.is_end) {
+        return this->data != other.data;
       }
-    };
-
-    constexpr Iterator begin() const noexcept {
-      return {start, step, false};
+      return not_equal_to_end(*this, other);
     }
 
-    constexpr Iterator end() const noexcept {
-      return {stop, step, true};
+    bool operator==(const Iterator& other) const noexcept {
+      return !(*this != other);
     }
   };
 
-  template <typename T>
-  constexpr Range<T> range(T stop) noexcept {
-    return {stop};
+  constexpr Iterator begin() const noexcept {
+    return {start, step, false};
   }
 
-  template <typename T>
-  constexpr Range<T> range(T start, T stop) noexcept {
-    return {start, stop};
+  constexpr Iterator end() const noexcept {
+    return {stop, step, true};
   }
+};
 
-  template <typename T>
-  constexpr Range<T> range(T start, T stop, T step) noexcept {
-    return step == T(0) ? Range<T>{0} : Range<T>{start, stop, step};
-  }
+template <typename T>
+constexpr iter::impl::Range<T> iter::range(T stop) noexcept {
+  return {stop};
+}
+
+template <typename T>
+constexpr iter::impl::Range<T> iter::range(T start, T stop) noexcept {
+  return {start, stop};
+}
+
+template <typename T>
+constexpr iter::impl::Range<T> iter::range(T start, T stop, T step) noexcept {
+  return step == T(0) ? impl::Range<T>{0} : impl::Range<T>{start, stop, step};
 }
 
-#endif  // #ifndef ITER_RANGE_H_
+#endif

From 2c3d34b52b1eb2c2dc67ea312d6764d72533cfd9 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 20 Aug 2015 22:44:00 -0700
Subject: [PATCH 1241/1866] moves Repeater[WithCount] into impl { }

---
 range.hpp  |   2 +-
 repeat.hpp | 202 +++++++++++++++++++++++++++--------------------------
 2 files changed, 104 insertions(+), 100 deletions(-)

diff --git a/range.hpp b/range.hpp
index 90465250..0262c7ed 100644
--- a/range.hpp
+++ b/range.hpp
@@ -131,7 +131,7 @@ class iter::impl::Range {
   class Iterator : public std::iterator<std::forward_iterator_tag, T,
                        std::ptrdiff_t, T*, T> {
    private:
-     detail::RangeIterData<T> data;
+    detail::RangeIterData<T> data;
     bool is_end;
 
     // compare unsigned values
diff --git a/repeat.hpp b/repeat.hpp
index b2ba8ff7..bf65c2bd 100644
--- a/repeat.hpp
+++ b/repeat.hpp
@@ -6,140 +6,144 @@
 #include <utility>
 
 namespace iter {
-  template <typename T>
-  class RepeaterWithCount;
+  namespace impl {
+    template <typename T>
+    class RepeaterWithCount;
+  }
 
   template <typename T>
-  constexpr RepeaterWithCount<T> repeat(T&&, int);
+  constexpr impl::RepeaterWithCount<T> repeat(T&&, int);
+}
 
-  template <typename T>
-  class RepeaterWithCount {
-    friend RepeaterWithCount repeat<T>(T&&, int);
+template <typename T>
+class iter::impl::RepeaterWithCount {
+  friend RepeaterWithCount iter::repeat<T>(T&&, int);
+
+ private:
+  T elem;
+  int count;
 
+  constexpr RepeaterWithCount(T e, int c)
+      : elem(std::forward<T>(e)), count{c} {}
+
+  using TPlain = typename std::remove_reference<T>::type;
+
+ public:
+  class Iterator : public std::iterator<std::input_iterator_tag, const TPlain> {
    private:
-    T elem;
+    const TPlain* elem;
     int count;
 
-    constexpr RepeaterWithCount(T e, int c)
-        : elem(std::forward<T>(e)), count{c} {}
+   public:
+    constexpr Iterator(const TPlain* e, int c) : elem{e}, count{c} {}
 
-    using TPlain = typename std::remove_reference<T>::type;
+    Iterator& operator++() {
+      --this->count;
+      return *this;
+    }
 
-   public:
-    class Iterator
-        : public std::iterator<std::input_iterator_tag, const TPlain> {
-     private:
-      const TPlain* elem;
-      int count;
-
-     public:
-      constexpr Iterator(const TPlain* e, int c) : elem{e}, count{c} {}
-
-      Iterator& operator++() {
-        --this->count;
-        return *this;
-      }
-
-      Iterator operator++(int) {
-        auto ret = *this;
-        ++*this;
-        return ret;
-      }
-
-      constexpr bool operator!=(const Iterator& other) const {
-        return !(*this == other);
-      }
-
-      constexpr bool operator==(const Iterator& other) const {
-        return this->count == other.count;
-      }
-
-      constexpr const TPlain& operator*() const {
-        return *this->elem;
-      }
-
-      constexpr const TPlain* operator->() const {
-        return this->elem;
-      }
-    };
-
-    constexpr Iterator begin() {
-      return {&this->elem, this->count};
+    Iterator operator++(int) {
+      auto ret = *this;
+      ++*this;
+      return ret;
     }
 
-    constexpr Iterator end() {
-      return {&this->elem, 0};
+    constexpr bool operator!=(const Iterator& other) const {
+      return !(*this == other);
+    }
+
+    constexpr bool operator==(const Iterator& other) const {
+      return this->count == other.count;
+    }
+
+    constexpr const TPlain& operator*() const {
+      return *this->elem;
+    }
+
+    constexpr const TPlain* operator->() const {
+      return this->elem;
     }
   };
 
-  template <typename T>
-  constexpr RepeaterWithCount<T> repeat(T&& e, int count) {
-    return {std::forward<T>(e), count < 0 ? 0 : count};
+  constexpr Iterator begin() {
+    return {&this->elem, this->count};
   }
 
-  template <typename T>
-  class Repeater;
+  constexpr Iterator end() {
+    return {&this->elem, 0};
+  }
+};
 
-  template <typename T>
-  constexpr Repeater<T> repeat(T&&);
+template <typename T>
+constexpr iter::impl::RepeaterWithCount<T> iter::repeat(T&& e, int count) {
+  return {std::forward<T>(e), count < 0 ? 0 : count};
+}
 
-  template <typename T>
-  class Repeater {
-    friend Repeater repeat<T>(T&&);
+namespace iter {
+  namespace impl {
+    template <typename T>
+    class Repeater;
+  }
 
-   private:
-    using TPlain = typename std::remove_reference<T>::type;
-    T elem;
+  template <typename T>
+  constexpr impl::Repeater<T> repeat(T&&);
+}
 
-    constexpr Repeater(T e) : elem(std::forward<T>(e)) {}
+template <typename T>
+class iter::impl::Repeater {
+  friend Repeater iter::repeat<T>(T&&);
 
-   public:
-    class Iterator
-        : public std::iterator<std::input_iterator_tag, const TPlain> {
-     private:
-      const TPlain* elem;
+ private:
+  using TPlain = typename std::remove_reference<T>::type;
+  T elem;
 
-     public:
-      constexpr Iterator(const TPlain* e) : elem{e} {}
+  constexpr Repeater(T e) : elem(std::forward<T>(e)) {}
 
-      constexpr const Iterator& operator++() const {
-        return *this;
-      }
+ public:
+  class Iterator : public std::iterator<std::input_iterator_tag, const TPlain> {
+   private:
+    const TPlain* elem;
 
-      constexpr Iterator operator++(int) const {
-        return *this;
-      }
+   public:
+    constexpr Iterator(const TPlain* e) : elem{e} {}
 
-      constexpr bool operator!=(const Iterator&) const {
-        return true;
-      }
+    constexpr const Iterator& operator++() const {
+      return *this;
+    }
 
-      constexpr bool operator==(const Iterator&) const {
-        return false;
-      }
+    constexpr Iterator operator++(int) const {
+      return *this;
+    }
 
-      constexpr const TPlain& operator*() const {
-        return *this->elem;
-      }
+    constexpr bool operator!=(const Iterator&) const {
+      return true;
+    }
 
-      constexpr const TPlain* operator->() const {
-        return this->elem;
-      }
-    };
+    constexpr bool operator==(const Iterator&) const {
+      return false;
+    }
 
-    constexpr Iterator begin() {
-      return {&this->elem};
+    constexpr const TPlain& operator*() const {
+      return *this->elem;
     }
 
-    constexpr Iterator end() {
-      return {nullptr};
+    constexpr const TPlain* operator->() const {
+      return this->elem;
     }
   };
 
-  template <typename T>
-  constexpr Repeater<T> repeat(T&& e) {
-    return {std::forward<T>(e)};
+  constexpr Iterator begin() {
+    return {&this->elem};
+  }
+
+  constexpr Iterator end() {
+    return {nullptr};
   }
+};
+
+template <typename T>
+constexpr iter::impl::Repeater<T> iter::repeat(T&& e) {
+  return {std::forward<T>(e)};
 }
 
 #endif

From bbdbd6fbc955477ae325363ef71eb0bcd5f026cf Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 20 Aug 2015 22:51:43 -0700
Subject: [PATCH 1242/1866] moves Reverser into impl { }

---
 reversed.hpp | 222 ++++++++++++++++++++++++++-------------------------
 1 file changed, 113 insertions(+), 109 deletions(-)

diff --git a/reversed.hpp b/reversed.hpp
index ccc63470..711890de 100644
--- a/reversed.hpp
+++ b/reversed.hpp
@@ -7,138 +7,142 @@
 #include <iterator>
 
 namespace iter {
-  template <typename Container>
-  class Reverser;
+  namespace impl {
+    template <typename Container>
+    class Reverser;
 
-  template <typename Container>
-  Reverser<Container> reversed(Container&&);
+    template <typename T, std::size_t N>
+    class Reverser<T[N]>;
+  }
 
   template <typename Container>
-  class Reverser {
-   private:
-    Container container;
-    friend Reverser reversed<Container>(Container&&);
+  impl::Reverser<Container> reversed(Container&&);
 
-    Reverser(Container&& in_container)
-        : container(std::forward<Container>(in_container)) {}
+  template <typename T, std::size_t N>
+  impl::Reverser<T[N]> reversed(T(&)[N]);
+}
+
+template <typename Container>
+class iter::impl::Reverser {
+ private:
+  Container container;
+  friend Reverser iter::reversed<Container>(Container&&);
+
+  Reverser(Container&& in_container)
+      : container(std::forward<Container>(in_container)) {}
+
+ public:
+  class Iterator : public std::iterator<std::input_iterator_tag,
+                       iterator_traits_deref<Container>> {
+   private:
+    reverse_iterator_type<Container> sub_iter;
 
    public:
-    class Iterator : public std::iterator<std::input_iterator_tag,
-                         iterator_traits_deref<Container>> {
-     private:
-      reverse_iterator_type<Container> sub_iter;
-
-     public:
-      Iterator(reverse_iterator_type<Container>&& iter)
-          : sub_iter{std::move(iter)} {}
-
-      reverse_iterator_deref<Container> operator*() {
-        return *this->sub_iter;
-      }
-
-      reverse_iterator_arrow<Container> operator->() {
-        return apply_arrow(this->sub_iter);
-      }
-
-      Iterator& operator++() {
-        ++this->sub_iter;
-        return *this;
-      }
-
-      Iterator operator++(int) {
-        auto ret = *this;
-        ++*this;
-        return ret;
-      }
-
-      bool operator!=(const Iterator& other) const {
-        return this->sub_iter != other.sub_iter;
-      }
-
-      bool operator==(const Iterator& other) const {
-        return !(*this != other);
-      }
-    };
-
-    Iterator begin() {
-      return {this->container.rbegin()};
+    Iterator(reverse_iterator_type<Container>&& iter)
+        : sub_iter{std::move(iter)} {}
+
+    reverse_iterator_deref<Container> operator*() {
+      return *this->sub_iter;
     }
 
-    Iterator end() {
-      return {this->container.rend()};
+    reverse_iterator_arrow<Container> operator->() {
+      return apply_arrow(this->sub_iter);
+    }
+
+    Iterator& operator++() {
+      ++this->sub_iter;
+      return *this;
+    }
+
+    Iterator operator++(int) {
+      auto ret = *this;
+      ++*this;
+      return ret;
+    }
+
+    bool operator!=(const Iterator& other) const {
+      return this->sub_iter != other.sub_iter;
+    }
+
+    bool operator==(const Iterator& other) const {
+      return !(*this != other);
     }
   };
 
-  template <typename Container>
-  Reverser<Container> reversed(Container&& container) {
-    return {std::forward<Container>(container)};
+  Iterator begin() {
+    return {this->container.rbegin()};
   }
 
-  //
-  // specialization for statically allocated arrays
-  //
-  template <typename T, std::size_t N>
-  Reverser<T[N]> reversed(T(&)[N]);
+  Iterator end() {
+    return {this->container.rend()};
+  }
+};
 
-  template <typename T, std::size_t N>
-  class Reverser<T[N]> {
-   private:
-    T* array;
-    friend Reverser reversed<T, N>(T(&)[N]);
+template <typename Container>
+iter::impl::Reverser<Container> iter::reversed(Container&& container) {
+  return {std::forward<Container>(container)};
+}
+
+// specialization for statically allocated arrays
+
+template <typename T, std::size_t N>
+class iter::impl::Reverser<T[N]> {
+ private:
+  T* array;
+  friend Reverser iter::reversed<T, N>(T(&)[N]);
 
-    // Value constructor for use only in the reversed function
-    Reverser(T* in_array) : array{in_array} {}
+  // Value constructor for use only in the reversed function
+  Reverser(T* in_array) : array{in_array} {}
+
+ public:
+  Reverser(const Reverser&) = default;
+  class Iterator : public std::iterator<std::input_iterator_tag, T> {
+   private:
+    T* sub_iter;
 
    public:
-    Reverser(const Reverser&) = default;
-    class Iterator : public std::iterator<std::input_iterator_tag, T> {
-     private:
-      T* sub_iter;
-
-     public:
-      Iterator(T* iter) : sub_iter{iter} {}
-
-      T& operator*() {
-        return *(this->sub_iter - 1);
-      }
-
-      T* operator->() {
-        return (this->sub_iter - 1);
-      }
-
-      Iterator& operator++() {
-        --this->sub_iter;
-        return *this;
-      }
-
-      Iterator operator++(int) {
-        auto ret = *this;
-        ++*this;
-        return ret;
-      }
-
-      bool operator!=(const Iterator& other) const {
-        return this->sub_iter != other.sub_iter;
-      }
-
-      bool operator==(const Iterator& other) const {
-        return !(*this != other);
-      }
-    };
-
-    Iterator begin() {
-      return {this->array + N};
+    Iterator(T* iter) : sub_iter{iter} {}
+
+    T& operator*() {
+      return *(this->sub_iter - 1);
+    }
+
+    T* operator->() {
+      return (this->sub_iter - 1);
     }
 
-    Iterator end() {
-      return {this->array};
+    Iterator& operator++() {
+      --this->sub_iter;
+      return *this;
+    }
+
+    Iterator operator++(int) {
+      auto ret = *this;
+      ++*this;
+      return ret;
+    }
+
+    bool operator!=(const Iterator& other) const {
+      return this->sub_iter != other.sub_iter;
+    }
+
+    bool operator==(const Iterator& other) const {
+      return !(*this != other);
     }
   };
 
-  template <typename T, std::size_t N>
-  Reverser<T[N]> reversed(T(&array)[N]) {
-    return {array};
+  Iterator begin() {
+    return {this->array + N};
   }
+
+  Iterator end() {
+    return {this->array};
+  }
+};
+
+template <typename T, std::size_t N>
+iter::impl::Reverser<T[N]> iter::reversed(T(&array)[N]) {
+  return {array};
 }
 
 #endif

From 91e1bad0a8e61a51dd3131a9c9dd44d2181cf2fd Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 20 Aug 2015 22:54:12 -0700
Subject: [PATCH 1243/1866] moves Sliced into impl { }

---
 slice.hpp | 194 +++++++++++++++++++++++++++---------------------------
 1 file changed, 97 insertions(+), 97 deletions(-)

diff --git a/slice.hpp b/slice.hpp
index 671e3a68..703a3305 100644
--- a/slice.hpp
+++ b/slice.hpp
@@ -8,139 +8,139 @@
 #include <initializer_list>
 
 namespace iter {
+  namespace impl {
+    template <typename Container, typename DifferenceType>
+    class Sliced;
+  }
 
   template <typename Container, typename DifferenceType>
-  class Slice;
-
-  template <typename Container, typename DifferenceType>
-  Slice<Container, DifferenceType> slice(Container&& container,
+  impl::Sliced<Container, DifferenceType> slice(Container&& container,
       DifferenceType start, DifferenceType stop, DifferenceType step = 1);
 
   template <typename Container, typename DifferenceType>
-  Slice<Container, DifferenceType> slice(
+  impl::Sliced<Container, DifferenceType> slice(
       Container&& container, DifferenceType stop);
 
   template <typename T, typename DifferenceType>
-  Slice<std::initializer_list<T>, DifferenceType> slice(
+  impl::Sliced<std::initializer_list<T>, DifferenceType> slice(
       std::initializer_list<T> il, DifferenceType start, DifferenceType stop,
       DifferenceType step = 1);
 
   template <typename T, typename DifferenceType>
-  Slice<std::initializer_list<T>, DifferenceType> slice(
+  impl::Sliced<std::initializer_list<T>, DifferenceType> slice(
       std::initializer_list<T> il, DifferenceType stop);
+}
 
-  template <typename Container, typename DifferenceType>
-  class Slice {
+template <typename Container, typename DifferenceType>
+class iter::impl::Sliced {
+ private:
+  Container container;
+  DifferenceType start;
+  DifferenceType stop;
+  DifferenceType step;
+
+  friend Sliced iter::slice<Container, DifferenceType>(
+      Container&&, DifferenceType, DifferenceType, DifferenceType);
+
+  friend Sliced iter::slice<Container, DifferenceType>(
+      Container&&, DifferenceType);
+
+  Sliced(Container&& in_container, DifferenceType in_start,
+      DifferenceType in_stop, DifferenceType in_step)
+      : container(std::forward<Container>(in_container)),
+        start{in_start < in_stop && in_step > 0 ? in_start : in_stop},
+        stop{in_stop},
+        step{in_step} {}
+
+ public:
+  class Iterator : public std::iterator<std::input_iterator_tag,
+                       iterator_traits_deref<Container>> {
    private:
-    Container container;
-    DifferenceType start;
+    iterator_type<Container> sub_iter;
+    iterator_type<Container> sub_end;
+    DifferenceType current;
     DifferenceType stop;
     DifferenceType step;
 
-    friend Slice slice<Container, DifferenceType>(
-        Container&&, DifferenceType, DifferenceType, DifferenceType);
-
-    friend Slice slice<Container, DifferenceType>(Container&&, DifferenceType);
-
-    Slice(Container&& in_container, DifferenceType in_start,
-        DifferenceType in_stop, DifferenceType in_step)
-        : container(std::forward<Container>(in_container)),
-          start{in_start < in_stop && in_step > 0 ? in_start : in_stop},
+   public:
+    Iterator(iterator_type<Container>&& si, iterator_type<Container>&& se,
+        DifferenceType in_start, DifferenceType in_stop, DifferenceType in_step)
+        : sub_iter{std::move(si)},
+          sub_end{std::move(se)},
+          current{in_start},
           stop{in_stop},
           step{in_step} {}
 
-   public:
-    class Iterator : public std::iterator<std::input_iterator_tag,
-                         iterator_traits_deref<Container>> {
-     private:
-      iterator_type<Container> sub_iter;
-      iterator_type<Container> sub_end;
-      DifferenceType current;
-      DifferenceType stop;
-      DifferenceType step;
-
-     public:
-      Iterator(iterator_type<Container>&& si, iterator_type<Container>&& se,
-          DifferenceType in_start, DifferenceType in_stop,
-          DifferenceType in_step)
-          : sub_iter{std::move(si)},
-            sub_end{std::move(se)},
-            current{in_start},
-            stop{in_stop},
-            step{in_step} {}
-
-      iterator_deref<Container> operator*() {
-        return *this->sub_iter;
-      }
-
-      iterator_arrow<Container> operator->() {
-        return apply_arrow(this->sub_iter);
-      }
-
-      Iterator& operator++() {
-        dumb_advance(this->sub_iter, this->sub_end, this->step);
-        this->current += this->step;
-        if (this->stop < this->current) {
-          this->current = this->stop;
-        }
-        return *this;
-      }
+    iterator_deref<Container> operator*() {
+      return *this->sub_iter;
+    }
 
-      Iterator operator++(int) {
-        auto ret = *this;
-        ++*this;
-        return ret;
-      }
+    iterator_arrow<Container> operator->() {
+      return apply_arrow(this->sub_iter);
+    }
 
-      bool operator!=(const Iterator& other) const {
-        return this->sub_iter != other.sub_iter
-               && this->current != other.current;
+    Iterator& operator++() {
+      dumb_advance(this->sub_iter, this->sub_end, this->step);
+      this->current += this->step;
+      if (this->stop < this->current) {
+        this->current = this->stop;
       }
+      return *this;
+    }
 
-      bool operator==(const Iterator& other) const {
-        return !(*this != other);
-      }
-    };
+    Iterator operator++(int) {
+      auto ret = *this;
+      ++*this;
+      return ret;
+    }
 
-    Iterator begin() {
-      auto it = std::begin(this->container);
-      dumb_advance(it, std::end(this->container), this->start);
-      return {std::move(it), std::end(this->container), this->start, this->stop,
-          this->step};
+    bool operator!=(const Iterator& other) const {
+      return this->sub_iter != other.sub_iter && this->current != other.current;
     }
 
-    Iterator end() {
-      return {std::end(this->container), std::end(this->container), this->stop,
-          this->stop, this->step};
+    bool operator==(const Iterator& other) const {
+      return !(*this != other);
     }
   };
 
-  // Helper function to instantiate a Slice
-  template <typename Container, typename DifferenceType>
-  Slice<Container, DifferenceType> slice(Container&& container,
-      DifferenceType start, DifferenceType stop, DifferenceType step) {
-    return {std::forward<Container>(container), start, stop, step};
+  Iterator begin() {
+    auto it = std::begin(this->container);
+    dumb_advance(it, std::end(this->container), this->start);
+    return {std::move(it), std::end(this->container), this->start, this->stop,
+        this->step};
   }
 
-  // only give the end as an arg and assume step  is 1 and begin is 0
-  template <typename Container, typename DifferenceType>
-  Slice<Container, DifferenceType> slice(
-      Container&& container, DifferenceType stop) {
-    return {std::forward<Container>(container), 0, stop, 1};
+  Iterator end() {
+    return {std::end(this->container), std::end(this->container), this->stop,
+        this->stop, this->step};
   }
+};
 
-  template <typename T, typename DifferenceType>
-  Slice<std::initializer_list<T>, DifferenceType> slice(
-      std::initializer_list<T> il, DifferenceType start, DifferenceType stop,
-      DifferenceType step) {
-    return {std::move(il), start, stop, step};
-  }
+// Helper function to instantiate a Sliced
+template <typename Container, typename DifferenceType>
+iter::impl::Sliced<Container, DifferenceType> iter::slice(Container&& container,
+    DifferenceType start, DifferenceType stop, DifferenceType step) {
+  return {std::forward<Container>(container), start, stop, step};
+}
 
-  template <typename T, typename DifferenceType>
-  Slice<std::initializer_list<T>, DifferenceType> slice(
-      std::initializer_list<T> il, DifferenceType stop) {
-    return {std::move(il), 0, stop, 1};
-  }
+// only give the end as an arg and assume step  is 1 and begin is 0
+template <typename Container, typename DifferenceType>
+iter::impl::Sliced<Container, DifferenceType> iter::slice(
+    Container&& container, DifferenceType stop) {
+  return {std::forward<Container>(container), 0, stop, 1};
+}
+
+template <typename T, typename DifferenceType>
+iter::impl::Sliced<std::initializer_list<T>, DifferenceType> iter::slice(
+    std::initializer_list<T> il, DifferenceType start, DifferenceType stop,
+    DifferenceType step) {
+  return {std::move(il), start, stop, step};
+}
+
+template <typename T, typename DifferenceType>
+iter::impl::Sliced<std::initializer_list<T>, DifferenceType> iter::slice(
+    std::initializer_list<T> il, DifferenceType stop) {
+  return {std::move(il), 0, stop, 1};
 }
 
 #endif

From 1ffd05c77e441e820cf6b9e1bd48626b5a100529 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 20 Aug 2015 22:56:16 -0700
Subject: [PATCH 1244/1866] moves WindowSlider into impl { }

---
 sliding_window.hpp | 149 +++++++++++++++++++++++----------------------
 1 file changed, 75 insertions(+), 74 deletions(-)

diff --git a/sliding_window.hpp b/sliding_window.hpp
index aefbca30..75fb0bf4 100644
--- a/sliding_window.hpp
+++ b/sliding_window.hpp
@@ -9,106 +9,107 @@
 #include <iterator>
 
 namespace iter {
-  template <typename Container>
-  class SlidingWindow;
+  namespace impl {
+    template <typename Container>
+    class WindowSlider;
+  }
 
   template <typename Container>
-  SlidingWindow<Container> sliding_window(Container&&, std::size_t);
+  impl::WindowSlider<Container> sliding_window(Container&&, std::size_t);
 
   template <typename T>
-  SlidingWindow<std::initializer_list<T>> sliding_window(
+  impl::WindowSlider<std::initializer_list<T>> sliding_window(
       std::initializer_list<T>, std::size_t);
+}
 
-  template <typename Container>
-  class SlidingWindow {
-   private:
-    Container container;
-    std::size_t window_size;
+template <typename Container>
+class iter::impl::WindowSlider {
+ private:
+  Container container;
+  std::size_t window_size;
 
-    friend SlidingWindow sliding_window<Container>(Container&&, std::size_t);
+  friend WindowSlider iter::sliding_window<Container>(Container&&, std::size_t);
 
-    template <typename T>
-    friend SlidingWindow<std::initializer_list<T>> sliding_window(
-        std::initializer_list<T>, std::size_t);
+  template <typename T>
+  friend WindowSlider<std::initializer_list<T>> iter::sliding_window(
+      std::initializer_list<T>, std::size_t);
 
-    SlidingWindow(Container&& in_container, std::size_t win_sz)
-        : container(std::forward<Container>(in_container)),
-          window_size{win_sz} {}
+  WindowSlider(Container&& in_container, std::size_t win_sz)
+      : container(std::forward<Container>(in_container)), window_size{win_sz} {}
 
-    using IndexVector = std::deque<iterator_type<Container>>;
-    using DerefVec = IterIterWrapper<IndexVector>;
+  using IndexVector = std::deque<iterator_type<Container>>;
+  using DerefVec = IterIterWrapper<IndexVector>;
 
-   public:
-    class Iterator : public std::iterator<std::input_iterator_tag, DerefVec> {
-     private:
-      iterator_type<Container> sub_iter;
-      DerefVec window;
-
-     public:
-      Iterator(iterator_type<Container>&& in_iter,
-          const iterator_type<Container>& in_end, std::size_t window_sz)
-          : sub_iter(std::move(in_iter)) {
-        std::size_t i{0};
-        while (i < window_sz && this->sub_iter != in_end) {
-          this->window.get().push_back(this->sub_iter);
-          ++i;
-          if (i != window_sz) ++this->sub_iter;
-        }
-      }
-
-      bool operator!=(const Iterator& other) const {
-        return this->sub_iter != other.sub_iter;
-      }
+ public:
+  class Iterator : public std::iterator<std::input_iterator_tag, DerefVec> {
+   private:
+    iterator_type<Container> sub_iter;
+    DerefVec window;
 
-      bool operator==(const Iterator& other) const {
-        return !(*this != other);
+   public:
+    Iterator(iterator_type<Container>&& in_iter,
+        const iterator_type<Container>& in_end, std::size_t window_sz)
+        : sub_iter(std::move(in_iter)) {
+      std::size_t i{0};
+      while (i < window_sz && this->sub_iter != in_end) {
+        this->window.get().push_back(this->sub_iter);
+        ++i;
+        if (i != window_sz) ++this->sub_iter;
       }
+    }
 
-      DerefVec& operator*() {
-        return this->window;
-      }
+    bool operator!=(const Iterator& other) const {
+      return this->sub_iter != other.sub_iter;
+    }
 
-      DerefVec* operator->() {
-        return this->window;
-      }
+    bool operator==(const Iterator& other) const {
+      return !(*this != other);
+    }
 
-      Iterator& operator++() {
-        ++this->sub_iter;
-        this->window.get().pop_front();
-        this->window.get().push_back(this->sub_iter);
-        return *this;
-      }
+    DerefVec& operator*() {
+      return this->window;
+    }
 
-      Iterator operator++(int) {
-        auto ret = *this;
-        ++*this;
-        return ret;
-      }
-    };
+    DerefVec* operator->() {
+      return this->window;
+    }
 
-    Iterator begin() {
-      return {(this->window_size != 0 ? std::begin(this->container)
-                                      : std::end(this->container)),
-          std::end(this->container), this->window_size};
+    Iterator& operator++() {
+      ++this->sub_iter;
+      this->window.get().pop_front();
+      this->window.get().push_back(this->sub_iter);
+      return *this;
     }
 
-    Iterator end() {
-      return {std::end(this->container), std::end(this->container),
-          this->window_size};
+    Iterator operator++(int) {
+      auto ret = *this;
+      ++*this;
+      return ret;
     }
   };
 
-  template <typename Container>
-  SlidingWindow<Container> sliding_window(
-      Container&& container, std::size_t window_size) {
-    return {std::forward<Container>(container), window_size};
+  Iterator begin() {
+    return {(this->window_size != 0 ? std::begin(this->container)
+                                    : std::end(this->container)),
+        std::end(this->container), this->window_size};
   }
 
-  template <typename T>
-  SlidingWindow<std::initializer_list<T>> sliding_window(
-      std::initializer_list<T> il, std::size_t window_size) {
-    return {std::move(il), window_size};
+  Iterator end() {
+    return {std::end(this->container), std::end(this->container),
+        this->window_size};
   }
+};
+
+template <typename Container>
+iter::impl::WindowSlider<Container> iter::sliding_window(
+    Container&& container, std::size_t window_size) {
+  return {std::forward<Container>(container), window_size};
+}
+
+template <typename T>
+iter::impl::WindowSlider<std::initializer_list<T>> iter::sliding_window(
+    std::initializer_list<T> il, std::size_t window_size) {
+  return {std::move(il), window_size};
 }
 
 #endif

From 03ab7fd6d77a9402216dbfa94b9ef357c7d8aabb Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 20 Aug 2015 22:58:34 -0700
Subject: [PATCH 1245/1866] moves SortedView into impl { }

---
 sorted.hpp | 83 +++++++++++++++++++++++++++++-------------------------
 1 file changed, 44 insertions(+), 39 deletions(-)

diff --git a/sorted.hpp b/sorted.hpp
index 318ae415..27f67323 100644
--- a/sorted.hpp
+++ b/sorted.hpp
@@ -9,57 +9,62 @@
 #include <vector>
 
 namespace iter {
-  template <typename Container>
-  class Sorted;
+  namespace impl {
+    template <typename Container>
+    class SortedView;
+  }
 
   template <typename Container, typename CompareFunc>
-  Sorted<Container> sorted(Container&&, CompareFunc);
-
-  template <typename Container>
-  class Sorted {
-   private:
-    using IterIterWrap = IterIterWrapper<std::vector<iterator_type<Container>>>;
-    using ItIt = iterator_type<IterIterWrap>;
+  impl::SortedView<Container> sorted(Container&&, CompareFunc);
+}
 
-    template <typename C, typename F>
-    friend Sorted<C> sorted(C&&, F);
+template <typename Container>
+class iter::impl::SortedView {
+ private:
+  using IterIterWrap = IterIterWrapper<std::vector<iterator_type<Container>>>;
+  using ItIt = iterator_type<IterIterWrap>;
 
-    Container container;
-    IterIterWrap sorted_iters;
+  template <typename C, typename F>
+  friend SortedView<C> iter::sorted(C&&, F);
 
-    template <typename CompareFunc>
-    Sorted(Container&& in_container, CompareFunc compare_func)
-        : container(std::forward<Container>(in_container)) {
-      // Fill the sorted_iters vector with an iterator to each
-      // element in the container
-      for (auto iter = std::begin(this->container);
-           iter != std::end(this->container); ++iter) {
-        this->sorted_iters.get().push_back(iter);
-      }
+  Container container;
+  IterIterWrap sorted_iters;
 
-      // sort by comparing the elements that the iterators point to
-      std::sort(std::begin(sorted_iters.get()), std::end(sorted_iters.get()),
-          [compare_func](const iterator_type<Container>& it1,
-                    const iterator_type<Container>& it2) {
-            return compare_func(*it1, *it2);
-          });
+  template <typename CompareFunc>
+  SortedView(Container&& in_container, CompareFunc compare_func)
+      : container(std::forward<Container>(in_container)) {
+    // Fill the sorted_iters vector with an iterator to each
+    // element in the container
+    for (auto iter = std::begin(this->container);
+         iter != std::end(this->container); ++iter) {
+      this->sorted_iters.get().push_back(iter);
     }
 
-   public:
-    ItIt begin() {
-      return std::begin(sorted_iters);
-    }
+    // sort by comparing the elements that the iterators point to
+    std::sort(std::begin(sorted_iters.get()), std::end(sorted_iters.get()),
+        [compare_func](const iterator_type<Container>& it1,
+                  const iterator_type<Container>& it2) {
+          return compare_func(*it1, *it2);
+        });
+  }
 
-    ItIt end() {
-      return std::end(sorted_iters);
-    }
-  };
+ public:
+  ItIt begin() {
+    return std::begin(sorted_iters);
+  }
 
-  template <typename Container, typename CompareFunc>
-  Sorted<Container> sorted(Container&& container, CompareFunc compare_func) {
-    return {std::forward<Container>(container), compare_func};
+  ItIt end() {
+    return std::end(sorted_iters);
   }
+};
 
+template <typename Container, typename CompareFunc>
+iter::impl::SortedView<Container> iter::sorted(
+    Container&& container, CompareFunc compare_func) {
+  return {std::forward<Container>(container), compare_func};
+}
+
+namespace iter {
   template <typename Container>
   auto sorted(Container&& container)
       -> decltype(sorted(std::forward<Container>(container),

From 5a4daf7f47b80775f6264bda31bcc5556fbdf715 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 20 Aug 2015 23:00:55 -0700
Subject: [PATCH 1246/1866] moves Taker into impl { }

---
 takewhile.hpp | 174 +++++++++++++++++++++++++-------------------------
 1 file changed, 87 insertions(+), 87 deletions(-)

diff --git a/takewhile.hpp b/takewhile.hpp
index 4f09fae7..29dd4c55 100644
--- a/takewhile.hpp
+++ b/takewhile.hpp
@@ -8,121 +8,121 @@
 #include <initializer_list>
 
 namespace iter {
-
-  // Forward declarations of TakeWhile and takewhile
-  template <typename FilterFunc, typename Container>
-  class TakeWhile;
+  namespace impl {
+    template <typename FilterFunc, typename Container>
+    class Taker;
+  }
 
   template <typename FilterFunc, typename Container>
-  TakeWhile<FilterFunc, Container> takewhile(FilterFunc, Container&&);
+  impl::Taker<FilterFunc, Container> takewhile(FilterFunc, Container&&);
 
   template <typename FilterFunc, typename T>
-  TakeWhile<FilterFunc, std::initializer_list<T>> takewhile(
+  impl::Taker<FilterFunc, std::initializer_list<T>> takewhile(
       FilterFunc, std::initializer_list<T>);
+}
 
-  template <typename FilterFunc, typename Container>
-  class TakeWhile {
-   private:
-    Container container;
-    FilterFunc filter_func;
+template <typename FilterFunc, typename Container>
+class iter::impl::Taker {
+ private:
+  Container container;
+  FilterFunc filter_func;
 
-    friend TakeWhile takewhile<FilterFunc, Container>(FilterFunc, Container&&);
+  friend Taker iter::takewhile<FilterFunc, Container>(FilterFunc, Container&&);
 
-    template <typename FF, typename T>
-    friend TakeWhile<FF, std::initializer_list<T>> takewhile(
-        FF, std::initializer_list<T>);
+  template <typename FF, typename T>
+  friend Taker<FF, std::initializer_list<T>> iter::takewhile(
+      FF, std::initializer_list<T>);
 
-    TakeWhile(FilterFunc in_filter_func, Container&& in_container)
-        : container(std::forward<Container>(in_container)),
-          filter_func(in_filter_func) {}
+  Taker(FilterFunc in_filter_func, Container&& in_container)
+      : container(std::forward<Container>(in_container)),
+        filter_func(in_filter_func) {}
 
-   public:
-    class Iterator : public std::iterator<std::input_iterator_tag,
-                         iterator_traits_deref<Container>> {
-     private:
-      using Holder = DerefHolder<iterator_deref<Container>>;
-      iterator_type<Container> sub_iter;
-      iterator_type<Container> sub_end;
-      Holder item;
-      FilterFunc* filter_func;
-
-      void inc_sub_iter() {
-        ++this->sub_iter;
-        if (this->sub_iter != this->sub_end) {
-          this->item.reset(*this->sub_iter);
-        }
-      }
-
-      void check_current() {
-        if (this->sub_iter != this->sub_end
-            && !(*this->filter_func)(this->item.get())) {
-          this->sub_iter = this->sub_end;
-        }
-      }
-
-     public:
-      Iterator(iterator_type<Container>&& iter, iterator_type<Container>&& end,
-          FilterFunc& in_filter_func)
-          : sub_iter{std::move(iter)},
-            sub_end{std::move(end)},
-            filter_func(&in_filter_func) {
-        if (this->sub_iter != this->sub_end) {
-          this->item.reset(*this->sub_iter);
-        }
-        this->check_current();
+ public:
+  class Iterator : public std::iterator<std::input_iterator_tag,
+                       iterator_traits_deref<Container>> {
+   private:
+    using Holder = DerefHolder<iterator_deref<Container>>;
+    iterator_type<Container> sub_iter;
+    iterator_type<Container> sub_end;
+    Holder item;
+    FilterFunc* filter_func;
+
+    void inc_sub_iter() {
+      ++this->sub_iter;
+      if (this->sub_iter != this->sub_end) {
+        this->item.reset(*this->sub_iter);
       }
+    }
 
-      typename Holder::reference operator*() {
-        return this->item.get();
+    void check_current() {
+      if (this->sub_iter != this->sub_end
+          && !(*this->filter_func)(this->item.get())) {
+        this->sub_iter = this->sub_end;
       }
+    }
 
-      typename Holder::pointer operator->() {
-        return this->item.get_ptr();
+   public:
+    Iterator(iterator_type<Container>&& iter, iterator_type<Container>&& end,
+        FilterFunc& in_filter_func)
+        : sub_iter{std::move(iter)},
+          sub_end{std::move(end)},
+          filter_func(&in_filter_func) {
+      if (this->sub_iter != this->sub_end) {
+        this->item.reset(*this->sub_iter);
       }
+      this->check_current();
+    }
 
-      Iterator& operator++() {
-        this->inc_sub_iter();
-        this->check_current();
-        return *this;
-      }
+    typename Holder::reference operator*() {
+      return this->item.get();
+    }
 
-      Iterator operator++(int) {
-        auto ret = *this;
-        ++*this;
-        return ret;
-      }
+    typename Holder::pointer operator->() {
+      return this->item.get_ptr();
+    }
 
-      bool operator!=(const Iterator& other) const {
-        return this->sub_iter != other.sub_iter;
-      }
+    Iterator& operator++() {
+      this->inc_sub_iter();
+      this->check_current();
+      return *this;
+    }
 
-      bool operator==(const Iterator& other) const {
-        return !(*this != other);
-      }
-    };
+    Iterator operator++(int) {
+      auto ret = *this;
+      ++*this;
+      return ret;
+    }
 
-    Iterator begin() {
-      return {std::begin(this->container), std::end(this->container),
-          this->filter_func};
+    bool operator!=(const Iterator& other) const {
+      return this->sub_iter != other.sub_iter;
     }
 
-    Iterator end() {
-      return {std::end(this->container), std::end(this->container),
-          this->filter_func};
+    bool operator==(const Iterator& other) const {
+      return !(*this != other);
     }
   };
 
-  template <typename FilterFunc, typename Container>
-  TakeWhile<FilterFunc, Container> takewhile(
-      FilterFunc filter_func, Container&& container) {
-    return {filter_func, std::forward<Container>(container)};
+  Iterator begin() {
+    return {std::begin(this->container), std::end(this->container),
+        this->filter_func};
   }
 
-  template <typename FilterFunc, typename T>
-  TakeWhile<FilterFunc, std::initializer_list<T>> takewhile(
-      FilterFunc filter_func, std::initializer_list<T> il) {
-    return {filter_func, std::move(il)};
+  Iterator end() {
+    return {std::end(this->container), std::end(this->container),
+        this->filter_func};
   }
+};
+
+template <typename FilterFunc, typename Container>
+iter::impl::Taker<FilterFunc, Container> iter::takewhile(
+    FilterFunc filter_func, Container&& container) {
+  return {filter_func, std::forward<Container>(container)};
+}
+
+template <typename FilterFunc, typename T>
+iter::impl::Taker<FilterFunc, std::initializer_list<T>> iter::takewhile(
+    FilterFunc filter_func, std::initializer_list<T> il) {
+  return {filter_func, std::move(il)};
 }
 
 #endif

From 8cce4cb5b39dd6e0130c792ed8fcd9051f6af39c Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 20 Aug 2015 23:03:46 -0700
Subject: [PATCH 1247/1866] moves Zipped into impl { }

---
 zip.hpp | 229 ++++++++++++++++++++++++++++----------------------------
 1 file changed, 116 insertions(+), 113 deletions(-)

diff --git a/zip.hpp b/zip.hpp
index 038808df..23e56221 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -8,140 +8,143 @@
 #include <utility>
 
 namespace iter {
-  template <typename... RestContainers>
-  class Zipped;
+  namespace impl {
+    template <typename... RestContainers>
+    class Zipped;
+
+    template <typename Container, typename... RestContainers>
+    class Zipped<Container, RestContainers...>;
+
+    template <>
+    class Zipped<>;
+  }
 
   template <typename... Containers>
-  Zipped<Containers...> zip(Containers&&...);
+  impl::Zipped<Containers...> zip(Containers&&...);
+}
 
-  // specialization for at least 1 template argument
-  template <typename Container, typename... RestContainers>
-  class Zipped<Container, RestContainers...> {
-    using ZipIterDeref = std::tuple<iterator_deref<Container>,
-        iterator_deref<RestContainers>...>;
+// specialization for at least 1 template argument
+template <typename Container, typename... RestContainers>
+class iter::impl::Zipped<Container, RestContainers...> {
+  using ZipIterDeref =
+      std::tuple<iterator_deref<Container>, iterator_deref<RestContainers>...>;
 
-    friend Zipped zip<Container, RestContainers...>(
-        Container&&, RestContainers&&...);
+  friend Zipped iter::zip<Container, RestContainers...>(
+      Container&&, RestContainers&&...);
 
-    template <typename...>
-    friend class Zipped;
+  template <typename...>
+  friend class Zipped;
 
+ private:
+  Container container;
+  Zipped<RestContainers...> rest_zipped;
+  Zipped(Container&& in_container, RestContainers&&... rest)
+      : container(std::forward<Container>(in_container)),
+        rest_zipped{std::forward<RestContainers>(rest)...} {}
+
+ public:
+  class Iterator : public std::iterator<std::input_iterator_tag, ZipIterDeref> {
    private:
-    Container container;
-    Zipped<RestContainers...> rest_zipped;
-    Zipped(Container&& in_container, RestContainers&&... rest)
-        : container(std::forward<Container>(in_container)),
-          rest_zipped{std::forward<RestContainers>(rest)...} {}
+    using RestIter = typename Zipped<RestContainers...>::Iterator;
+
+    iterator_type<Container> iter;
+    RestIter rest_iter;
 
    public:
-    class Iterator
-        : public std::iterator<std::input_iterator_tag, ZipIterDeref> {
-     private:
-      using RestIter = typename Zipped<RestContainers...>::Iterator;
-
-      iterator_type<Container> iter;
-      RestIter rest_iter;
-
-     public:
-      constexpr static const bool is_base_iter = false;
-      Iterator(iterator_type<Container>&& it, RestIter&& rest)
-          : iter{std::move(it)}, rest_iter{std::move(rest)} {}
-
-      Iterator& operator++() {
-        ++this->iter;
-        ++this->rest_iter;
-        return *this;
-      }
-
-      Iterator operator++(int) {
-        auto ret = *this;
-        ++*this;
-        return ret;
-      }
-
-      bool operator!=(const Iterator& other) const {
-        return this->iter != other.iter
-               && (RestIter::is_base_iter
-                      || this->rest_iter != other.rest_iter);
-      }
-
-      bool operator==(const Iterator& other) const {
-        return !(*this != other);
-      }
-
-      auto operator*() -> decltype(
-          std::tuple_cat(std::tuple<iterator_deref<Container>>{*this->iter},
-              *this->rest_iter)) {
-        return std::tuple_cat(
-            std::tuple<iterator_deref<Container>>{*this->iter},
-            *this->rest_iter);
-      }
-
-      auto operator-> () -> ArrowProxy<decltype(**this)> {
-        return {**this};
-      }
-    };
-
-    Iterator begin() {
-      return {std::begin(this->container), std::begin(this->rest_zipped)};
+    constexpr static const bool is_base_iter = false;
+    Iterator(iterator_type<Container>&& it, RestIter&& rest)
+        : iter{std::move(it)}, rest_iter{std::move(rest)} {}
+
+    Iterator& operator++() {
+      ++this->iter;
+      ++this->rest_iter;
+      return *this;
+    }
+
+    Iterator operator++(int) {
+      auto ret = *this;
+      ++*this;
+      return ret;
     }
 
-    Iterator end() {
-      return {std::end(this->container), std::end(this->rest_zipped)};
+    bool operator!=(const Iterator& other) const {
+      return this->iter != other.iter
+             && (RestIter::is_base_iter || this->rest_iter != other.rest_iter);
+    }
+
+    bool operator==(const Iterator& other) const {
+      return !(*this != other);
+    }
+
+    auto operator*() -> decltype(std::tuple_cat(
+        std::tuple<iterator_deref<Container>>{*this->iter}, *this->rest_iter)) {
+      return std::tuple_cat(
+          std::tuple<iterator_deref<Container>>{*this->iter}, *this->rest_iter);
+    }
+
+    auto operator -> () -> ArrowProxy<decltype(**this)> {
+      return {**this};
     }
   };
 
-  template <>
-  class Zipped<> {
+  Iterator begin() {
+    return {std::begin(this->container), std::begin(this->rest_zipped)};
+  }
+
+  Iterator end() {
+    return {std::end(this->container), std::end(this->rest_zipped)};
+  }
+};
+
+template <>
+class iter::impl::Zipped<> {
+ public:
+  class Iterator : public std::iterator<std::input_iterator_tag, std::tuple<>> {
    public:
-    class Iterator
-        : public std::iterator<std::input_iterator_tag, std::tuple<>> {
-     public:
-      constexpr static const bool is_base_iter = true;
-
-      Iterator& operator++() {
-        return *this;
-      }
-
-      Iterator operator++(int) {
-        return *this;
-      }
-
-      // if this were to return true, there would be no need
-      // for the is_base_iter static class attribute.
-      // However, returning false causes an empty zip() call
-      // to reach the "end" immediately. Returning true here
-      // instead results in an infinite loop in the zip() case
-      bool operator!=(const Iterator&) const {
-        return false;
-      }
-
-      bool operator==(const Iterator& other) const {
-        return !(*this != other);
-      }
-
-      std::tuple<> operator*() {
-        return std::tuple<>{};
-      }
-
-      auto operator-> () -> ArrowProxy<decltype(**this)> {
-        return {**this};
-      }
-    };
-
-    Iterator begin() {
-      return {};
+    constexpr static const bool is_base_iter = true;
+
+    Iterator& operator++() {
+      return *this;
+    }
+
+    Iterator operator++(int) {
+      return *this;
+    }
+
+    // if this were to return true, there would be no need
+    // for the is_base_iter static class attribute.
+    // However, returning false causes an empty zip() call
+    // to reach the "end" immediately. Returning true here
+    // instead results in an infinite loop in the zip() case
+    bool operator!=(const Iterator&) const {
+      return false;
     }
 
-    Iterator end() {
-      return {};
+    bool operator==(const Iterator& other) const {
+      return !(*this != other);
+    }
+
+    std::tuple<> operator*() {
+      return std::tuple<>{};
+    }
+
+    auto operator -> () -> ArrowProxy<decltype(**this)> {
+      return {**this};
     }
   };
 
-  template <typename... Containers>
-  Zipped<Containers...> zip(Containers&&... containers) {
-    return {std::forward<Containers>(containers)...};
+  Iterator begin() {
+    return {};
   }
+
+  Iterator end() {
+    return {};
+  }
+};
+
+template <typename... Containers>
+iter::impl::Zipped<Containers...> iter::zip(Containers&&... containers) {
+  return {std::forward<Containers>(containers)...};
 }
 
 #endif

From def95a24cc85b7d0999bfb89a797e7b3ce79ab1a Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 20 Aug 2015 23:06:41 -0700
Subject: [PATCH 1248/1866] moves ZippedLongest into impl { }

---
 zip_longest.hpp | 212 +++++++++++++++++++++++++-----------------------
 1 file changed, 109 insertions(+), 103 deletions(-)

diff --git a/zip_longest.hpp b/zip_longest.hpp
index 7029bb50..cde50074 100644
--- a/zip_longest.hpp
+++ b/zip_longest.hpp
@@ -9,145 +9,151 @@
 #include <utility>
 
 namespace iter {
+  namespace impl {
+    template <typename... RestContainers>
+    class ZippedLongest;
 
-  template <typename Container>
-  using OptIterDeref = boost::optional<iterator_deref<Container>>;
+    template <typename Container, typename... RestContainers>
+    class ZippedLongest<Container, RestContainers...>;
 
-  template <typename... RestContainers>
-  class ZippedLongest;
+    template <>
+    class ZippedLongest<>;
+  }
 
   template <typename... Containers>
-  ZippedLongest<Containers...> zip_longest(Containers&&...);
+  impl::ZippedLongest<Containers...> zip_longest(Containers&&...);
+}
+
+template <typename Container, typename... RestContainers>
+class iter::impl::ZippedLongest<Container, RestContainers...> {
+  static_assert(!std::is_rvalue_reference<Container>::value,
+      "Itertools cannot be templated with rvalue references");
+
+  friend ZippedLongest zip_longest<Container, RestContainers...>(
+      Container&&, RestContainers&&...);
+
+  template <typename...>
+  friend class ZippedLongest;
 
-  template <typename Container, typename... RestContainers>
-  class ZippedLongest<Container, RestContainers...> {
-    static_assert(!std::is_rvalue_reference<Container>::value,
-        "Itertools cannot be templated with rvalue references");
+ private:
+  template <typename C>
+  using OptIterDeref = boost::optional<iterator_deref<C>>;
 
-    friend ZippedLongest zip_longest<Container, RestContainers...>(
-        Container&&, RestContainers&&...);
+  using OptType = OptIterDeref<Container>;
+  using ZipIterDeref = std::tuple<OptType, OptIterDeref<RestContainers>...>;
 
-    template <typename...>
-    friend class ZippedLongest;
+  Container container;
+  ZippedLongest<RestContainers...> rest_zipped;
+  ZippedLongest(Container&& in_container, RestContainers&&... rest)
+      : container(std::forward<Container>(in_container)),
+        rest_zipped{std::forward<RestContainers>(rest)...} {}
 
+ public:
+  class Iterator : public std::iterator<std::input_iterator_tag, ZipIterDeref> {
    private:
-    using OptType = OptIterDeref<Container>;
-    using ZipIterDeref = std::tuple<OptType, OptIterDeref<RestContainers>...>;
+    using RestIter = typename ZippedLongest<RestContainers...>::Iterator;
 
-    Container container;
-    ZippedLongest<RestContainers...> rest_zipped;
-    ZippedLongest(Container&& in_container, RestContainers&&... rest)
-        : container(std::forward<Container>(in_container)),
-          rest_zipped{std::forward<RestContainers>(rest)...} {}
+    iterator_type<Container> iter;
+    iterator_type<Container> end;
+    RestIter rest_iter;
 
    public:
-    class Iterator
-        : public std::iterator<std::input_iterator_tag, ZipIterDeref> {
-     private:
-      using RestIter = typename ZippedLongest<RestContainers...>::Iterator;
-
-      iterator_type<Container> iter;
-      iterator_type<Container> end;
-      RestIter rest_iter;
-
-     public:
-      Iterator(iterator_type<Container>&& it, iterator_type<Container>&& in_end,
-          RestIter&& rest)
-          : iter{std::move(it)},
-            end{std::move(in_end)},
-            rest_iter{std::move(rest)} {}
-
-      Iterator& operator++() {
-        if (this->iter != this->end) {
-          ++this->iter;
-        }
-        ++this->rest_iter;
-        return *this;
-      }
-
-      Iterator operator++(int) {
-        auto ret = *this;
-        ++*this;
-        return ret;
+    Iterator(iterator_type<Container>&& it, iterator_type<Container>&& in_end,
+        RestIter&& rest)
+        : iter{std::move(it)},
+          end{std::move(in_end)},
+          rest_iter{std::move(rest)} {}
+
+    Iterator& operator++() {
+      if (this->iter != this->end) {
+        ++this->iter;
       }
+      ++this->rest_iter;
+      return *this;
+    }
 
-      bool operator!=(const Iterator& other) const {
-        return this->iter != other.iter || this->rest_iter != other.rest_iter;
-      }
+    Iterator operator++(int) {
+      auto ret = *this;
+      ++*this;
+      return ret;
+    }
 
-      bool operator==(const Iterator& other) const {
-        return !(*this != other);
-      }
+    bool operator!=(const Iterator& other) const {
+      return this->iter != other.iter || this->rest_iter != other.rest_iter;
+    }
 
-      ZipIterDeref operator*() {
-        if (this->iter != this->end) {
-          return std::tuple_cat(
-              std::tuple<OptType>{{*this->iter}}, *this->rest_iter);
-        } else {
-          return std::tuple_cat(std::tuple<OptType>{{}}, *this->rest_iter);
-        }
-      }
+    bool operator==(const Iterator& other) const {
+      return !(*this != other);
+    }
 
-      ArrowProxy<ZipIterDeref> operator->() {
-        return {**this};
+    ZipIterDeref operator*() {
+      if (this->iter != this->end) {
+        return std::tuple_cat(
+            std::tuple<OptType>{{*this->iter}}, *this->rest_iter);
+      } else {
+        return std::tuple_cat(std::tuple<OptType>{{}}, *this->rest_iter);
       }
-    };
-
-    Iterator begin() {
-      return {std::begin(this->container), std::end(this->container),
-          std::begin(this->rest_zipped)};
     }
 
-    Iterator end() {
-      return {std::end(this->container), std::end(this->container),
-          std::end(this->rest_zipped)};
+    ArrowProxy<ZipIterDeref> operator->() {
+      return {**this};
     }
   };
 
-  template <>
-  class ZippedLongest<> {
-   public:
-    class Iterator
-        : public std::iterator<std::input_iterator_tag, std::tuple<>> {
-     public:
-      Iterator& operator++() {
-        return *this;
-      }
+  Iterator begin() {
+    return {std::begin(this->container), std::end(this->container),
+        std::begin(this->rest_zipped)};
+  }
 
-      constexpr Iterator operator++(int) const {
-        return *this;
-      }
+  Iterator end() {
+    return {std::end(this->container), std::end(this->container),
+        std::end(this->rest_zipped)};
+  }
+};
 
-      constexpr bool operator!=(const Iterator&) const {
-        return false;
-      }
+template <>
+class iter::impl::ZippedLongest<> {
+ public:
+  class Iterator : public std::iterator<std::input_iterator_tag, std::tuple<>> {
+   public:
+    Iterator& operator++() {
+      return *this;
+    }
 
-      constexpr bool operator==(const Iterator&) const {
-        return true;
-      }
+    constexpr Iterator operator++(int) const {
+      return *this;
+    }
 
-      constexpr std::tuple<> operator*() const {
-        return {};
-      }
+    constexpr bool operator!=(const Iterator&) const {
+      return false;
+    }
 
-      constexpr ArrowProxy<std::tuple<>> operator->() const {
-        return {{}};
-      }
-    };
+    constexpr bool operator==(const Iterator&) const {
+      return true;
+    }
 
-    constexpr Iterator begin() const {
+    constexpr std::tuple<> operator*() const {
       return {};
     }
 
-    constexpr Iterator end() const {
-      return {};
+    constexpr ArrowProxy<std::tuple<>> operator->() const {
+      return {{}};
     }
   };
 
-  template <typename... Containers>
-  ZippedLongest<Containers...> zip_longest(Containers&&... containers) {
-    return {std::forward<Containers>(containers)...};
+  constexpr Iterator begin() const {
+    return {};
+  }
+
+  constexpr Iterator end() const {
+    return {};
   }
+};
+
+template <typename... Containers>
+iter::impl::ZippedLongest<Containers...> iter::zip_longest(
+    Containers&&... containers) {
+  return {std::forward<Containers>(containers)...};
 }
 
 #endif

From f18f822996ee01a2ab750d146e42f117b2944643 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 20 Aug 2015 23:15:05 -0700
Subject: [PATCH 1249/1866] Moves all of iterbase and iteriter into impl { }

It's mostly used inside of the implementation classes anyway
---
 accumulate.hpp                 |   4 +-
 filter.hpp                     | 132 ++++++++++++++++-----------------
 filterfalse.hpp                |   6 +-
 groupby.hpp                    |   4 +-
 imap.hpp                       |   4 +-
 iteratoriterator.hpp           |   4 +-
 iterbase.hpp                   |   2 +
 range.hpp                      |   2 +-
 sorted.hpp                     |   4 +-
 test/helpers.hpp               |   2 +-
 test/test_iteratoriterator.cpp |   2 +-
 unique_everseen.hpp            |   4 +-
 unique_justseen.hpp            |   2 +-
 13 files changed, 88 insertions(+), 84 deletions(-)

diff --git a/accumulate.hpp b/accumulate.hpp
index c91319e8..95b464c0 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -142,11 +142,11 @@ namespace iter {
   auto accumulate(Container&& container) -> decltype(accumulate(
       std::forward<Container>(container),
       std::plus<
-          typename std::remove_reference<iterator_deref<Container>>::type>{})) {
+          typename std::remove_reference<impl::iterator_deref<Container>>::type>{})) {
     return accumulate(
         std::forward<Container>(container),
         std::plus<
-            typename std::remove_reference<iterator_deref<Container>>::type>{});
+            typename std::remove_reference<impl::iterator_deref<Container>>::type>{});
   }
 
   template <typename T>
diff --git a/filter.hpp b/filter.hpp
index 9a7b203f..f31aa145 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -43,75 +43,75 @@ class iter::impl::Filtered {
   class Iterator : public std::iterator<std::input_iterator_tag,
                        iterator_traits_deref<Container>> {
    protected:
-    using Holder = DerefHolder<iterator_deref<Container>>;
-    iterator_type<Container> sub_iter;
-    iterator_type<Container> sub_end;
-    Holder item;
-    FilterFunc* filter_func;
-
-    void inc_sub_iter() {
-      ++this->sub_iter;
-      if (this->sub_iter != this->sub_end) {
-        this->item.reset(*this->sub_iter);
-      }
-    }
-
-    // increment until the iterator points to is true on the
-    // predicate.  Called by constructor and operator++
-    void skip_failures() {
-      while (this->sub_iter != this->sub_end
-             && !(*this->filter_func)(this->item.get())) {
-        this->inc_sub_iter();
-      }
-    }
+     using Holder = DerefHolder<iterator_deref<Container>>;
+     iterator_type<Container> sub_iter;
+     iterator_type<Container> sub_end;
+     Holder item;
+     FilterFunc* filter_func;
+
+     void inc_sub_iter() {
+       ++this->sub_iter;
+       if (this->sub_iter != this->sub_end) {
+         this->item.reset(*this->sub_iter);
+       }
+     }
+
+     // increment until the iterator points to is true on the
+     // predicate.  Called by constructor and operator++
+     void skip_failures() {
+       while (this->sub_iter != this->sub_end
+           && !(*this->filter_func)(this->item.get())) {
+         this->inc_sub_iter();
+       }
+     }
 
    public:
-    Iterator(iterator_type<Container> iter, iterator_type<Container> end,
-        FilterFunc& in_filter_func)
-        : sub_iter{iter}, sub_end{end}, filter_func(&in_filter_func) {
-      if (this->sub_iter != this->sub_end) {
-        this->item.reset(*this->sub_iter);
-      }
-      this->skip_failures();
-    }
-
-    typename Holder::reference operator*() {
-      return this->item.get();
-    }
-
-    typename Holder::pointer operator->() {
-      return this->item.get_ptr();
-    }
-
-    Iterator& operator++() {
-      this->inc_sub_iter();
-      this->skip_failures();
-      return *this;
-    }
-
-    Iterator operator++(int) {
-      auto ret = *this;
-      ++*this;
-      return ret;
-    }
-
-    bool operator!=(const Iterator& other) const {
-      return this->sub_iter != other.sub_iter;
-    }
-
-    bool operator==(const Iterator& other) const {
-      return !(*this != other);
-    }
-  };
+     Iterator(iterator_type<Container> iter, iterator_type<Container> end,
+         FilterFunc& in_filter_func)
+       : sub_iter{iter}, sub_end{end}, filter_func(&in_filter_func) {
+         if (this->sub_iter != this->sub_end) {
+           this->item.reset(*this->sub_iter);
+         }
+         this->skip_failures();
+       }
+
+     typename Holder::reference operator*() {
+       return this->item.get();
+     }
+
+     typename Holder::pointer operator->() {
+       return this->item.get_ptr();
+     }
+
+     Iterator& operator++() {
+       this->inc_sub_iter();
+       this->skip_failures();
+       return *this;
+     }
+
+     Iterator operator++(int) {
+       auto ret = *this;
+       ++*this;
+       return ret;
+     }
+
+     bool operator!=(const Iterator& other) const {
+       return this->sub_iter != other.sub_iter;
+     }
+
+     bool operator==(const Iterator& other) const {
+       return !(*this != other);
+     }
+                       };
 
   Iterator begin() {
     return {std::begin(this->container), std::end(this->container),
-        this->filter_func};
+      this->filter_func};
   }
 
   Iterator end() {
     return {std::end(this->container), std::end(this->container),
-        this->filter_func};
+      this->filter_func};
   }
 };
 
@@ -131,14 +131,14 @@ namespace iter {
   namespace detail {
 
     template <typename T>
-    bool boolean_cast(const T& t) {
-      return bool(t);
-    }
+      bool boolean_cast(const T& t) {
+        return bool(t);
+      }
 
     template <typename Container>
-    class BoolTester {
-     public:
-      bool operator()(const iterator_deref<Container> item) const {
+      class BoolTester {
+        public:
+          bool operator()(const impl::iterator_deref<Container> item) const {
         return bool(item);
       }
     };
diff --git a/filterfalse.hpp b/filterfalse.hpp
index 9d7d7840..850cfec4 100644
--- a/filterfalse.hpp
+++ b/filterfalse.hpp
@@ -25,12 +25,12 @@ namespace iter {
       PredicateFlipper(const PredicateFlipper&) = default;
 
       // Calls the filter_func
-      bool operator()(const iterator_deref<Container> item) const {
+      bool operator()(const impl::iterator_deref<Container> item) const {
         return !bool(filter_func(item));
       }
 
       // with non-const incase FilterFunc::operator() is non-const
-      bool operator()(const iterator_deref<Container> item) {
+      bool operator()(const impl::iterator_deref<Container> item) {
         return !bool(filter_func(item));
       }
     };
@@ -40,7 +40,7 @@ namespace iter {
     template <typename Container>
     class BoolFlipper {
      public:
-      bool operator()(const iterator_deref<Container> item) const {
+      bool operator()(const impl::iterator_deref<Container> item) const {
         return !bool(item);
       }
     };
diff --git a/groupby.hpp b/groupby.hpp
index 8262652b..8bd6091e 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -294,8 +294,8 @@ namespace iter {
     template <typename Container>
     class ItemReturner {
      public:
-      iterator_deref<Container> operator()(
-          iterator_deref<Container> item) const {
+       impl::iterator_deref<Container> operator()(
+          impl::iterator_deref<Container> item) const {
         return item;
       }
     };
diff --git a/imap.hpp b/imap.hpp
index 54f82595..d679a918 100644
--- a/imap.hpp
+++ b/imap.hpp
@@ -78,7 +78,7 @@ class iter::impl::IMapper {
   ZippedType zipped;
 
   using IMapIterDeref =
-      decltype(detail::call_with_tuple(map_func, *std::begin(zipped)));
+      decltype(iter::detail::call_with_tuple(map_func, *std::begin(zipped)));
 
   IMapper(MapFunc in_map_func, Containers&&... in_containers)
       : map_func(in_map_func),
@@ -96,7 +96,7 @@ class iter::impl::IMapper {
         : map_func(&in_map_func), zipiter(std::move(in_zipiter)) {}
 
     IMapIterDeref operator*() {
-      return detail::call_with_tuple(*this->map_func, *(this->zipiter));
+      return iter::detail::call_with_tuple(*this->map_func, *(this->zipiter));
     }
 
     ArrowProxy<IMapIterDeref> operator->() {
diff --git a/iteratoriterator.hpp b/iteratoriterator.hpp
index ad330c6c..9752830b 100644
--- a/iteratoriterator.hpp
+++ b/iteratoriterator.hpp
@@ -15,6 +15,7 @@
 // behave like some_collection<T> when iterated over or indexed
 
 namespace iter {
+  namespace impl {
   template <typename T, typename = void>
   struct HasConstDeref : std::false_type {};
 
@@ -75,7 +76,7 @@ namespace iter {
       return **this->sub_iter;
     }
 
-    auto operator-> () -> decltype(*sub_iter) {
+    auto operator -> () -> decltype(*sub_iter) {
       return *this->sub_iter;
     }
 
@@ -264,5 +265,6 @@ namespace iter {
     }
   };
 }
+}
 
 #endif
diff --git a/iterbase.hpp b/iterbase.hpp
index 20585a7a..749c478b 100644
--- a/iterbase.hpp
+++ b/iterbase.hpp
@@ -15,6 +15,7 @@
 #include <cstddef>
 
 namespace iter {
+  namespace impl {
   template <typename T>
   struct type_is {
     using type = T;
@@ -278,5 +279,6 @@ namespace iter {
     }
   };
 }
+}
 
 #endif
diff --git a/range.hpp b/range.hpp
index 0262c7ed..2be9b940 100644
--- a/range.hpp
+++ b/range.hpp
@@ -131,7 +131,7 @@ class iter::impl::Range {
   class Iterator : public std::iterator<std::forward_iterator_tag, T,
                        std::ptrdiff_t, T*, T> {
    private:
-    detail::RangeIterData<T> data;
+    iter::detail::RangeIterData<T> data;
     bool is_end;
 
     // compare unsigned values
diff --git a/sorted.hpp b/sorted.hpp
index 27f67323..d7b56b0a 100644
--- a/sorted.hpp
+++ b/sorted.hpp
@@ -68,9 +68,9 @@ namespace iter {
   template <typename Container>
   auto sorted(Container&& container)
       -> decltype(sorted(std::forward<Container>(container),
-          std::less<const_iterator_deref<Container>>())) {
+          std::less<impl::const_iterator_deref<Container>>())) {
     return sorted(std::forward<Container>(container),
-        std::less<const_iterator_deref<Container>>());
+        std::less<impl::const_iterator_deref<Container>>());
   }
 }
 
diff --git a/test/helpers.hpp b/test/helpers.hpp
index 99cb404b..5a8c0755 100644
--- a/test/helpers.hpp
+++ b/test/helpers.hpp
@@ -172,7 +172,7 @@ class BasicIterable {
         }
 };
 
-using iter::void_t;
+using iter::impl::void_t;
 
 template <typename, typename =void>
 struct IsIterator : std::false_type { };
diff --git a/test/test_iteratoriterator.cpp b/test/test_iteratoriterator.cpp
index e034cc71..ae963688 100644
--- a/test/test_iteratoriterator.cpp
+++ b/test/test_iteratoriterator.cpp
@@ -5,7 +5,7 @@
 
 #include "catch.hpp"
 
-using iter::IterIterWrapper;
+using iter::impl::IterIterWrapper;
 
 TEST_CASE("Iterator over a vector of vector iterators", "[iteratoriterator]") {
     using std::vector;
diff --git a/unique_everseen.hpp b/unique_everseen.hpp
index 23b951c4..2c24adc3 100644
--- a/unique_everseen.hpp
+++ b/unique_everseen.hpp
@@ -15,9 +15,9 @@ namespace iter {
   // performance checking if it has ever been seen
   template <typename Container>
   auto unique_everseen(Container&& container)
-      -> impl::Filtered<std::function<bool(iterator_deref<Container>)>,
+      -> impl::Filtered<std::function<bool(impl::iterator_deref<Container>)>,
           Container> {
-    using elem_t = iterator_deref<Container>;
+    using elem_t = impl::iterator_deref<Container>;
     std::unordered_set<typename std::decay<elem_t>::type> elem_seen;
 
     std::function<bool(elem_t)> func =
diff --git a/unique_justseen.hpp b/unique_justseen.hpp
index 442e658e..eb1baacd 100644
--- a/unique_justseen.hpp
+++ b/unique_justseen.hpp
@@ -13,7 +13,7 @@
 namespace iter {
   template <typename GroupByType>
   struct GroupFrontGetter {
-    auto operator()(iterator_deref<GroupByType> gb)
+    auto operator()(impl::iterator_deref<GroupByType> gb)
         -> decltype(*std::begin(gb.second)) {
       return *std::begin(gb.second);
     }

From 0d6be7da306e9da6b84c0f5532ffcb24380e227a Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 20 Aug 2015 23:18:11 -0700
Subject: [PATCH 1250/1866] renames grouper_examples to chunked_examples

---
 examples/SConstruct                                     | 2 +-
 examples/{grouper_examples.cpp => chunked_examples.cpp} | 6 +++---
 2 files changed, 4 insertions(+), 4 deletions(-)
 rename examples/{grouper_examples.cpp => chunked_examples.cpp} (77%)

diff --git a/examples/SConstruct b/examples/SConstruct
index 9710069b..9e345c01 100644
--- a/examples/SConstruct
+++ b/examples/SConstruct
@@ -17,6 +17,7 @@ progs = Split(
     '''
     accumulate
     chain
+    chunked
     combinatoric
     compress
     count
@@ -26,7 +27,6 @@ progs = Split(
     filter
     filterfalse
     groupby
-    grouper
     imap
     range
     repeat
diff --git a/examples/grouper_examples.cpp b/examples/chunked_examples.cpp
similarity index 77%
rename from examples/grouper_examples.cpp
rename to examples/chunked_examples.cpp
index 0ae6bb40..9c3046f5 100644
--- a/examples/grouper_examples.cpp
+++ b/examples/chunked_examples.cpp
@@ -1,4 +1,4 @@
-#include <grouper.hpp>
+#include <chunked.hpp>
 
 #include <iostream>
 #include <vector>
@@ -6,7 +6,7 @@
 int main() {
     std::cout << "chunk size: 4\n";
     std::vector<int> v {1,2,3,4,5,6,7,8,9}; 
-    for (auto&& sec : iter::grouper(v, 4)) {
+    for (auto&& sec : iter::chunked(v, 4)) {
         for (auto&& i : sec) {
             std::cout << i << " ";
         }
@@ -14,7 +14,7 @@ int main() {
     }
 
     std::cout << "chunk size: 3\n";
-    for (auto&& sec : iter::grouper(v,3)) {
+    for (auto&& sec : iter::chunked(v,3)) {
         for (auto&& i : sec) {
             std::cout << i << " ";
         }

From 09c2d9ca1e766d0209a8680cddab70df6473783f Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 20 Aug 2015 23:52:19 -0700
Subject: [PATCH 1251/1866] clarifies chunked() behavior

---
 README.md | 20 ++++++++++++--------
 1 file changed, 12 insertions(+), 8 deletions(-)

diff --git a/README.md b/README.md
index 26678192..9d214bbc 100644
--- a/README.md
+++ b/README.md
@@ -614,24 +614,28 @@ for (auto&& sec : sliding_window(v,4)) {
 chunked
 ------
 
-chunked is very similar to sliding window, except instead of the
-section sliding by only 1 it goes the length of the full section.
+chunked will yield subsequent chunkes of an iterable in blocks of a specified
+size. The final chunk may be shorter than the rest if the chunk size given
+does not evenly divide the length of the iterable
 
 Example usage:
 ```c++
 vector<int> v {1,2,3,4,5,6,7,8,9};
-for (auto&& sec : chunked(v,4))
-//each section will have 4 elements
-//except the last one may be cut short
-{
+for (auto&& sec : chunked(v,4)) {
     for (auto&& i : sec) {
-        cout << i << " ";
-        i.get() *= 2;
+        cout << i << ' ';
     }
     cout << '\n';
 }
 ```
 
+The above prints:
+```
+1 2 3 4
+5 6 7 8
+9
+```
+
 product
 ------
 *Additional Requirements*: Input must have a ForwardIterator

From 0f33cafb53810b95b35a02469d83f18a82575bad Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 22 Aug 2015 22:59:53 -0700
Subject: [PATCH 1252/1866] tests enumerate with a start index

---
 test/test_enumerate.cpp | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/test/test_enumerate.cpp b/test/test_enumerate.cpp
index 3f315d3e..6f25b3bd 100644
--- a/test/test_enumerate.cpp
+++ b/test/test_enumerate.cpp
@@ -48,6 +48,14 @@ TEST_CASE("Postfix ++ enumerate", "[enumerate]") {
     REQUIRE( (*it).first == 1 );
 }
 
+TEST_CASE("enumerate: with starting value", "[enumerate]") {
+  std::string str = "hey";
+  auto e = enumerate(str, 5);
+  Vec v(std::begin(e), std::end(e));
+  Vec vc{{5, 'h'}, {6, 'e'}, {7, 'y'}};
+
+  REQUIRE( v == vc );
+}
 
 TEST_CASE("Modifications through enumerate affect container", "[enumerate]") {
     std::vector<int> v{1, 2, 3, 4};
@@ -123,7 +131,6 @@ TEST_CASE("Doesn't move or copy elements of iterable", "[enumerate]") {
     }
 }
 
-
 TEST_CASE("enumerate: iterator meets requirements", "[enumerate]") {
     std::string s{};
     auto c = enumerate(s);

From d1d7820c4357b38aaef4fe0966a06d0247d474ad Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 22 Aug 2015 23:00:06 -0700
Subject: [PATCH 1253/1866] adds two-argument enumerate()

---
 enumerate.hpp | 30 ++++++++++++++++--------------
 1 file changed, 16 insertions(+), 14 deletions(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index f8cbc37e..a6c38227 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -16,31 +16,32 @@ namespace iter {
   }
 
   template <typename Container>
-  impl::Enumerable<Container> enumerate(Container&&);
+  impl::Enumerable<Container> enumerate(Container&&, std::size_t = 0);
 
   template <typename T>
   impl::Enumerable<std::initializer_list<T>> enumerate(
-      std::initializer_list<T>);
+      std::initializer_list<T>, std::size_t = 0);
 }
 
 template <typename Container>
 class iter::impl::Enumerable {
  private:
   Container container;
+  const std::size_t start;
 
   // The only thing allowed to directly instantiate an Enumerable is
   // the enumerate function
-  friend Enumerable iter::enumerate<Container>(Container&&);
+  friend Enumerable iter::enumerate<Container>(Container&&, std::size_t);
   template <typename T>
   friend Enumerable<std::initializer_list<T>> iter::enumerate(
-      std::initializer_list<T>);
+      std::initializer_list<T>, std::size_t);
 
   // for IterYield
   using BasePair = std::pair<std::size_t, iterator_deref<Container>>;
 
   // Value constructor for use only in the enumerate function
-  Enumerable(Container&& in_container)
-      : container(std::forward<Container>(in_container)) {}
+  Enumerable(Container&& in_container, std::size_t in_start)
+      : container(std::forward<Container>(in_container)), start{in_start} {}
 
  public:
   // "yielded" by the Enumerable::Iterator.  Has a .index, and a
@@ -61,8 +62,8 @@ class iter::impl::Enumerable {
     std::size_t index;
 
    public:
-    Iterator(iterator_type<Container>&& si)
-        : sub_iter{std::move(si)}, index{0} {}
+    Iterator(iterator_type<Container>&& si, std::size_t start)
+        : sub_iter{std::move(si)}, index{start} {}
 
     IterYield operator*() {
       return {this->index, *this->sub_iter};
@@ -94,23 +95,24 @@ class iter::impl::Enumerable {
   };
 
   Iterator begin() {
-    return {std::begin(this->container)};
+    return {std::begin(this->container), start};
   }
 
   Iterator end() {
-    return {std::end(this->container)};
+    return {std::end(this->container), start};
   }
 };
 
 template <typename Container>
-iter::impl::Enumerable<Container> iter::enumerate(Container&& container) {
-  return {std::forward<Container>(container)};
+iter::impl::Enumerable<Container> iter::enumerate(
+    Container&& container, std::size_t start) {
+  return {std::forward<Container>(container), start};
 }
 
 template <typename T>
 iter::impl::Enumerable<std::initializer_list<T>> iter::enumerate(
-    std::initializer_list<T> il) {
-  return {std::move(il)};
+    std::initializer_list<T> il, std::size_t start) {
+  return {std::move(il), start};
 }
 
 #endif

From d07d09196ce43a8361209373596f81ee76ccc705 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 22 Aug 2015 23:07:51 -0700
Subject: [PATCH 1254/1866] formatting

---
 accumulate.hpp       |   8 +-
 filter.hpp           | 132 ++++++------
 groupby.hpp          |   2 +-
 iteratoriterator.hpp | 493 ++++++++++++++++++++++---------------------
 iterbase.hpp         | 440 +++++++++++++++++++-------------------
 5 files changed, 538 insertions(+), 537 deletions(-)

diff --git a/accumulate.hpp b/accumulate.hpp
index 95b464c0..c43b0a67 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -141,12 +141,12 @@ namespace iter {
   template <typename Container>
   auto accumulate(Container&& container) -> decltype(accumulate(
       std::forward<Container>(container),
-      std::plus<
-          typename std::remove_reference<impl::iterator_deref<Container>>::type>{})) {
+      std::plus<typename std::
+              remove_reference<impl::iterator_deref<Container>>::type>{})) {
     return accumulate(
         std::forward<Container>(container),
-        std::plus<
-            typename std::remove_reference<impl::iterator_deref<Container>>::type>{});
+        std::plus<typename std::
+                remove_reference<impl::iterator_deref<Container>>::type>{});
   }
 
   template <typename T>
diff --git a/filter.hpp b/filter.hpp
index f31aa145..ec79b166 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -43,75 +43,75 @@ class iter::impl::Filtered {
   class Iterator : public std::iterator<std::input_iterator_tag,
                        iterator_traits_deref<Container>> {
    protected:
-     using Holder = DerefHolder<iterator_deref<Container>>;
-     iterator_type<Container> sub_iter;
-     iterator_type<Container> sub_end;
-     Holder item;
-     FilterFunc* filter_func;
-
-     void inc_sub_iter() {
-       ++this->sub_iter;
-       if (this->sub_iter != this->sub_end) {
-         this->item.reset(*this->sub_iter);
-       }
-     }
-
-     // increment until the iterator points to is true on the
-     // predicate.  Called by constructor and operator++
-     void skip_failures() {
-       while (this->sub_iter != this->sub_end
-           && !(*this->filter_func)(this->item.get())) {
-         this->inc_sub_iter();
-       }
-     }
+    using Holder = DerefHolder<iterator_deref<Container>>;
+    iterator_type<Container> sub_iter;
+    iterator_type<Container> sub_end;
+    Holder item;
+    FilterFunc* filter_func;
+
+    void inc_sub_iter() {
+      ++this->sub_iter;
+      if (this->sub_iter != this->sub_end) {
+        this->item.reset(*this->sub_iter);
+      }
+    }
+
+    // increment until the iterator points to is true on the
+    // predicate.  Called by constructor and operator++
+    void skip_failures() {
+      while (this->sub_iter != this->sub_end
+             && !(*this->filter_func)(this->item.get())) {
+        this->inc_sub_iter();
+      }
+    }
 
    public:
-     Iterator(iterator_type<Container> iter, iterator_type<Container> end,
-         FilterFunc& in_filter_func)
-       : sub_iter{iter}, sub_end{end}, filter_func(&in_filter_func) {
-         if (this->sub_iter != this->sub_end) {
-           this->item.reset(*this->sub_iter);
-         }
-         this->skip_failures();
-       }
-
-     typename Holder::reference operator*() {
-       return this->item.get();
-     }
-
-     typename Holder::pointer operator->() {
-       return this->item.get_ptr();
-     }
-
-     Iterator& operator++() {
-       this->inc_sub_iter();
-       this->skip_failures();
-       return *this;
-     }
-
-     Iterator operator++(int) {
-       auto ret = *this;
-       ++*this;
-       return ret;
-     }
-
-     bool operator!=(const Iterator& other) const {
-       return this->sub_iter != other.sub_iter;
-     }
-
-     bool operator==(const Iterator& other) const {
-       return !(*this != other);
-     }
-                       };
+    Iterator(iterator_type<Container> iter, iterator_type<Container> end,
+        FilterFunc& in_filter_func)
+        : sub_iter{iter}, sub_end{end}, filter_func(&in_filter_func) {
+      if (this->sub_iter != this->sub_end) {
+        this->item.reset(*this->sub_iter);
+      }
+      this->skip_failures();
+    }
+
+    typename Holder::reference operator*() {
+      return this->item.get();
+    }
+
+    typename Holder::pointer operator->() {
+      return this->item.get_ptr();
+    }
+
+    Iterator& operator++() {
+      this->inc_sub_iter();
+      this->skip_failures();
+      return *this;
+    }
+
+    Iterator operator++(int) {
+      auto ret = *this;
+      ++*this;
+      return ret;
+    }
+
+    bool operator!=(const Iterator& other) const {
+      return this->sub_iter != other.sub_iter;
+    }
+
+    bool operator==(const Iterator& other) const {
+      return !(*this != other);
+    }
+  };
 
   Iterator begin() {
     return {std::begin(this->container), std::end(this->container),
-      this->filter_func};
+        this->filter_func};
   }
 
   Iterator end() {
     return {std::end(this->container), std::end(this->container),
-      this->filter_func};
+        this->filter_func};
   }
 };
 
@@ -131,14 +131,14 @@ namespace iter {
   namespace detail {
 
     template <typename T>
-      bool boolean_cast(const T& t) {
-        return bool(t);
-      }
+    bool boolean_cast(const T& t) {
+      return bool(t);
+    }
 
     template <typename Container>
-      class BoolTester {
-        public:
-          bool operator()(const impl::iterator_deref<Container> item) const {
+    class BoolTester {
+     public:
+      bool operator()(const impl::iterator_deref<Container> item) const {
         return bool(item);
       }
     };
diff --git a/groupby.hpp b/groupby.hpp
index 8bd6091e..99f0fb74 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -294,7 +294,7 @@ namespace iter {
     template <typename Container>
     class ItemReturner {
      public:
-       impl::iterator_deref<Container> operator()(
+      impl::iterator_deref<Container> operator()(
           impl::iterator_deref<Container> item) const {
         return item;
       }
diff --git a/iteratoriterator.hpp b/iteratoriterator.hpp
index 9752830b..1a6b3f93 100644
--- a/iteratoriterator.hpp
+++ b/iteratoriterator.hpp
@@ -16,255 +16,256 @@
 
 namespace iter {
   namespace impl {
-  template <typename T, typename = void>
-  struct HasConstDeref : std::false_type {};
-
-  template <typename T>
-  struct HasConstDeref<T, void_t<decltype(*std::declval<const T&>())>>
-      : std::true_type {};
-
-  template <typename Iter,
-      typename Diff = typename std::iterator_traits<Iter>::difference_type>
-  class IteratorIterator
-      : public std::iterator<std::random_access_iterator_tag,
-            typename std::iterator_traits<Iter>::value_type, Diff,
-            typename std::iterator_traits<Iter>::pointer,
-            typename std::iterator_traits<Iter>::reference> {
-    static_assert(
-        std::is_same<typename std::iterator_traits<Iter>::iterator_category,
-            std::random_access_iterator_tag>::value,
-        "IteratorIterator only works with random access iterators");
-
-   private:
-    Iter sub_iter;
-
-   public:
-    IteratorIterator() = default;
-    IteratorIterator(const Iter& it) : sub_iter{it} {}
-
-    bool operator==(const IteratorIterator& other) const {
-      return !(*this != other);
-    }
-
-    bool operator!=(const IteratorIterator& other) const {
-      return this->sub_iter != other.sub_iter;
-    }
-
-    IteratorIterator& operator++() {
-      ++this->sub_iter;
-      return *this;
-    }
-
-    IteratorIterator operator++(int) {
-      auto ret = *this;
-      ++*this;
-      return ret;
-    }
-
-    IteratorIterator& operator--() {
-      --this->sub_iter;
-      return *this;
-    }
-
-    IteratorIterator operator--(int) {
-      auto ret = *this;
-      --*this;
-      return ret;
-    }
-
-    auto operator*() -> decltype(**sub_iter) {
-      return **this->sub_iter;
-    }
-
-    auto operator -> () -> decltype(*sub_iter) {
-      return *this->sub_iter;
-    }
-
-    IteratorIterator& operator+=(Diff n) {
-      this->sub_iter += n;
-      return *this;
-    }
-
-    IteratorIterator operator+(Diff n) const {
-      auto it = *this;
-      it += n;
-      return it;
-    }
-
-    friend IteratorIterator operator+(Diff n, IteratorIterator it) {
-      it += n;
-      return it;
-    }
-
-    IteratorIterator& operator-=(Diff n) {
-      this->sub_iter -= n;
-      return *this;
-    }
-
-    IteratorIterator operator-(Diff n) const {
-      auto it = *this;
-      it -= n;
-      return it;
-    }
-
-    friend IteratorIterator operator-(Diff n, IteratorIterator it) {
-      it -= n;
-      return it;
-    }
-
-    Diff operator-(const IteratorIterator& rhs) const {
-      return this->sub_iter - rhs.sub_iter;
-    }
-
-    auto operator[](Diff idx) -> decltype(*sub_iter[idx]) {
-      return *sub_iter[idx];
-    }
-
-    bool operator<(const IteratorIterator& rhs) const {
-      return this->sub_iter < rhs.sub_iter;
-    }
-
-    bool operator>(const IteratorIterator& rhs) const {
-      return this->sub_iter > rhs.sub_iter;
-    }
-
-    bool operator<=(const IteratorIterator& rhs) const {
-      return this->sub_iter <= rhs.sub_iter;
-    }
-
-    bool operator>=(const IteratorIterator& rhs) const {
-      return this->sub_iter >= rhs.sub_iter;
-    }
-  };
-
-  template <typename Container>
-  class IterIterWrapper {
-   private:
-    Container container;
-
-    using contained_iter = typename Container::value_type;
-    using size_type = typename Container::size_type;
-    using iterator = IteratorIterator<typename Container::iterator>;
-    using const_iterator = IteratorIterator<typename Container::const_iterator>;
-    using reverse_iterator =
-        IteratorIterator<typename Container::reverse_iterator>;
-    using const_reverse_iterator =
-        IteratorIterator<typename Container::const_reverse_iterator>;
-
-    template <typename U = Container, typename = void>
-    struct ConstAtTypeOrVoid : type_is<void> {};
-
-    template <typename U>
-    struct ConstAtTypeOrVoid<U,
-        void_t<decltype(*std::declval<const U&>().at(0))>>
-        : type_is<decltype(*std::declval<const U&>().at(0))> {};
-
-    using const_at_type_or_void_t = typename ConstAtTypeOrVoid<>::type;
-
-    template <typename U = Container, typename = void>
-    struct ConstIndexTypeOrVoid : type_is<void> {};
-
-    template <typename U>
-    struct ConstIndexTypeOrVoid<U,
-        void_t<decltype(*std::declval<const U&>()[0])>>
-        : type_is<decltype(*std::declval<const U&>()[0])> {};
-
-    using const_index_type_or_void_t = typename ConstIndexTypeOrVoid<>::type;
-
-   public:
-    IterIterWrapper() = default;
-
-    explicit IterIterWrapper(size_type sz) : container(sz) {}
-
-    IterIterWrapper(size_type sz, const contained_iter& val)
-        : container(sz, val) {}
-
-    auto at(size_type pos) -> decltype(*container.at(pos)) {
-      return *container.at(pos);
-    }
-
-    auto at(size_type pos) const -> const_at_type_or_void_t {
-      return *container.at(pos);
-    }
-
-    auto operator[](size_type pos) noexcept(noexcept(*container[pos]))
-        -> decltype(*container[pos]) {
-      return *container[pos];
-    }
-
-    auto operator[](size_type pos) const noexcept(noexcept(*container[pos]))
-        -> const_index_type_or_void_t {
-      return *container[pos];
-    }
-
-    bool empty() const noexcept {
-      return container.empty();
-    }
-
-    size_type size() const noexcept {
-      return container.size();
-    }
-
-    iterator begin() noexcept {
-      return {container.begin()};
-    }
-
-    iterator end() noexcept {
-      return {container.end()};
-    }
-
-    const_iterator begin() const noexcept {
-      return {container.begin()};
-    }
-
-    const_iterator end() const noexcept {
-      return {container.end()};
-    }
-
-    const_iterator cbegin() const noexcept {
-      return {container.cbegin()};
-    }
-
-    const_iterator cend() const noexcept {
-      return {container.cend()};
-    }
-
-    reverse_iterator rbegin() noexcept {
-      return {container.rbegin()};
-    }
-
-    reverse_iterator rend() noexcept {
-      return {container.rend()};
-    }
-
-    const_reverse_iterator rbegin() const noexcept {
-      return {container.rbegin()};
-    }
-
-    const_reverse_iterator rend() const noexcept {
-      return {container.rend()};
-    }
-
-    const_reverse_iterator crbegin() const noexcept {
-      return {container.rbegin()};
-    }
+    template <typename T, typename = void>
+    struct HasConstDeref : std::false_type {};
+
+    template <typename T>
+    struct HasConstDeref<T, void_t<decltype(*std::declval<const T&>())>>
+        : std::true_type {};
+
+    template <typename Iter,
+        typename Diff = typename std::iterator_traits<Iter>::difference_type>
+    class IteratorIterator
+        : public std::iterator<std::random_access_iterator_tag,
+              typename std::iterator_traits<Iter>::value_type, Diff,
+              typename std::iterator_traits<Iter>::pointer,
+              typename std::iterator_traits<Iter>::reference> {
+      static_assert(
+          std::is_same<typename std::iterator_traits<Iter>::iterator_category,
+              std::random_access_iterator_tag>::value,
+          "IteratorIterator only works with random access iterators");
+
+     private:
+      Iter sub_iter;
+
+     public:
+      IteratorIterator() = default;
+      IteratorIterator(const Iter& it) : sub_iter{it} {}
+
+      bool operator==(const IteratorIterator& other) const {
+        return !(*this != other);
+      }
+
+      bool operator!=(const IteratorIterator& other) const {
+        return this->sub_iter != other.sub_iter;
+      }
+
+      IteratorIterator& operator++() {
+        ++this->sub_iter;
+        return *this;
+      }
+
+      IteratorIterator operator++(int) {
+        auto ret = *this;
+        ++*this;
+        return ret;
+      }
+
+      IteratorIterator& operator--() {
+        --this->sub_iter;
+        return *this;
+      }
+
+      IteratorIterator operator--(int) {
+        auto ret = *this;
+        --*this;
+        return ret;
+      }
+
+      auto operator*() -> decltype(**sub_iter) {
+        return **this->sub_iter;
+      }
+
+      auto operator -> () -> decltype(*sub_iter) {
+        return *this->sub_iter;
+      }
+
+      IteratorIterator& operator+=(Diff n) {
+        this->sub_iter += n;
+        return *this;
+      }
+
+      IteratorIterator operator+(Diff n) const {
+        auto it = *this;
+        it += n;
+        return it;
+      }
+
+      friend IteratorIterator operator+(Diff n, IteratorIterator it) {
+        it += n;
+        return it;
+      }
+
+      IteratorIterator& operator-=(Diff n) {
+        this->sub_iter -= n;
+        return *this;
+      }
+
+      IteratorIterator operator-(Diff n) const {
+        auto it = *this;
+        it -= n;
+        return it;
+      }
+
+      friend IteratorIterator operator-(Diff n, IteratorIterator it) {
+        it -= n;
+        return it;
+      }
+
+      Diff operator-(const IteratorIterator& rhs) const {
+        return this->sub_iter - rhs.sub_iter;
+      }
+
+      auto operator[](Diff idx) -> decltype(*sub_iter[idx]) {
+        return *sub_iter[idx];
+      }
+
+      bool operator<(const IteratorIterator& rhs) const {
+        return this->sub_iter < rhs.sub_iter;
+      }
+
+      bool operator>(const IteratorIterator& rhs) const {
+        return this->sub_iter > rhs.sub_iter;
+      }
+
+      bool operator<=(const IteratorIterator& rhs) const {
+        return this->sub_iter <= rhs.sub_iter;
+      }
+
+      bool operator>=(const IteratorIterator& rhs) const {
+        return this->sub_iter >= rhs.sub_iter;
+      }
+    };
+
+    template <typename Container>
+    class IterIterWrapper {
+     private:
+      Container container;
+
+      using contained_iter = typename Container::value_type;
+      using size_type = typename Container::size_type;
+      using iterator = IteratorIterator<typename Container::iterator>;
+      using const_iterator =
+          IteratorIterator<typename Container::const_iterator>;
+      using reverse_iterator =
+          IteratorIterator<typename Container::reverse_iterator>;
+      using const_reverse_iterator =
+          IteratorIterator<typename Container::const_reverse_iterator>;
+
+      template <typename U = Container, typename = void>
+      struct ConstAtTypeOrVoid : type_is<void> {};
+
+      template <typename U>
+      struct ConstAtTypeOrVoid<U,
+          void_t<decltype(*std::declval<const U&>().at(0))>>
+          : type_is<decltype(*std::declval<const U&>().at(0))> {};
+
+      using const_at_type_or_void_t = typename ConstAtTypeOrVoid<>::type;
+
+      template <typename U = Container, typename = void>
+      struct ConstIndexTypeOrVoid : type_is<void> {};
+
+      template <typename U>
+      struct ConstIndexTypeOrVoid<U,
+          void_t<decltype(*std::declval<const U&>()[0])>>
+          : type_is<decltype(*std::declval<const U&>()[0])> {};
+
+      using const_index_type_or_void_t = typename ConstIndexTypeOrVoid<>::type;
+
+     public:
+      IterIterWrapper() = default;
+
+      explicit IterIterWrapper(size_type sz) : container(sz) {}
+
+      IterIterWrapper(size_type sz, const contained_iter& val)
+          : container(sz, val) {}
+
+      auto at(size_type pos) -> decltype(*container.at(pos)) {
+        return *container.at(pos);
+      }
+
+      auto at(size_type pos) const -> const_at_type_or_void_t {
+        return *container.at(pos);
+      }
+
+      auto operator[](size_type pos) noexcept(noexcept(*container[pos]))
+          -> decltype(*container[pos]) {
+        return *container[pos];
+      }
+
+      auto operator[](size_type pos) const noexcept(noexcept(*container[pos]))
+          -> const_index_type_or_void_t {
+        return *container[pos];
+      }
+
+      bool empty() const noexcept {
+        return container.empty();
+      }
+
+      size_type size() const noexcept {
+        return container.size();
+      }
+
+      iterator begin() noexcept {
+        return {container.begin()};
+      }
+
+      iterator end() noexcept {
+        return {container.end()};
+      }
+
+      const_iterator begin() const noexcept {
+        return {container.begin()};
+      }
+
+      const_iterator end() const noexcept {
+        return {container.end()};
+      }
+
+      const_iterator cbegin() const noexcept {
+        return {container.cbegin()};
+      }
+
+      const_iterator cend() const noexcept {
+        return {container.cend()};
+      }
+
+      reverse_iterator rbegin() noexcept {
+        return {container.rbegin()};
+      }
+
+      reverse_iterator rend() noexcept {
+        return {container.rend()};
+      }
+
+      const_reverse_iterator rbegin() const noexcept {
+        return {container.rbegin()};
+      }
+
+      const_reverse_iterator rend() const noexcept {
+        return {container.rend()};
+      }
+
+      const_reverse_iterator crbegin() const noexcept {
+        return {container.rbegin()};
+      }
 
-    const_reverse_iterator crend() const noexcept {
-      return {container.rend()};
-    }
+      const_reverse_iterator crend() const noexcept {
+        return {container.rend()};
+      }
 
-    // get() exposes the underlying container.  this allows the
-    // itertools to manipulate the iterators in the container
-    // and should not be depended on anywhere else.
-    Container& get() noexcept {
-      return container;
-    }
+      // get() exposes the underlying container.  this allows the
+      // itertools to manipulate the iterators in the container
+      // and should not be depended on anywhere else.
+      Container& get() noexcept {
+        return container;
+      }
 
-    const Container& get() const noexcept {
-      return container;
-    }
-  };
-}
+      const Container& get() const noexcept {
+        return container;
+      }
+    };
+  }
 }
 
 #endif
diff --git a/iterbase.hpp b/iterbase.hpp
index 749c478b..44b779cc 100644
--- a/iterbase.hpp
+++ b/iterbase.hpp
@@ -16,269 +16,269 @@
 
 namespace iter {
   namespace impl {
-  template <typename T>
-  struct type_is {
-    using type = T;
-  };
-
-  // gcc CWG 1558
-  template <typename...>
-  struct void_t_help {
-    using type = void;
-  };
-  template <typename... Ts>
-  using void_t = typename void_t_help<Ts...>::type;
-
-  // iterator_type<C> is the type of C's iterator
-  template <typename Container>
-  using iterator_type = decltype(std::begin(std::declval<Container&>()));
-
-  // iterator_deref<C> is the type obtained by dereferencing an iterator
-  // to an object of type C
-  template <typename Container>
-  using iterator_deref = decltype(*std::declval<iterator_type<Container>&>());
-
-  // const_iteator_deref is the type obtained through dereferencing
-  // a const iterator& (note: not a const_iterator).  ie: the result
-  // of Container::iterator::operator*() const
-  template <typename Container>
-  using const_iterator_deref =
-      decltype(*std::declval<const iterator_type<Container>&>());
-
-  template <typename Container>
-  using iterator_traits_deref =
-      typename std::remove_reference<iterator_deref<Container>>::type;
-
-  // iterator_type<C> is the type of C's iterator
-  template <typename Container>
-  using reverse_iterator_type = decltype(std::declval<Container&>().rbegin());
-
-  // iterator_deref<C> is the type obtained by dereferencing an iterator
-  // to an object of type C
-  template <typename Container>
-  using reverse_iterator_deref =
-      decltype(*std::declval<reverse_iterator_type<Container>&>());
-
-  namespace detail {
-    template <typename T, typename = void>
-    struct ArrowHelper {
-      using type = void;
-    };
-
     template <typename T>
-    struct ArrowHelper<T*, void> {
-      using type = T*;
-      constexpr type operator()(T* t) const noexcept {
-        return t;
-      }
+    struct type_is {
+      using type = T;
     };
 
-    template <typename T>
-    struct ArrowHelper<T, void_t<decltype(std::declval<T&>().operator->())>> {
-      using type = decltype(std::declval<T&>().operator->());
-      type operator()(T& t) const {
-        return t.operator->();
-      }
+    // gcc CWG 1558
+    template <typename...>
+    struct void_t_help {
+      using type = void;
     };
+    template <typename... Ts>
+    using void_t = typename void_t_help<Ts...>::type;
+
+    // iterator_type<C> is the type of C's iterator
+    template <typename Container>
+    using iterator_type = decltype(std::begin(std::declval<Container&>()));
+
+    // iterator_deref<C> is the type obtained by dereferencing an iterator
+    // to an object of type C
+    template <typename Container>
+    using iterator_deref = decltype(*std::declval<iterator_type<Container>&>());
+
+    // const_iteator_deref is the type obtained through dereferencing
+    // a const iterator& (note: not a const_iterator).  ie: the result
+    // of Container::iterator::operator*() const
+    template <typename Container>
+    using const_iterator_deref =
+        decltype(*std::declval<const iterator_type<Container>&>());
+
+    template <typename Container>
+    using iterator_traits_deref =
+        typename std::remove_reference<iterator_deref<Container>>::type;
+
+    // iterator_type<C> is the type of C's iterator
+    template <typename Container>
+    using reverse_iterator_type = decltype(std::declval<Container&>().rbegin());
+
+    // iterator_deref<C> is the type obtained by dereferencing an iterator
+    // to an object of type C
+    template <typename Container>
+    using reverse_iterator_deref =
+        decltype(*std::declval<reverse_iterator_type<Container>&>());
+
+    namespace detail {
+      template <typename T, typename = void>
+      struct ArrowHelper {
+        using type = void;
+      };
+
+      template <typename T>
+      struct ArrowHelper<T*, void> {
+        using type = T*;
+        constexpr type operator()(T* t) const noexcept {
+          return t;
+        }
+      };
+
+      template <typename T>
+      struct ArrowHelper<T, void_t<decltype(std::declval<T&>().operator->())>> {
+        using type = decltype(std::declval<T&>().operator->());
+        type operator()(T& t) const {
+          return t.operator->();
+        }
+      };
+
+      template <typename T>
+      using arrow = typename detail::ArrowHelper<T>::type;
+    }
+
+    // type of C::iterator::operator->, also works with pointers
+    // void if the iterator has no operator->
+    template <typename C>
+    using iterator_arrow = detail::arrow<iterator_type<C>>;
 
+    template <typename C>
+    using reverse_iterator_arrow = detail::arrow<reverse_iterator_type<C>>;
+
+    // applys the -> operator to an object, if the object is a pointer,
+    // it returns the pointer
     template <typename T>
-    using arrow = typename detail::ArrowHelper<T>::type;
-  }
+    detail::arrow<T> apply_arrow(T& t) {
+      return detail::ArrowHelper<T>{}(t);
+    }
 
-  // type of C::iterator::operator->, also works with pointers
-  // void if the iterator has no operator->
-  template <typename C>
-  using iterator_arrow = detail::arrow<iterator_type<C>>;
+    // For iterators that have an operator* which returns a value
+    // they can return this type from their operator-> instead, which will
+    // wrap an object and allow it to be used with arrow
+    template <typename T>
+    class ArrowProxy {
+     private:
+      using TPlain = typename std::remove_reference<T>::type;
+      T obj;
 
-  template <typename C>
-  using reverse_iterator_arrow = detail::arrow<reverse_iterator_type<C>>;
+     public:
+      constexpr ArrowProxy(T&& in_obj) : obj(std::forward<T>(in_obj)) {}
 
-  // applys the -> operator to an object, if the object is a pointer,
-  // it returns the pointer
-  template <typename T>
-  detail::arrow<T> apply_arrow(T& t) {
-    return detail::ArrowHelper<T>{}(t);
-  }
+      TPlain* operator->() {
+        return &obj;
+      }
+    };
 
-  // For iterators that have an operator* which returns a value
-  // they can return this type from their operator-> instead, which will
-  // wrap an object and allow it to be used with arrow
-  template <typename T>
-  class ArrowProxy {
-   private:
-    using TPlain = typename std::remove_reference<T>::type;
-    T obj;
+    template <typename, typename = void>
+    struct is_random_access_iter : std::false_type {};
 
-   public:
-    constexpr ArrowProxy(T&& in_obj) : obj(std::forward<T>(in_obj)) {}
+    template <typename T>
+    struct is_random_access_iter<T,
+        typename std::enable_if<std::is_same<typename std::iterator_traits<T>::
+                                                 iterator_category,
+                                    std::random_access_iterator_tag>::value,
+                                     void>::type> : std::true_type {};
 
-    TPlain* operator->() {
-      return &obj;
-    }
-  };
-
-  template <typename, typename = void>
-  struct is_random_access_iter : std::false_type {};
-
-  template <typename T>
-  struct is_random_access_iter<T,
-      typename std::enable_if<std::is_same<typename std::iterator_traits<T>::
-                                               iterator_category,
-                                  std::random_access_iterator_tag>::value,
-                                   void>::type> : std::true_type {};
-
-  template <typename T>
-  using has_random_access_iter = is_random_access_iter<iterator_type<T>>;
-  // because std::advance assumes a lot and is actually smart, I need a dumb
-
-  // version that will work with most things
-  template <typename InputIt, typename Distance = std::size_t>
-  void dumb_advance(InputIt& iter, Distance distance = 1) {
-    for (Distance i(0); i < distance; ++i) {
-      ++iter;
+    template <typename T>
+    using has_random_access_iter = is_random_access_iter<iterator_type<T>>;
+    // because std::advance assumes a lot and is actually smart, I need a dumb
+
+    // version that will work with most things
+    template <typename InputIt, typename Distance = std::size_t>
+    void dumb_advance(InputIt& iter, Distance distance = 1) {
+      for (Distance i(0); i < distance; ++i) {
+        ++iter;
+      }
     }
-  }
 
-  template <typename Iter, typename Distance>
-  void dumb_advance_impl(
-      Iter& iter, const Iter& end, Distance distance, std::false_type) {
-    for (Distance i(0); i < distance && iter != end; ++i) {
-      ++iter;
+    template <typename Iter, typename Distance>
+    void dumb_advance_impl(
+        Iter& iter, const Iter& end, Distance distance, std::false_type) {
+      for (Distance i(0); i < distance && iter != end; ++i) {
+        ++iter;
+      }
     }
-  }
 
-  template <typename Iter, typename Distance>
-  void dumb_advance_impl(
-      Iter& iter, const Iter& end, Distance distance, std::true_type) {
-    if (static_cast<Distance>(end - iter) < distance) {
-      iter = end;
-    } else {
-      iter += distance;
+    template <typename Iter, typename Distance>
+    void dumb_advance_impl(
+        Iter& iter, const Iter& end, Distance distance, std::true_type) {
+      if (static_cast<Distance>(end - iter) < distance) {
+        iter = end;
+      } else {
+        iter += distance;
+      }
     }
-  }
 
-  // iter will not be incremented past end
-  template <typename Iter, typename Distance = std::size_t>
-  void dumb_advance(Iter& iter, const Iter& end, Distance distance = 1) {
-    dumb_advance_impl(iter, end, distance, is_random_access_iter<Iter>{});
-  }
+    // iter will not be incremented past end
+    template <typename Iter, typename Distance = std::size_t>
+    void dumb_advance(Iter& iter, const Iter& end, Distance distance = 1) {
+      dumb_advance_impl(iter, end, distance, is_random_access_iter<Iter>{});
+    }
 
-  template <typename ForwardIt, typename Distance = std::size_t>
-  ForwardIt dumb_next(ForwardIt it, Distance distance = 1) {
-    dumb_advance(it, distance);
-    return it;
-  }
+    template <typename ForwardIt, typename Distance = std::size_t>
+    ForwardIt dumb_next(ForwardIt it, Distance distance = 1) {
+      dumb_advance(it, distance);
+      return it;
+    }
 
-  template <typename ForwardIt, typename Distance = std::size_t>
-  ForwardIt dumb_next(
-      ForwardIt it, const ForwardIt& end, Distance distance = 1) {
-    dumb_advance(it, end, distance);
-    return it;
-  }
+    template <typename ForwardIt, typename Distance = std::size_t>
+    ForwardIt dumb_next(
+        ForwardIt it, const ForwardIt& end, Distance distance = 1) {
+      dumb_advance(it, end, distance);
+      return it;
+    }
 
-  template <typename Container, typename Distance = std::size_t>
-  Distance dumb_size(Container&& container) {
-    Distance d{0};
-    for (auto it = std::begin(container), end = std::end(container); it != end;
-         ++it) {
-      ++d;
+    template <typename Container, typename Distance = std::size_t>
+    Distance dumb_size(Container&& container) {
+      Distance d{0};
+      for (auto it = std::begin(container), end = std::end(container);
+           it != end; ++it) {
+        ++d;
+      }
+      return d;
     }
-    return d;
-  }
 
-  template <typename... Ts>
-  struct are_same : std::true_type {};
+    template <typename... Ts>
+    struct are_same : std::true_type {};
 
-  template <typename T, typename U, typename... Ts>
-  struct are_same<T, U, Ts...>
-      : std::integral_constant<bool,
-            std::is_same<T, U>::value && are_same<T, Ts...>::value> {};
+    template <typename T, typename U, typename... Ts>
+    struct are_same<T, U, Ts...>
+        : std::integral_constant<bool,
+              std::is_same<T, U>::value && are_same<T, Ts...>::value> {};
 
-  // DerefHolder holds the value gotten from an iterator dereference
-  // if the iterate dereferences to an lvalue references, a pointer to the
-  //     element is stored
-  // if it does not, a value is stored instead
-  // get() returns a reference to the held item
-  // get_ptr() returns a pointer to the held item
-  // reset() replaces the currently held item
+    // DerefHolder holds the value gotten from an iterator dereference
+    // if the iterate dereferences to an lvalue references, a pointer to the
+    //     element is stored
+    // if it does not, a value is stored instead
+    // get() returns a reference to the held item
+    // get_ptr() returns a pointer to the held item
+    // reset() replaces the currently held item
 
-  template <typename T, typename = void>
-  class DerefHolder {
-   private:
-    static_assert(!std::is_lvalue_reference<T>::value,
-        "Non-lvalue-ref specialization used for lvalue ref type");
-    // it could still be an rvalue reference
-    using TPlain = typename std::remove_reference<T>::type;
+    template <typename T, typename = void>
+    class DerefHolder {
+     private:
+      static_assert(!std::is_lvalue_reference<T>::value,
+          "Non-lvalue-ref specialization used for lvalue ref type");
+      // it could still be an rvalue reference
+      using TPlain = typename std::remove_reference<T>::type;
 
-    std::unique_ptr<TPlain> item_p;
+      std::unique_ptr<TPlain> item_p;
 
-   public:
-    using reference = TPlain&;
-    using pointer = TPlain*;
+     public:
+      using reference = TPlain&;
+      using pointer = TPlain*;
 
-    DerefHolder() = default;
+      DerefHolder() = default;
 
-    DerefHolder(const DerefHolder& other)
-        : item_p{other.item_p ? new TPlain(*other.item_p) : nullptr} {}
+      DerefHolder(const DerefHolder& other)
+          : item_p{other.item_p ? new TPlain(*other.item_p) : nullptr} {}
 
-    DerefHolder& operator=(const DerefHolder& other) {
-      this->item_p.reset(other.item_p ? new TPlain(*other.item_p) : nullptr);
-      return *this;
-    }
+      DerefHolder& operator=(const DerefHolder& other) {
+        this->item_p.reset(other.item_p ? new TPlain(*other.item_p) : nullptr);
+        return *this;
+      }
 
-    DerefHolder(DerefHolder&&) = default;
-    DerefHolder& operator=(DerefHolder&&) = default;
-    ~DerefHolder() = default;
+      DerefHolder(DerefHolder&&) = default;
+      DerefHolder& operator=(DerefHolder&&) = default;
+      ~DerefHolder() = default;
 
-    reference get() {
-      return *this->item_p;
-    }
+      reference get() {
+        return *this->item_p;
+      }
 
-    pointer get_ptr() {
-      return this->item_p.get();
-    }
+      pointer get_ptr() {
+        return this->item_p.get();
+      }
 
-    void reset(T&& item) {
-      item_p.reset(new TPlain(std::move(item)));
-    }
+      void reset(T&& item) {
+        item_p.reset(new TPlain(std::move(item)));
+      }
 
-    explicit operator bool() const {
-      return this->item_p;
-    }
-  };
+      explicit operator bool() const {
+        return this->item_p;
+      }
+    };
 
-  // Specialization for when T is an lvalue ref.  Keep this in mind
-  // wherever a T appears.
-  template <typename T>
-  class DerefHolder<T,
-      typename std::enable_if<std::is_lvalue_reference<T>::value>::type> {
-   public:
-    using reference = T;
-    using pointer = typename std::remove_reference<T>::type*;
+    // Specialization for when T is an lvalue ref.  Keep this in mind
+    // wherever a T appears.
+    template <typename T>
+    class DerefHolder<T,
+        typename std::enable_if<std::is_lvalue_reference<T>::value>::type> {
+     public:
+      using reference = T;
+      using pointer = typename std::remove_reference<T>::type*;
 
-   private:
-    pointer item_p{};
+     private:
+      pointer item_p{};
 
-   public:
-    DerefHolder() = default;
+     public:
+      DerefHolder() = default;
 
-    reference get() {
-      return *this->item_p;
-    }
+      reference get() {
+        return *this->item_p;
+      }
 
-    pointer get_ptr() {
-      return this->item_p;
-    }
+      pointer get_ptr() {
+        return this->item_p;
+      }
 
-    void reset(T item) {
-      this->item_p = &item;
-    }
+      void reset(T item) {
+        this->item_p = &item;
+      }
 
-    explicit operator bool() const {
-      return this->item_p != nullptr;
-    }
-  };
-}
+      explicit operator bool() const {
+        return this->item_p != nullptr;
+      }
+    };
+  }
 }
 
 #endif

From aee0a31b21e3e124f04100d1b3113e5084b9c16c Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 22 Aug 2015 23:17:34 -0700
Subject: [PATCH 1255/1866] moves iterbase and iteratoriterator into sub dir

internal/ to keep make it less outwardly available/obvious
---
 accumulate.hpp                                        | 2 +-
 chain.hpp                                             | 2 +-
 chunked.hpp                                           | 4 ++--
 combinations.hpp                                      | 4 ++--
 combinations_with_replacement.hpp                     | 4 ++--
 compress.hpp                                          | 2 +-
 cycle.hpp                                             | 2 +-
 dropwhile.hpp                                         | 2 +-
 enumerate.hpp                                         | 2 +-
 filter.hpp                                            | 2 +-
 filterfalse.hpp                                       | 2 +-
 groupby.hpp                                           | 2 +-
 iteratoriterator.hpp => internal/iteratoriterator.hpp | 0
 iterbase.hpp => internal/iterbase.hpp                 | 0
 permutations.hpp                                      | 4 ++--
 powerset.hpp                                          | 2 +-
 product.hpp                                           | 2 +-
 range.hpp                                             | 2 +-
 reversed.hpp                                          | 2 +-
 slice.hpp                                             | 2 +-
 sliding_window.hpp                                    | 4 ++--
 sorted.hpp                                            | 4 ++--
 takewhile.hpp                                         | 2 +-
 test/helpers.hpp                                      | 2 +-
 test/test_iteratoriterator.cpp                        | 2 +-
 unique_everseen.hpp                                   | 2 +-
 unique_justseen.hpp                                   | 2 +-
 zip.hpp                                               | 2 +-
 zip_longest.hpp                                       | 2 +-
 29 files changed, 33 insertions(+), 33 deletions(-)
 rename iteratoriterator.hpp => internal/iteratoriterator.hpp (100%)
 rename iterbase.hpp => internal/iterbase.hpp (100%)

diff --git a/accumulate.hpp b/accumulate.hpp
index c43b0a67..8e94dee0 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -1,7 +1,7 @@
 #ifndef ITER_ACCUMULATE_H_
 #define ITER_ACCUMULATE_H_
 
-#include "iterbase.hpp"
+#include "internal/iterbase.hpp"
 
 #include <utility>
 #include <iterator>
diff --git a/chain.hpp b/chain.hpp
index 0e8c3343..5dbda67d 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -1,7 +1,7 @@
 #ifndef ITER_CHAIN_HPP_
 #define ITER_CHAIN_HPP_
 
-#include "iterbase.hpp"
+#include "internal/iterbase.hpp"
 
 #include <utility>
 #include <iterator>
diff --git a/chunked.hpp b/chunked.hpp
index 5b5981aa..0a1fd5fe 100644
--- a/chunked.hpp
+++ b/chunked.hpp
@@ -1,8 +1,8 @@
 #ifndef ITER_CHUNKED_HPP_
 #define ITER_CHUNKED_HPP_
 
-#include "iterbase.hpp"
-#include "iteratoriterator.hpp"
+#include "internal/iterbase.hpp"
+#include "internal/iteratoriterator.hpp"
 
 #include <vector>
 #include <algorithm>
diff --git a/combinations.hpp b/combinations.hpp
index 83be1851..3ba5ef60 100644
--- a/combinations.hpp
+++ b/combinations.hpp
@@ -1,8 +1,8 @@
 #ifndef ITER_COMBINATIONS_HPP_
 #define ITER_COMBINATIONS_HPP_
 
-#include "iterbase.hpp"
-#include "iteratoriterator.hpp"
+#include "internal/iterbase.hpp"
+#include "internal/iteratoriterator.hpp"
 
 #include <vector>
 #include <type_traits>
diff --git a/combinations_with_replacement.hpp b/combinations_with_replacement.hpp
index 64c139ba..c2f7f025 100644
--- a/combinations_with_replacement.hpp
+++ b/combinations_with_replacement.hpp
@@ -1,8 +1,8 @@
 #ifndef ITER_COMBINATIONS_WITH_REPLACEMENT_HPP_
 #define ITER_COMBINATIONS_WITH_REPLACEMENT_HPP_
 
-#include "iterbase.hpp"
-#include "iteratoriterator.hpp"
+#include "internal/iterbase.hpp"
+#include "internal/iteratoriterator.hpp"
 
 #include <iterator>
 #include <vector>
diff --git a/compress.hpp b/compress.hpp
index d6ef8096..7e19a4c5 100644
--- a/compress.hpp
+++ b/compress.hpp
@@ -1,7 +1,7 @@
 #ifndef ITER_COMPRESS_H_
 #define ITER_COMPRESS_H_
 
-#include "iterbase.hpp"
+#include "internal/iterbase.hpp"
 
 #include <utility>
 #include <iterator>
diff --git a/cycle.hpp b/cycle.hpp
index 07356032..001cf719 100644
--- a/cycle.hpp
+++ b/cycle.hpp
@@ -1,7 +1,7 @@
 #ifndef ITER_CYCLE_H_
 #define ITER_CYCLE_H_
 
-#include "iterbase.hpp"
+#include "internal/iterbase.hpp"
 
 #include <utility>
 #include <iterator>
diff --git a/dropwhile.hpp b/dropwhile.hpp
index 9efbdbc3..76975dfc 100644
--- a/dropwhile.hpp
+++ b/dropwhile.hpp
@@ -1,7 +1,7 @@
 #ifndef ITER_DROPWHILE_H_
 #define ITER_DROPWHILE_H_
 
-#include "iterbase.hpp"
+#include "internal/iterbase.hpp"
 
 #include <utility>
 #include <iterator>
diff --git a/enumerate.hpp b/enumerate.hpp
index a6c38227..ffb2a8eb 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -1,7 +1,7 @@
 #ifndef ITER_ENUMERATE_H_
 #define ITER_ENUMERATE_H_
 
-#include "iterbase.hpp"
+#include "internal/iterbase.hpp"
 
 #include <utility>
 #include <iterator>
diff --git a/filter.hpp b/filter.hpp
index ec79b166..381ad056 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -1,7 +1,7 @@
 #ifndef ITER_FILTER_H_
 #define ITER_FILTER_H_
 
-#include "iterbase.hpp"
+#include "internal/iterbase.hpp"
 
 #include <utility>
 #include <iterator>
diff --git a/filterfalse.hpp b/filterfalse.hpp
index 850cfec4..425893e0 100644
--- a/filterfalse.hpp
+++ b/filterfalse.hpp
@@ -1,7 +1,7 @@
 #ifndef ITER_FILTER_FALSE_HPP_
 #define ITER_FILTER_FALSE_HPP_
 
-#include "iterbase.hpp"
+#include "internal/iterbase.hpp"
 #include "filter.hpp"
 
 #include <utility>
diff --git a/groupby.hpp b/groupby.hpp
index 99f0fb74..f02edca0 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -3,7 +3,7 @@
 
 // this is easily the most functionally complex itertool
 
-#include "iterbase.hpp"
+#include "internal/iterbase.hpp"
 
 #include <type_traits>
 #include <memory>
diff --git a/iteratoriterator.hpp b/internal/iteratoriterator.hpp
similarity index 100%
rename from iteratoriterator.hpp
rename to internal/iteratoriterator.hpp
diff --git a/iterbase.hpp b/internal/iterbase.hpp
similarity index 100%
rename from iterbase.hpp
rename to internal/iterbase.hpp
diff --git a/permutations.hpp b/permutations.hpp
index 9e970121..a847956a 100644
--- a/permutations.hpp
+++ b/permutations.hpp
@@ -1,8 +1,8 @@
 #ifndef ITER_PERMUTATIONS_HPP_
 #define ITER_PERMUTATIONS_HPP_
 
-#include "iterbase.hpp"
-#include "iteratoriterator.hpp"
+#include "internal/iterbase.hpp"
+#include "internal/iteratoriterator.hpp"
 
 #include <algorithm>
 #include <initializer_list>
diff --git a/powerset.hpp b/powerset.hpp
index d69d94d5..c1cd96dc 100644
--- a/powerset.hpp
+++ b/powerset.hpp
@@ -1,7 +1,7 @@
 #ifndef ITER_POWERSET_HPP_
 #define ITER_POWERSET_HPP_
 
-#include "iterbase.hpp"
+#include "internal/iterbase.hpp"
 #include "combinations.hpp"
 
 #include <cassert>
diff --git a/product.hpp b/product.hpp
index c8b41a64..f83d5221 100644
--- a/product.hpp
+++ b/product.hpp
@@ -1,7 +1,7 @@
 #ifndef ITER_PRODUCT_HPP_
 #define ITER_PRODUCT_HPP_
 
-#include "iterbase.hpp"
+#include "internal/iterbase.hpp"
 
 #include <iterator>
 #include <tuple>
diff --git a/range.hpp b/range.hpp
index 2be9b940..3c142da8 100644
--- a/range.hpp
+++ b/range.hpp
@@ -1,7 +1,7 @@
 #ifndef ITER_RANGE_H_
 #define ITER_RANGE_H_
 
-#include "iterbase.hpp"
+#include "internal/iterbase.hpp"
 
 #include <exception>
 #include <type_traits>
diff --git a/reversed.hpp b/reversed.hpp
index 711890de..c52f1e4a 100644
--- a/reversed.hpp
+++ b/reversed.hpp
@@ -1,7 +1,7 @@
 #ifndef ITER_REVERSE_HPP_
 #define ITER_REVERSE_HPP_
 
-#include "iterbase.hpp"
+#include "internal/iterbase.hpp"
 
 #include <utility>
 #include <iterator>
diff --git a/slice.hpp b/slice.hpp
index 703a3305..e960da85 100644
--- a/slice.hpp
+++ b/slice.hpp
@@ -1,7 +1,7 @@
 #ifndef ITER_SLICE_HPP_
 #define ITER_SLICE_HPP_
 
-#include "iterbase.hpp"
+#include "internal/iterbase.hpp"
 
 #include <iterator>
 #include <type_traits>
diff --git a/sliding_window.hpp b/sliding_window.hpp
index 75fb0bf4..9493afe0 100644
--- a/sliding_window.hpp
+++ b/sliding_window.hpp
@@ -1,8 +1,8 @@
 #ifndef ITER_SLIDING_WINDOW_HPP_
 #define ITER_SLIDING_WINDOW_HPP_
 
-#include "iterbase.hpp"
-#include "iteratoriterator.hpp"
+#include "internal/iterbase.hpp"
+#include "internal/iteratoriterator.hpp"
 
 #include <deque>
 #include <utility>
diff --git a/sorted.hpp b/sorted.hpp
index d7b56b0a..7eee9881 100644
--- a/sorted.hpp
+++ b/sorted.hpp
@@ -1,8 +1,8 @@
 #ifndef ITER_SORTED_HPP_
 #define ITER_SORTED_HPP_
 
-#include "iterbase.hpp"
-#include "iteratoriterator.hpp"
+#include "internal/iterbase.hpp"
+#include "internal/iteratoriterator.hpp"
 
 #include <iterator>
 #include <algorithm>
diff --git a/takewhile.hpp b/takewhile.hpp
index 29dd4c55..1449d154 100644
--- a/takewhile.hpp
+++ b/takewhile.hpp
@@ -1,7 +1,7 @@
 #ifndef ITER_TAKEWHILE_H_
 #define ITER_TAKEWHILE_H_
 
-#include "iterbase.hpp"
+#include "internal/iterbase.hpp"
 
 #include <utility>
 #include <iterator>
diff --git a/test/helpers.hpp b/test/helpers.hpp
index 5a8c0755..1b370f89 100644
--- a/test/helpers.hpp
+++ b/test/helpers.hpp
@@ -1,7 +1,7 @@
 #ifndef TEST_HELPER_H_
 #define TEST_HELPER_H_
 
-#include <iterbase.hpp>
+#include <internal/iterbase.hpp>
 
 #include <stdexcept>
 #include <type_traits>
diff --git a/test/test_iteratoriterator.cpp b/test/test_iteratoriterator.cpp
index ae963688..6903d8cf 100644
--- a/test/test_iteratoriterator.cpp
+++ b/test/test_iteratoriterator.cpp
@@ -1,4 +1,4 @@
-#include <iteratoriterator.hpp>
+#include <internal/iteratoriterator.hpp>
 
 #include <vector>
 #include <string>
diff --git a/unique_everseen.hpp b/unique_everseen.hpp
index 2c24adc3..5a993304 100644
--- a/unique_everseen.hpp
+++ b/unique_everseen.hpp
@@ -1,7 +1,7 @@
 #ifndef ITER_UNIQUE_EVERSEEN_HPP_
 #define ITER_UNIQUE_EVERSEEN_HPP_
 
-#include "iterbase.hpp"
+#include "internal/iterbase.hpp"
 #include "filter.hpp"
 
 #include <type_traits>
diff --git a/unique_justseen.hpp b/unique_justseen.hpp
index eb1baacd..8d5c6f30 100644
--- a/unique_justseen.hpp
+++ b/unique_justseen.hpp
@@ -1,7 +1,7 @@
 #ifndef ITER_UNIQUE_JUSTSEEN_HPP
 #define ITER_UNIQUE_JUSTSEEN_HPP
 
-#include "iterbase.hpp"
+#include "internal/iterbase.hpp"
 #include "groupby.hpp"
 #include "imap.hpp"
 
diff --git a/zip.hpp b/zip.hpp
index 23e56221..154cd2a7 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -1,7 +1,7 @@
 #ifndef ITER_ZIP_HPP_
 #define ITER_ZIP_HPP_
 
-#include "iterbase.hpp"
+#include "internal/iterbase.hpp"
 
 #include <iterator>
 #include <tuple>
diff --git a/zip_longest.hpp b/zip_longest.hpp
index cde50074..a2321a46 100644
--- a/zip_longest.hpp
+++ b/zip_longest.hpp
@@ -1,7 +1,7 @@
 #ifndef ITER_ZIP_LONGEST_HPP_
 #define ITER_ZIP_LONGEST_HPP_
 
-#include "iterbase.hpp"
+#include "internal/iterbase.hpp"
 
 #include <boost/optional.hpp>
 #include <iterator>

From eb0230ad8cb09b3f82ee866c01bb941332c843c9 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 22 Aug 2015 23:32:12 -0700
Subject: [PATCH 1256/1866] notes requirements on accumulate and reversed

---
 README.md | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/README.md b/README.md
index 9d214bbc..01ef6796 100644
--- a/README.md
+++ b/README.md
@@ -365,6 +365,9 @@ Thus, if the group is unsorted, the same key may appear multiple times.
 
 accumulate
 -------
+*Additional Requirements*: Type return from functor (with reference removed)
+must be assignable.
+
 Differs from `std::accumulate` (which in my humble opinion should be named
 `std::reduce` or `std::foldl`).  It is similar to a functional reduce where one
 can see all of the intermediate results.  By default, it keeps a running sum.
@@ -556,6 +559,8 @@ for (auto&& i : chain.from_iterable(matrix)) {
 
 reversed
 -------
+*Additional Requirements*: Input must have `.rbegin()` and `.rend()`, or be
+a plain C array.
 
 Iterates over elements of a sequence in reverse order.
 

From 50f605924bf8f9ef31eb71d362a5f53d04da11df Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 22 Aug 2015 23:56:56 -0700
Subject: [PATCH 1257/1866] clarifies permutations requirement

---
 README.md | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index 01ef6796..bbc54e7d 100644
--- a/README.md
+++ b/README.md
@@ -696,13 +696,12 @@ for (auto&& v : combinations_with_replacement(s, 2)) {
 }
 ```
 
-
 permutations
 -----------
-*Additional Requirements*: Input must have a ForwardIterator
+*Additional Requirements*: Input must have a ForwardIterator.  Iterator must
+have an `operator*() const`.
 
-Generates all the permutations of a range using `std::next_permutation`.  The
-iterators of the sequence passed must have an `operator*() const`
+Generates all the permutations of a range using `std::next_permutation`.
 
 Example usage:
 ```c++

From 39de8bff8d444caf626252d6718a42cd7f2af693 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 22 Aug 2015 23:57:07 -0700
Subject: [PATCH 1258/1866] optional default ctor in BasicIterable::Iterator

---
 test/helpers.hpp           |  3 +++
 test/test_combinations.cpp | 12 ++++++++++++
 2 files changed, 15 insertions(+)

diff --git a/test/helpers.hpp b/test/helpers.hpp
index 1b370f89..06d0e035 100644
--- a/test/helpers.hpp
+++ b/test/helpers.hpp
@@ -148,6 +148,9 @@ class BasicIterable {
             private:
                 T *p;
             public:
+#ifdef DEFINE_DEFAULT_ITERATOR_CTOR
+                Iterator() = default;
+#endif
                 Iterator(T *b) : p{b} { }
                 bool operator!=(const Iterator& other) const {
                     return this->p != other.p;
diff --git a/test/test_combinations.cpp b/test/test_combinations.cpp
index b01c2224..278c6225 100644
--- a/test/test_combinations.cpp
+++ b/test/test_combinations.cpp
@@ -1,4 +1,7 @@
+#define DEFINE_DEFAULT_ITERATOR_CTOR
 #include "helpers.hpp"
+#undef DEFINE_DEFAULT_ITERATOR_CTOR
+
 #include <combinations.hpp>
 
 #include <set>
@@ -57,6 +60,15 @@ TEST_CASE("combinations: size 0 gives nothing", "[combinations]") {
     REQUIRE( std::begin(c) == std::end(c) );
 }
 
+TEST_CASE("combinations: iterable without operator*() const", "[combinations]")
+{
+    BasicIterable<char> bi{'x', 'y', 'z'};
+    auto c = combinations(bi, 1);
+    auto it = std::begin(c);
+    ++it;
+    (*it)[0];
+}
+
 TEST_CASE("combinations: binds to lvalues, moves rvalues", "[combinations]") {
     BasicIterable<char> bi{'x', 'y', 'z'};
     SECTION("binds to lvalues") {

From fbb06cca540bffc860a6f9d8b0c7bc0b6ad0f4ff Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 23 Aug 2015 00:04:09 -0700
Subject: [PATCH 1259/1866] describes groupby requirements

---
 README.md | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/README.md b/README.md
index bbc54e7d..4d1b2611 100644
--- a/README.md
+++ b/README.md
@@ -341,6 +341,10 @@ for (auto&& i : count()) {
 
 groupby
 -------
+*Additional Requirements*: If the Input's iterator's `operator*()` returns
+a reference, the reference must remain valid after the iterator is incremented.
+Roughly equivalent to requiring the Input have a ForwardIterator.
+
 Separate an iterable into groups sharing a common key.  The following example
 creates a new group whenever a string of a different length is encountered.
 ```c++

From a3f7d9d7805ad21644ee0524343863b6110931c2 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 23 Aug 2015 00:06:49 -0700
Subject: [PATCH 1260/1866] notes unique_everseen requirements

---
 README.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/README.md b/README.md
index 4d1b2611..0169a83f 100644
--- a/README.md
+++ b/README.md
@@ -228,6 +228,8 @@ for(auto&& i : filterfalse(vec)) {
 ```
 unique\_everseen
 ---------------
+*Additional Requirements*: Underlying values must be copy-constructible.
+
 This is a filter adaptor that only generates values that have never been seen
 before. For this to work your object must be specialized for `std::hash`.
 

From 57d89a543ea069a410e6617821153f9cc956ada6 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 23 Aug 2015 18:35:31 -0700
Subject: [PATCH 1261/1866] iteriter doesn't need to include zip.hpp

---
 internal/iteratoriterator.hpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/internal/iteratoriterator.hpp b/internal/iteratoriterator.hpp
index 1a6b3f93..6052cc68 100644
--- a/internal/iteratoriterator.hpp
+++ b/internal/iteratoriterator.hpp
@@ -2,7 +2,6 @@
 #define ITERATOR_ITERATOR_HPP_
 
 #include "iterbase.hpp"
-#include "zip.hpp"
 #include <iterator>
 #include <type_traits>
 #include <utility>

From 025122607cd24096cab4ee416c5b2c42fb534207 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 23 Aug 2015 20:14:06 -0700
Subject: [PATCH 1262/1866] makes accumulate implementation class move-only

---
 accumulate.hpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/accumulate.hpp b/accumulate.hpp
index 8e94dee0..3d878c22 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -48,6 +48,8 @@ class iter::impl::Accumulator {
         accumulate_func(in_accumulate_func) {}
 
  public:
+  Accumulator(Accumulator&&) = default;
+
   class Iterator : public std::iterator<std::input_iterator_tag, AccumVal> {
    private:
     iterator_type<Container> sub_iter;
@@ -57,7 +59,7 @@ class iter::impl::Accumulator {
 
    public:
     Iterator(iterator_type<Container>&& iter, iterator_type<Container>&& end,
-        AccumulateFunc in_accumulate_func)
+        AccumulateFunc in_accumulate_fun)
         : sub_iter{std::move(iter)},
           sub_end{std::move(end)},
           accumulate_func(&in_accumulate_func),

From c38f839d4069f3297228b63d5a7588100ebca23e Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 23 Aug 2015 20:14:50 -0700
Subject: [PATCH 1263/1866] makes chain impl classes move-only

---
 chain.hpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/chain.hpp b/chain.hpp
index 5dbda67d..5ee3bcfa 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -46,6 +46,7 @@ class iter::impl::Chained {
         rest_chained{std::forward<RestContainers>(rest)...} {}
 
  public:
+  Chained(Chained&&) = default;
   class Iterator : public std::iterator<std::input_iterator_tag,
                        iterator_traits_deref<Container>> {
    private:
@@ -122,6 +123,7 @@ class iter::impl::Chained<Container> {
       : container(std::forward<Container>(in_container)) {}
 
  public:
+  Chained(Chained&&) = default;
   class Iterator : public std::iterator<std::input_iterator_tag,
                        iterator_traits_deref<Container>> {
    private:
@@ -179,6 +181,7 @@ class iter::impl::ChainedFromIterable {
       : container(std::forward<Container>(in_container)) {}
 
  public:
+  ChainedFromIterable(ChainedFromIterable&&) = default;
   class Iterator : public std::iterator<std::input_iterator_tag,
                        iterator_traits_deref<iterator_deref<Container>>> {
    private:

From c5731834d070ced7a8796653eb178cbce0a02995 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 23 Aug 2015 20:15:00 -0700
Subject: [PATCH 1264/1866] makes chunked impl class move-only

---
 chunked.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/chunked.hpp b/chunked.hpp
index 0a1fd5fe..3ce976f4 100644
--- a/chunked.hpp
+++ b/chunked.hpp
@@ -44,6 +44,7 @@ class iter::impl::Chunker {
   using DerefVec = IterIterWrapper<IndexVector>;
 
  public:
+  Chunker(Chunker&&) = default;
   class Iterator : public std::iterator<std::input_iterator_tag, DerefVec> {
    private:
     iterator_type<Container> sub_iter;

From 3666238659c7dec7a533075a8a43f7e73a4a8250 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 23 Aug 2015 20:15:11 -0700
Subject: [PATCH 1265/1866] makes combinations impl class move-only

---
 combinations.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/combinations.hpp b/combinations.hpp
index 3ba5ef60..098fc9d0 100644
--- a/combinations.hpp
+++ b/combinations.hpp
@@ -41,6 +41,7 @@ class iter::impl::Combinator {
   using CombIteratorDeref = IterIterWrapper<IndexVector>;
 
  public:
+  Combinator(Combinator&&) = default;
   class Iterator
       : public std::iterator<std::input_iterator_tag, CombIteratorDeref> {
    private:

From e5e1dcdbe7ae09060da26037a2f2bb271da37b92 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 23 Aug 2015 20:15:23 -0700
Subject: [PATCH 1266/1866] makes comb_w_repl impl class move-only

---
 combinations_with_replacement.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/combinations_with_replacement.hpp b/combinations_with_replacement.hpp
index c2f7f025..adc41665 100644
--- a/combinations_with_replacement.hpp
+++ b/combinations_with_replacement.hpp
@@ -44,6 +44,7 @@ class iter::impl::CombinatorWithReplacement {
   using CombIteratorDeref = IterIterWrapper<IndexVector>;
 
  public:
+  CombinatorWithReplacement(CombinatorWithReplacement&&) = default;
   class Iterator
       : public std::iterator<std::input_iterator_tag, CombIteratorDeref> {
    private:

From 7cc7d11c263bd0f24b750fc1a962b99d023bacc0 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 23 Aug 2015 20:15:37 -0700
Subject: [PATCH 1267/1866] makes compress impl class move-only

---
 compress.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/compress.hpp b/compress.hpp
index 7e19a4c5..dd92c203 100644
--- a/compress.hpp
+++ b/compress.hpp
@@ -58,6 +58,7 @@ class iter::impl::Compressed {
         selectors(std::forward<Selector>(in_selectors)) {}
 
  public:
+  Compressed(Compressed&&) = default;
   class Iterator : public std::iterator<std::input_iterator_tag,
                        iterator_traits_deref<Container>> {
    private:

From a040b2f3ed40ecc8584c3cddf515e98b05a2ad6f Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 23 Aug 2015 20:15:45 -0700
Subject: [PATCH 1268/1866] makes cycle impl class move-only

---
 cycle.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/cycle.hpp b/cycle.hpp
index 001cf719..ac4f5401 100644
--- a/cycle.hpp
+++ b/cycle.hpp
@@ -33,6 +33,7 @@ class iter::impl::Cycler {
       : container(std::forward<Container>(in_container)) {}
 
  public:
+  Cycler(Cycler&&) = default;
   class Iterator : public std::iterator<std::input_iterator_tag,
                        iterator_traits_deref<Container>> {
    private:

From 9f963b5f917e61bdd260319bf5a8d1be334a69d6 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 23 Aug 2015 20:15:53 -0700
Subject: [PATCH 1269/1866] makes dropwhile impl class move-only

---
 dropwhile.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/dropwhile.hpp b/dropwhile.hpp
index 76975dfc..f7f39e2a 100644
--- a/dropwhile.hpp
+++ b/dropwhile.hpp
@@ -39,6 +39,7 @@ class iter::impl::Dropper {
         filter_func(in_filter_func) {}
 
  public:
+  Dropper(Dropper&&) = default;
   class Iterator : public std::iterator<std::input_iterator_tag,
                        iterator_traits_deref<Container>> {
    private:

From 688620476fce798d2be65dd401a67ad972a6c1fe Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 23 Aug 2015 20:16:00 -0700
Subject: [PATCH 1270/1866] makes enumerate impl class move-only

---
 enumerate.hpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/enumerate.hpp b/enumerate.hpp
index ffb2a8eb..715eb7b0 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -44,6 +44,8 @@ class iter::impl::Enumerable {
       : container(std::forward<Container>(in_container)), start{in_start} {}
 
  public:
+  Enumerable(Enumerable&&) = default;
+
   // "yielded" by the Enumerable::Iterator.  Has a .index, and a
   // .element referencing the value yielded by the subiterator
   class IterYield : public BasePair {

From 8f9b4b6cbf7c519d0ca6fb9dd8c983a227c215a5 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 23 Aug 2015 20:16:13 -0700
Subject: [PATCH 1271/1866] makes filter impl class move-only

---
 filter.hpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/filter.hpp b/filter.hpp
index 381ad056..7b50fd38 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -40,6 +40,8 @@ class iter::impl::Filtered {
         filter_func(in_filter_func) {}
 
  public:
+  Filtered(Filtered&&) = default;
+
   class Iterator : public std::iterator<std::input_iterator_tag,
                        iterator_traits_deref<Container>> {
    protected:

From 87974e2b6c820630e4397f02b0ab5137e90d8b2e Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 23 Aug 2015 20:16:19 -0700
Subject: [PATCH 1272/1866] makes groupby impl class move-only

---
 groupby.hpp | 13 +------------
 1 file changed, 1 insertion(+), 12 deletions(-)

diff --git a/groupby.hpp b/groupby.hpp
index f02edca0..ca774609 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -44,11 +44,6 @@ class iter::impl::GroupProducer {
         key_func(in_key_func) {}
 
  public:
-  GroupProducer() = delete;
-  GroupProducer(const GroupProducer&) = delete;
-  GroupProducer& operator=(const GroupProducer&) = delete;
-  GroupProducer& operator=(GroupProducer&&) = delete;
-
   GroupProducer(GroupProducer&&) = default;
 
   class Iterator;
@@ -196,13 +191,7 @@ class iter::impl::GroupProducer {
       }
     }
 
-    // move-constructible, non-copy-constructible,
-    // non-assignable
-    Group() = delete;
-    Group(const Group&) = default;
-    Group& operator=(const Group&) = delete;
-    Group& operator=(Group&&) = delete;
-
+    // move-constructible, non-copy-constructible, non-assignable
     Group(Group&& other)
         : owner{other.owner}, key{other.key}, completed{other.completed} {
       other.completed = true;

From 0a0d9437d65a52badafea4dc44c4493433bb5665 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 23 Aug 2015 20:16:27 -0700
Subject: [PATCH 1273/1866] makes imap impl class move-only

---
 imap.hpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/imap.hpp b/imap.hpp
index d679a918..fc5a2e66 100644
--- a/imap.hpp
+++ b/imap.hpp
@@ -85,6 +85,8 @@ class iter::impl::IMapper {
         zipped(zip(std::forward<Containers>(in_containers)...)) {}
 
  public:
+  IMapper(IMapper&&) = default;
+
   class Iterator : public std::iterator<std::input_iterator_tag,
                        typename std::remove_reference<IMapIterDeref>::type> {
    private:

From 29495d9c5c98293515c6a58ffb054323ae2dd035 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 23 Aug 2015 20:16:38 -0700
Subject: [PATCH 1274/1866] makes permutations impl class move-only

---
 permutations.hpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/permutations.hpp b/permutations.hpp
index a847956a..81fdb34f 100644
--- a/permutations.hpp
+++ b/permutations.hpp
@@ -40,6 +40,8 @@ class iter::impl::Permuter {
       : container(std::forward<Container>(in_container)) {}
 
  public:
+  Permuter(Permuter&&) = default;
+
   class Iterator : public std::iterator<std::input_iterator_tag, Permutable> {
    private:
     static constexpr const int COMPLETE = -1;

From 09aef65967ba6b1c9a03809f70a05d2b4ebc659b Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 23 Aug 2015 20:16:52 -0700
Subject: [PATCH 1275/1866] makes powerset impl class move-only

---
 powerset.hpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/powerset.hpp b/powerset.hpp
index c1cd96dc..83e7ebe4 100644
--- a/powerset.hpp
+++ b/powerset.hpp
@@ -39,6 +39,8 @@ class iter::impl::Powersetter {
       : container(std::forward<Container>(in_container)) {}
 
  public:
+  Powersetter(Powersetter&&) = default;
+
   class Iterator
       : public std::iterator<std::input_iterator_tag, CombinatorType> {
    private:

From 4f9afa3f57c05919f50057b9045e98fe858b3e18 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 23 Aug 2015 20:17:02 -0700
Subject: [PATCH 1276/1866] makes product impl class move-only

---
 product.hpp | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/product.hpp b/product.hpp
index f83d5221..8939a28e 100644
--- a/product.hpp
+++ b/product.hpp
@@ -27,9 +27,6 @@ namespace iter {
 // specialization for at least 1 template argument
 template <typename Container, typename... RestContainers>
 class iter::impl::Productor<Container, RestContainers...> {
-  static_assert(!std::is_rvalue_reference<Container>::value,
-      "Itertools cannot be templated with rvalue references");
-
   friend Productor iter::product<Container, RestContainers...>(
       Container&&, RestContainers&&...);
 
@@ -47,6 +44,7 @@ class iter::impl::Productor<Container, RestContainers...> {
         rest_products{std::forward<RestContainers>(rest)...} {}
 
  public:
+  Productor(Productor&&) = default;
   class Iterator
       : public std::iterator<std::input_iterator_tag, ProdIterDeref> {
    private:
@@ -116,6 +114,7 @@ class iter::impl::Productor<Container, RestContainers...> {
 template <>
 class iter::impl::Productor<> {
  public:
+  Productor(Productor&&) = default;
   class Iterator : public std::iterator<std::input_iterator_tag, std::tuple<>> {
    public:
     constexpr static const bool is_base_iter = true;

From 6fe614ae966b0748ea7a2e99a703e7b25d6a0152 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 23 Aug 2015 20:17:14 -0700
Subject: [PATCH 1277/1866] makes reversed impl class move-only

---
 reversed.hpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/reversed.hpp b/reversed.hpp
index c52f1e4a..28a19157 100644
--- a/reversed.hpp
+++ b/reversed.hpp
@@ -32,6 +32,7 @@ class iter::impl::Reverser {
       : container(std::forward<Container>(in_container)) {}
 
  public:
+  Reverser(Reverser&&) = default;
   class Iterator : public std::iterator<std::input_iterator_tag,
                        iterator_traits_deref<Container>> {
    private:
@@ -95,7 +96,8 @@ class iter::impl::Reverser<T[N]> {
   Reverser(T* in_array) : array{in_array} {}
 
  public:
-  Reverser(const Reverser&) = default;
+  Reverser(Reverser&&) = default;
+
   class Iterator : public std::iterator<std::input_iterator_tag, T> {
    private:
     T* sub_iter;

From bcc27ca9345054c3b867f2498f63f345e53757aa Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 23 Aug 2015 20:17:23 -0700
Subject: [PATCH 1278/1866] makes slice impl class move-only

---
 slice.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/slice.hpp b/slice.hpp
index e960da85..09cdfb24 100644
--- a/slice.hpp
+++ b/slice.hpp
@@ -53,6 +53,7 @@ class iter::impl::Sliced {
         step{in_step} {}
 
  public:
+  Sliced(Sliced&&) = default;
   class Iterator : public std::iterator<std::input_iterator_tag,
                        iterator_traits_deref<Container>> {
    private:

From cc7293d72c511c86b5f7e8b3f84bbba6326cf22a Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 23 Aug 2015 20:17:35 -0700
Subject: [PATCH 1279/1866] makes sliding_window impl class move-only

---
 sliding_window.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/sliding_window.hpp b/sliding_window.hpp
index 9493afe0..cffc0e0f 100644
--- a/sliding_window.hpp
+++ b/sliding_window.hpp
@@ -41,6 +41,7 @@ class iter::impl::WindowSlider {
   using DerefVec = IterIterWrapper<IndexVector>;
 
  public:
+  WindowSlider(WindowSlider&&) = default;
   class Iterator : public std::iterator<std::input_iterator_tag, DerefVec> {
    private:
     iterator_type<Container> sub_iter;

From 5ac91a2262fd7dbb2fac685cbb29ef397d4427e6 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 23 Aug 2015 20:17:49 -0700
Subject: [PATCH 1280/1866] makes sorted impl class move-only

---
 sorted.hpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/sorted.hpp b/sorted.hpp
index 7eee9881..b546ce54 100644
--- a/sorted.hpp
+++ b/sorted.hpp
@@ -49,6 +49,8 @@ class iter::impl::SortedView {
   }
 
  public:
+  SortedView(SortedView&&) = default;
+
   ItIt begin() {
     return std::begin(sorted_iters);
   }

From 1316a38b888f7c5b8d3b874314ff43cf22e90991 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 23 Aug 2015 20:18:06 -0700
Subject: [PATCH 1281/1866] makes takewhile impl class move-only

---
 takewhile.hpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/takewhile.hpp b/takewhile.hpp
index 1449d154..6defbb17 100644
--- a/takewhile.hpp
+++ b/takewhile.hpp
@@ -38,6 +38,8 @@ class iter::impl::Taker {
         filter_func(in_filter_func) {}
 
  public:
+  Taker(Taker&&) = default;
+
   class Iterator : public std::iterator<std::input_iterator_tag,
                        iterator_traits_deref<Container>> {
    private:

From d13354df2de7e0d1e70d3c5b2766a778d337c1ae Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 23 Aug 2015 20:18:16 -0700
Subject: [PATCH 1282/1866] makes zip impl class move-only

---
 zip.hpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/zip.hpp b/zip.hpp
index 154cd2a7..ecd9a26d 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -43,6 +43,7 @@ class iter::impl::Zipped<Container, RestContainers...> {
         rest_zipped{std::forward<RestContainers>(rest)...} {}
 
  public:
+  Zipped(Zipped&&) = default;
   class Iterator : public std::iterator<std::input_iterator_tag, ZipIterDeref> {
    private:
     using RestIter = typename Zipped<RestContainers...>::Iterator;
@@ -99,6 +100,7 @@ class iter::impl::Zipped<Container, RestContainers...> {
 template <>
 class iter::impl::Zipped<> {
  public:
+  Zipped(Zipped&&) = default;
   class Iterator : public std::iterator<std::input_iterator_tag, std::tuple<>> {
    public:
     constexpr static const bool is_base_iter = true;

From 2b04905446f960c851d91573467c61b5ce89c8ec Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 23 Aug 2015 20:18:24 -0700
Subject: [PATCH 1283/1866] makes zip_longest impl class move-only

---
 zip_longest.hpp | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/zip_longest.hpp b/zip_longest.hpp
index a2321a46..dcd9ec59 100644
--- a/zip_longest.hpp
+++ b/zip_longest.hpp
@@ -26,9 +26,6 @@ namespace iter {
 
 template <typename Container, typename... RestContainers>
 class iter::impl::ZippedLongest<Container, RestContainers...> {
-  static_assert(!std::is_rvalue_reference<Container>::value,
-      "Itertools cannot be templated with rvalue references");
-
   friend ZippedLongest zip_longest<Container, RestContainers...>(
       Container&&, RestContainers&&...);
 
@@ -49,6 +46,7 @@ class iter::impl::ZippedLongest<Container, RestContainers...> {
         rest_zipped{std::forward<RestContainers>(rest)...} {}
 
  public:
+  ZippedLongest(ZippedLongest&&) = default;
   class Iterator : public std::iterator<std::input_iterator_tag, ZipIterDeref> {
    private:
     using RestIter = typename ZippedLongest<RestContainers...>::Iterator;
@@ -114,6 +112,7 @@ class iter::impl::ZippedLongest<Container, RestContainers...> {
 template <>
 class iter::impl::ZippedLongest<> {
  public:
+  ZippedLongest(ZippedLongest&&) = default;
   class Iterator : public std::iterator<std::input_iterator_tag, std::tuple<>> {
    public:
     Iterator& operator++() {

From e7748a1b6f7b4323e4f2eb527b6baab5637b4899 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 23 Aug 2015 20:18:49 -0700
Subject: [PATCH 1284/1866] makes repeat impl classes move-only

---
 repeat.hpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/repeat.hpp b/repeat.hpp
index bf65c2bd..6ef077bc 100644
--- a/repeat.hpp
+++ b/repeat.hpp
@@ -29,6 +29,8 @@ class iter::impl::RepeaterWithCount {
   using TPlain = typename std::remove_reference<T>::type;
 
  public:
+  RepeaterWithCount(RepeaterWithCount&&) = default;
+
   class Iterator : public std::iterator<std::input_iterator_tag, const TPlain> {
    private:
     const TPlain* elem;
@@ -100,6 +102,8 @@ class iter::impl::Repeater {
   constexpr Repeater(T e) : elem(std::forward<T>(e)) {}
 
  public:
+  Repeater(Repeater&&) = default;
+
   class Iterator : public std::iterator<std::input_iterator_tag, const TPlain> {
    private:
     const TPlain* elem;

From 51c368cbd97ef3eddeb6d59fe5bd9818a0a4fc2f Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 23 Aug 2015 20:20:50 -0700
Subject: [PATCH 1285/1866] fixes address-of-temporary error in accumulate

---
 accumulate.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/accumulate.hpp b/accumulate.hpp
index 3d878c22..eca67cb1 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -59,10 +59,10 @@ class iter::impl::Accumulator {
 
    public:
     Iterator(iterator_type<Container>&& iter, iterator_type<Container>&& end,
-        AccumulateFunc in_accumulate_fun)
+        AccumulateFunc& in_accumulate_fun)
         : sub_iter{std::move(iter)},
           sub_end{std::move(end)},
-          accumulate_func(&in_accumulate_func),
+          accumulate_func(&in_accumulate_fun),
           // only get first value if not an end iterator
           acc_val{!(iter != end) ? nullptr : new AccumVal(*iter)} {}
 

From f7776fea08c3be2ef9a655cbdd33db4da96cf79e Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 23 Aug 2015 20:22:27 -0700
Subject: [PATCH 1286/1866] adds missing noexcepts in friend decls

---
 range.hpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/range.hpp b/range.hpp
index 3c142da8..83543dc0 100644
--- a/range.hpp
+++ b/range.hpp
@@ -107,9 +107,9 @@ namespace iter {
 
 template <typename T>
 class iter::impl::Range {
-  friend Range iter::range<T>(T);
-  friend Range iter::range<T>(T, T);
-  friend Range iter::range<T>(T, T, T);
+  friend Range iter::range<T>(T) noexcept;
+  friend Range iter::range<T>(T, T) noexcept;
+  friend Range iter::range<T>(T, T, T) noexcept;
 
  private:
   const T start;

From d9dbebd0ebb34c82732d04a4bf5651df7a977989 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 23 Aug 2015 23:27:54 -0400
Subject: [PATCH 1287/1866] adds missing constexpr to friend decls

---
 range.hpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/range.hpp b/range.hpp
index 83543dc0..8a4047c4 100644
--- a/range.hpp
+++ b/range.hpp
@@ -107,9 +107,9 @@ namespace iter {
 
 template <typename T>
 class iter::impl::Range {
-  friend Range iter::range<T>(T) noexcept;
-  friend Range iter::range<T>(T, T) noexcept;
-  friend Range iter::range<T>(T, T, T) noexcept;
+  friend constexpr Range iter::range<T>(T) noexcept;
+  friend constexpr Range iter::range<T>(T, T) noexcept;
+  friend constexpr Range iter::range<T>(T, T, T) noexcept;
 
  private:
   const T start;

From 024cd0525bc34755f63abda428294cf21319e5e7 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 23 Aug 2015 20:29:47 -0700
Subject: [PATCH 1288/1866] removes constexpr from friend decls

---
 range.hpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/range.hpp b/range.hpp
index 8a4047c4..83543dc0 100644
--- a/range.hpp
+++ b/range.hpp
@@ -107,9 +107,9 @@ namespace iter {
 
 template <typename T>
 class iter::impl::Range {
-  friend constexpr Range iter::range<T>(T) noexcept;
-  friend constexpr Range iter::range<T>(T, T) noexcept;
-  friend constexpr Range iter::range<T>(T, T, T) noexcept;
+  friend Range iter::range<T>(T) noexcept;
+  friend Range iter::range<T>(T, T) noexcept;
+  friend Range iter::range<T>(T, T, T) noexcept;
 
  private:
   const T start;

From 4bf9faf15444348472dd6926cec2d8d2e52e4fef Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 24 Aug 2015 02:37:04 -0400
Subject: [PATCH 1289/1866] tests that iteratoriterator has correct traits

---
 test/test_iteratoriterator.cpp | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/test/test_iteratoriterator.cpp b/test/test_iteratoriterator.cpp
index 6903d8cf..129ebd15 100644
--- a/test/test_iteratoriterator.cpp
+++ b/test/test_iteratoriterator.cpp
@@ -52,3 +52,12 @@ TEST_CASE("IteratorIterator operator->", "[iteratoriterator]") {
     auto it = std::begin(itritr);
     REQUIRE( it->size() == 8 );
 }
+
+TEST_CASE("Iterate over a vector of string iterators", "[iteratoriterator]") {
+  std::string str = "hello world";
+  IterIterWrapper<std::vector<std::string::iterator>> itritr;
+  auto it = std::begin(itritr);
+  static_assert(std::is_same<decltype(*it),
+      std::iterator_traits<decltype(it)>::reference>::value,
+      "iterator is mis marked");
+}

From f2ffc55db485504efc0544bd1c612aa19e2040fd Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 24 Aug 2015 02:38:24 -0400
Subject: [PATCH 1290/1866] corrects iteratoriterator traits

previously all the iterator_traits were defined as per the outer
iterator instead of the inner one. This surfaced when compiling with
libc++ (as opposed to libstdc++) which doesn't tighter checks
---
 internal/iteratoriterator.hpp | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

diff --git a/internal/iteratoriterator.hpp b/internal/iteratoriterator.hpp
index 6052cc68..75e79a69 100644
--- a/internal/iteratoriterator.hpp
+++ b/internal/iteratoriterator.hpp
@@ -22,24 +22,23 @@ namespace iter {
     struct HasConstDeref<T, void_t<decltype(*std::declval<const T&>())>>
         : std::true_type {};
 
-    template <typename Iter,
-        typename Diff = typename std::iterator_traits<Iter>::difference_type>
+    template <typename TopIter>
     class IteratorIterator
         : public std::iterator<std::random_access_iterator_tag,
-              typename std::iterator_traits<Iter>::value_type, Diff,
-              typename std::iterator_traits<Iter>::pointer,
-              typename std::iterator_traits<Iter>::reference> {
+                               typename std::decay<decltype(
+                                   **std::declval<TopIter>())>::type> {
+      using Diff = std::ptrdiff_t;
       static_assert(
-          std::is_same<typename std::iterator_traits<Iter>::iterator_category,
+          std::is_same<typename std::iterator_traits<TopIter>::iterator_category,
               std::random_access_iterator_tag>::value,
           "IteratorIterator only works with random access iterators");
 
      private:
-      Iter sub_iter;
+      TopIter sub_iter;
 
      public:
       IteratorIterator() = default;
-      IteratorIterator(const Iter& it) : sub_iter{it} {}
+      IteratorIterator(const TopIter& it) : sub_iter{it} {}
 
       bool operator==(const IteratorIterator& other) const {
         return !(*this != other);

From dd9711786b4f7f82bddda38e4638d78acad2879f Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 24 Aug 2015 02:40:15 -0400
Subject: [PATCH 1291/1866] adds missing explicit type in empty multiset

---
 test/test_powerset.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/test/test_powerset.cpp b/test/test_powerset.cpp
index 7da82744..3c13e09f 100644
--- a/test/test_powerset.cpp
+++ b/test/test_powerset.cpp
@@ -18,7 +18,8 @@ TEST_CASE("powerset: basic test, [1, 2, 3]", "[powerset]") {
         v.emplace(std::begin(st), std::end(st));
     }
 
-    const IntPermSet vc = { {}, {1}, {2}, {3,}, {1,2}, {1,3}, {2,3}, {1,2,3} };
+    const IntPermSet vc = { std::multiset<int>{},
+      {1}, {2}, {3,}, {1,2}, {1,3}, {2,3}, {1,2,3} };
     REQUIRE( v == vc );
 }
 

From e78c34412660c79f7c552a3b2d73bb2ab8c63852 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 24 Aug 2015 02:40:40 -0400
Subject: [PATCH 1292/1866] replaces std::array of SolidInt with plain c array

---
 test/test_slice.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/test_slice.cpp b/test/test_slice.cpp
index ea6f5e13..921fab44 100644
--- a/test/test_slice.cpp
+++ b/test/test_slice.cpp
@@ -96,7 +96,7 @@ TEST_CASE("slice: moves rvalues and binds to lvalues", "[slice]") {
 
 
 TEST_CASE("slice: with iterable doesn't move or copy elems", "[slice]") {
-    constexpr std::array<itertest::SolidInt, 3> arr{{{6}, {7}, {8}}};
+    constexpr itertest::SolidInt arr[] = {{6}, {7}, {8}};
     for (auto&& i : slice(arr, 2)) {
         (void)i;
     }

From b8cdccd83e73fd36b0aa52977e513b93b0e72a1b Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 24 Aug 2015 02:42:34 -0400
Subject: [PATCH 1293/1866] marks repeat begin/end as const

---
 repeat.hpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/repeat.hpp b/repeat.hpp
index 6ef077bc..45a6c8e9 100644
--- a/repeat.hpp
+++ b/repeat.hpp
@@ -67,11 +67,11 @@ class iter::impl::RepeaterWithCount {
     }
   };
 
-  constexpr Iterator begin() {
+  constexpr Iterator begin() const {
     return {&this->elem, this->count};
   }
 
-  constexpr Iterator end() {
+  constexpr Iterator end() const {
     return {&this->elem, 0};
   }
 };
@@ -136,11 +136,11 @@ class iter::impl::Repeater {
     }
   };
 
-  constexpr Iterator begin() {
+  constexpr Iterator begin() const {
     return {&this->elem};
   }
 
-  constexpr Iterator end() {
+  constexpr Iterator end() const {
     return {nullptr};
   }
 };

From a14ae7ac986ecafdb370b4bbeb64e6c30b0556c5 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 24 Aug 2015 02:59:29 -0400
Subject: [PATCH 1294/1866] declares all repeat<> friends of all Repeater<>

There's a gcc bug that causes it to *very explicitly* not allow
declaring a constexpr friend specialization which is fixed in trunk as
of right now, and will probably get released with gcc-5.1.1
http://stackoverflow.com/questions/32174186/
---
 repeat.hpp | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/repeat.hpp b/repeat.hpp
index 45a6c8e9..c33d40c5 100644
--- a/repeat.hpp
+++ b/repeat.hpp
@@ -17,7 +17,10 @@ namespace iter {
 
 template <typename T>
 class iter::impl::RepeaterWithCount {
-  friend RepeaterWithCount iter::repeat<T>(T&&, int);
+  // see stackoverflow.com/questions/32174186/ about why this isn't
+  // declaring just a specialization as friend
+  template <typename U>
+  friend constexpr RepeaterWithCount<U> iter::repeat(U&&, int);
 
  private:
   T elem;
@@ -93,7 +96,8 @@ namespace iter {
 
 template <typename T>
 class iter::impl::Repeater {
-  friend Repeater iter::repeat<T>(T&&);
+  template <typename U>
+  friend constexpr Repeater<U> iter::repeat(U&&);
 
  private:
   using TPlain = typename std::remove_reference<T>::type;

From d936c2f246e8478026b3c759abfe7f4f95ba081e Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 24 Aug 2015 03:12:33 -0400
Subject: [PATCH 1295/1866] makes range<> friends with all Range<>s

---
 range.hpp | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/range.hpp b/range.hpp
index 83543dc0..74d6bc5d 100644
--- a/range.hpp
+++ b/range.hpp
@@ -107,9 +107,14 @@ namespace iter {
 
 template <typename T>
 class iter::impl::Range {
-  friend Range iter::range<T>(T) noexcept;
-  friend Range iter::range<T>(T, T) noexcept;
-  friend Range iter::range<T>(T, T, T) noexcept;
+  // see stackoverflow.com/questions/32174186 about why only specializations
+  // aren't marked as friend
+  template <typename U>
+  friend constexpr Range<U> iter::range(U) noexcept;
+  template <typename U>
+  friend constexpr Range<U> iter::range(U, U) noexcept;
+  template <typename U>
+  friend constexpr Range<U> iter::range(U, U, U) noexcept;
 
  private:
   const T start;

From d3bd2b675a4bd98b93e8516f86ccd778f256f109 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 24 Aug 2015 13:18:08 -0400
Subject: [PATCH 1296/1866] remove_ref rather than decay to get value_type

---
 internal/iteratoriterator.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/internal/iteratoriterator.hpp b/internal/iteratoriterator.hpp
index 75e79a69..a49b4b06 100644
--- a/internal/iteratoriterator.hpp
+++ b/internal/iteratoriterator.hpp
@@ -25,7 +25,7 @@ namespace iter {
     template <typename TopIter>
     class IteratorIterator
         : public std::iterator<std::random_access_iterator_tag,
-                               typename std::decay<decltype(
+                               typename std::remove_reference<decltype(
                                    **std::declval<TopIter>())>::type> {
       using Diff = std::ptrdiff_t;
       static_assert(

From 67abb0315fe75c6e7e1519b24985a1462f1bf420 Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Mon, 24 Aug 2015 13:05:26 -0700
Subject: [PATCH 1297/1866] adds missing && in groupby examples

---
 examples/groupby_examples.cpp | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/examples/groupby_examples.cpp b/examples/groupby_examples.cpp
index e4ae4048..7ee1ab74 100644
--- a/examples/groupby_examples.cpp
+++ b/examples/groupby_examples.cpp
@@ -35,17 +35,15 @@ int main() {
         }
         std::cout << '\n';
     }
-   
+
 
     std::cout << "ints grouped by their value:\n";
     std::vector<int> ivec = {5, 5, 6, 6, 19, 19, 19, 19, 69, 0, 10, 10};
-    for (auto gb : iter::groupby(ivec)) {
+    for (auto&& gb : iter::groupby(ivec)) {
         std::cout << "key(" << gb.first << "): ";
-        for (auto s : gb.second) {
+        for (auto&& s : gb.second) {
             std::cout << s << "  ";
         }
         std::cout << '\n';
     }
 }
-
-    

From cdedf05fbd87d497a780e65a79c89c2f61536f39 Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Mon, 24 Aug 2015 18:58:54 -0700
Subject: [PATCH 1298/1866] adds repeat constexpr test with literal

---
 test/test_repeat.cpp | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/test/test_repeat.cpp b/test/test_repeat.cpp
index 3cb9e45f..b6e71a45 100644
--- a/test/test_repeat.cpp
+++ b/test/test_repeat.cpp
@@ -34,6 +34,13 @@ TEST_CASE("repeat: can be used as constexpr", "[repeat]") {
         constexpr auto i2 = ++i; (void)i2;
     }
 
+    {
+      constexpr static auto r = repeat('a');
+      constexpr auto i = r.begin();
+      //constexpr char c2 = *i;
+      //static_assert(c2 == 'a', "repeat value not as expected");
+    }
+
     {
         constexpr auto r = repeat(c, 2);
         constexpr auto i = r.begin();

From 7a3066e31e14e37143cbde04436ac7c72c6a9412 Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Mon, 24 Aug 2015 18:59:45 -0700
Subject: [PATCH 1299/1866] uses custom forward to get c++14 functionality

because c++11's std::forward isn't marked as constexpr. facepalm
---
 repeat.hpp | 19 +++++++++++++++----
 1 file changed, 15 insertions(+), 4 deletions(-)

diff --git a/repeat.hpp b/repeat.hpp
index c33d40c5..ecef3e49 100644
--- a/repeat.hpp
+++ b/repeat.hpp
@@ -9,6 +9,17 @@ namespace iter {
   namespace impl {
     template <typename T>
     class RepeaterWithCount;
+
+    // forward isn't constexpr until c++14
+    template <typename T>
+    constexpr T&& forward( typename std::remove_reference<T>::type& t ) {
+      return static_cast<T&&>(t);
+    }
+
+    template <typename T>
+    constexpr T&& forward( typename std::remove_reference<T>::type&& t ) {
+      return static_cast<T&&>(t);
+    }
   }
 
   template <typename T>
@@ -27,7 +38,7 @@ class iter::impl::RepeaterWithCount {
   int count;
 
   constexpr RepeaterWithCount(T e, int c)
-      : elem(std::forward<T>(e)), count{c} {}
+      : elem(impl::forward<T>(e)), count{c} {}
 
   using TPlain = typename std::remove_reference<T>::type;
 
@@ -81,7 +92,7 @@ class iter::impl::RepeaterWithCount {
 
 template <typename T>
 constexpr iter::impl::RepeaterWithCount<T> iter::repeat(T&& e, int count) {
-  return {std::forward<T>(e), count < 0 ? 0 : count};
+  return {impl::forward<T>(e), count < 0 ? 0 : count};
 }
 
 namespace iter {
@@ -103,7 +114,7 @@ class iter::impl::Repeater {
   using TPlain = typename std::remove_reference<T>::type;
   T elem;
 
-  constexpr Repeater(T e) : elem(std::forward<T>(e)) {}
+  constexpr Repeater(T e) : elem(impl::forward<T>(e)) {}
 
  public:
   Repeater(Repeater&&) = default;
@@ -151,7 +162,7 @@ class iter::impl::Repeater {
 
 template <typename T>
 constexpr iter::impl::Repeater<T> iter::repeat(T&& e) {
-  return {std::forward<T>(e)};
+  return {impl::forward<T>(e)};
 }
 
 #endif

From db3011e9f61d20e0a0070a43f12cf523b6ff6e80 Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Mon, 24 Aug 2015 19:31:37 -0700
Subject: [PATCH 1300/1866] adjusts for weird libc++ mem_fn behavior

I'm hesitant to call it a bug, but I think it is. libc++'s std::mem_fn
doesn't seem to work when the member function is marked const. I can't
get it to work with &std::string::size, for example.
---
 examples/groupby_examples.cpp | 8 +-------
 test/test_groupby.cpp         | 4 ++--
 2 files changed, 3 insertions(+), 9 deletions(-)

diff --git a/examples/groupby_examples.cpp b/examples/groupby_examples.cpp
index fb55a5cd..8d4a9918 100644
--- a/examples/groupby_examples.cpp
+++ b/examples/groupby_examples.cpp
@@ -5,14 +5,8 @@
 #include <string>
 #include <functional>
 
-// fix OSX compilation
-static int string_length(const std::string & str)
-{
-    return str.length();
-}
-
 int main() {
-    auto len = string_length;
+    auto len = [](const std::string& str){ return str.size(); };
     std::vector<std::string> vec = {
         "hi", "ab", "ho",
         "abc", "def",
diff --git a/test/test_groupby.cpp b/test/test_groupby.cpp
index eddb2728..ad74be9d 100644
--- a/test/test_groupby.cpp
+++ b/test/test_groupby.cpp
@@ -47,7 +47,7 @@ TEST_CASE("groupby: works with lambda, callable, and function pointer") {
     }
 
     SECTION("lambda function") {
-        for (auto&& gb : groupby(vec, 
+        for (auto&& gb : groupby(vec,
                     [](const std::string& s){return s.size();})) {
             keys.push_back(gb.first);
             groups.emplace_back(std::begin(gb.second), std::end(gb.second));
@@ -201,7 +201,7 @@ TEST_CASE("groupby: copy constructed iterators behave as expected",
 
 TEST_CASE("groupby: operator-> on both iterator types", "[groupby]") {
     std::vector<std::string> ns = {"a", "abc"};
-    auto g = groupby(ns, std::mem_fn(&std::string::size));
+    auto g = groupby(ns, [](const std::string& str){return str.size();});
     auto it = std::begin(g);
     REQUIRE( it->first == 1 );
     auto it2 = std::begin(it->second);

From 4bc46f7d8c6e6c79931f2f81a284cd9d092f3714 Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Mon, 24 Aug 2015 19:42:48 -0700
Subject: [PATCH 1301/1866] formatting

---
 repeat.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/repeat.hpp b/repeat.hpp
index ecef3e49..b9fcd885 100644
--- a/repeat.hpp
+++ b/repeat.hpp
@@ -12,12 +12,12 @@ namespace iter {
 
     // forward isn't constexpr until c++14
     template <typename T>
-    constexpr T&& forward( typename std::remove_reference<T>::type& t ) {
+    constexpr T&& forward(typename std::remove_reference<T>::type& t) {
       return static_cast<T&&>(t);
     }
 
     template <typename T>
-    constexpr T&& forward( typename std::remove_reference<T>::type&& t ) {
+    constexpr T&& forward(typename std::remove_reference<T>::type&& t) {
       return static_cast<T&&>(t);
     }
   }

From 7bc27058aa5c67d87af6ccc4733245dd48b2fb0d Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 24 Aug 2015 23:30:22 -0700
Subject: [PATCH 1302/1866] uncomments end of a repeat test

---
 test/test_repeat.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/test_repeat.cpp b/test/test_repeat.cpp
index b6e71a45..ee7c03e4 100644
--- a/test/test_repeat.cpp
+++ b/test/test_repeat.cpp
@@ -37,8 +37,8 @@ TEST_CASE("repeat: can be used as constexpr", "[repeat]") {
     {
       constexpr static auto r = repeat('a');
       constexpr auto i = r.begin();
-      //constexpr char c2 = *i;
-      //static_assert(c2 == 'a', "repeat value not as expected");
+      constexpr char c2 = *i;
+      static_assert(c2 == 'a', "repeat value not as expected");
     }
 
     {

From 56d96e6b5da6780ee0c7592fb7bb57fc0c087b49 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 24 Aug 2015 23:37:35 -0700
Subject: [PATCH 1303/1866] Notes implementation class limitations

---
 README.md | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/README.md b/README.md
index 0169a83f..b293c690 100644
--- a/README.md
+++ b/README.md
@@ -59,6 +59,12 @@ This library takes every effort to rely on as little as possible from the
 underlying iterables, but if anything noteworthy is needed it is described
 in this document.
 
+#### Guarantees of implementations
+By implementations I mean the objects returned by the API's functions. All of
+the implementation classes are move-constructible, not copy-constructible,
+not assignable. All iterators that work over another iterable are tagged
+as InputIterators and behave as such.
+
 #### Feedback
 If you find anything not working as you expect, not compiling when you believe
 it should, a divergence from the python itertools behavior, or any sort of

From 7886ba4e0fccdcb3f118adef8bdcde95a11c6795 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 27 Aug 2015 08:32:41 -0700
Subject: [PATCH 1304/1866] changes Group move ctor to work with gcc-4.8

If this were a big change I wouldn't do it, but all it needs is changing
a{b} to a(b) in one spot, so why not.
---
 groupby.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/groupby.hpp b/groupby.hpp
index ca774609..d794d70d 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -193,7 +193,7 @@ class iter::impl::GroupProducer {
 
     // move-constructible, non-copy-constructible, non-assignable
     Group(Group&& other)
-        : owner{other.owner}, key{other.key}, completed{other.completed} {
+        : owner(other.owner), key{other.key}, completed{other.completed} {
       other.completed = true;
     }
 

From 7db884170dd8d88b431bc1209ae85fe936334029 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 27 Aug 2015 08:43:13 -0700
Subject: [PATCH 1305/1866] Removes new-gcc specific flag from SConstructs

and informs that catch.hpp might be there, but CXX might be wrong
---
 examples/SConstruct | 3 +--
 test/SConstruct     | 5 +++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/examples/SConstruct b/examples/SConstruct
index 9e345c01..8040c840 100644
--- a/examples/SConstruct
+++ b/examples/SConstruct
@@ -1,11 +1,10 @@
 import os
 
 env = Environment(
-    ENV = {'PATH' : os.environ['PATH']},
+    ENV=os.environ,
     CXX='c++',
     CXXFLAGS= ['-g', '-Wall', '-Wextra',
                '-pedantic', '-std=c++11',
-                '-fdiagnostics-color=always',
                '-I/usr/local/include'],
     CPPPATH='..',
     LINKFLAGS='-L/usr/local/lib')
diff --git a/test/SConstruct b/test/SConstruct
index a37669b5..b35f286c 100644
--- a/test/SConstruct
+++ b/test/SConstruct
@@ -2,10 +2,9 @@ import os
 
 env = Environment(
     ENV = os.environ,
-    CXX='c++',
+    CXX='c++'
     CXXFLAGS= ['-g', '-Wall', '-Wextra',
                '-pedantic', '-std=c++11',
-                '-fdiagnostics-color=always',
                '-I/usr/local/include', '-I.'],
     CPPPATH='..',
     LINKFLAGS='-L/usr/local/lib')
@@ -54,6 +53,8 @@ conf = Configure(env)
 # if catch isn't available, exit
 if not conf.CheckCXXHeader('catch.hpp'):
     print("WARNING: catch.hpp not found, run ./download_catch.sh first")
+    print("note: you may receive this warning if the c++ compiler specified "
+          "by CXX  at the top of the SConstruct file is invalid.")
     Exit(1)
 
 if conf.CheckCXXHeader('boost/optional.hpp'):

From dcb4a7f264438b9a574ba2a2fbe7ffaa6aa06584 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 27 Aug 2015 22:27:17 -0700
Subject: [PATCH 1306/1866] adds back missing comma

---
 test/SConstruct | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/SConstruct b/test/SConstruct
index b35f286c..129c2dbf 100644
--- a/test/SConstruct
+++ b/test/SConstruct
@@ -2,7 +2,7 @@ import os
 
 env = Environment(
     ENV = os.environ,
-    CXX='c++'
+    CXX='c++',
     CXXFLAGS= ['-g', '-Wall', '-Wextra',
                '-pedantic', '-std=c++11',
                '-I/usr/local/include', '-I.'],

From 93177acc9bd7b32b779601106eb394534d09b0c5 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 27 Aug 2015 22:42:37 -0700
Subject: [PATCH 1307/1866] tests chain.from_iterable arrow

---
 test/test_chain.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/test/test_chain.cpp b/test/test_chain.cpp
index 46319d33..b4cf0836 100644
--- a/test/test_chain.cpp
+++ b/test/test_chain.cpp
@@ -186,6 +186,12 @@ TEST_CASE("chain.from_iterable: postfix ++", "[chain.from_iterable]") {
     REQUIRE( *it == 'n' );
 }
 
+TEST_CASE("chain.from_iterable: operator->","[chain.from_iterable]") {
+    std::vector<std::vector<std::string>> sv{{"a", "ab"}, {"abc"}};
+    auto ch = chain.from_iterable(sv);
+    auto it = std::begin(ch);
+    REQUIRE( it->size() == 1 );
+}
 
 TEST_CASE("chain.from_iterable: moves rvalues and binds ref to lvalues",
         "[chain.from_iterable]") {

From 4eb45a6f8c36ee6b082ac9aa02fd9b476c7b042f Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 27 Aug 2015 22:42:48 -0700
Subject: [PATCH 1308/1866] implements chain.from_iterable arrow

---
 chain.hpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/chain.hpp b/chain.hpp
index 2556fecc..3fb097a5 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -255,6 +255,10 @@ class iter::impl::ChainedFromIterable {
     iterator_deref<iterator_deref<Container>> operator*() {
       return **this->sub_iter_p;
     }
+
+    iterator_arrow<iterator_deref<Container>> operator->() {
+      return apply_arrow(*this->sub_iter_p);
+    }
   };
 
   Iterator begin() {

From afbe4ffccc2bb08c31f1597e0c70984e320f04c6 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 27 Aug 2015 22:48:30 -0700
Subject: [PATCH 1309/1866] puts back in chain operator->

---
 chain.hpp | 19 ++++++++++++++++++-
 1 file changed, 18 insertions(+), 1 deletion(-)

diff --git a/chain.hpp b/chain.hpp
index 3fb097a5..b50e520f 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -41,12 +41,18 @@ class iter::impl::Chained {
 
   using IterTupType = iterator_tuple_type<TupType>;
   using DerefType = iterator_deref<std::tuple_element_t<0, TupType>>;
+  using ArrowType = iterator_arrow<std::tuple_element_t<0, TupType>>;
 
   template <std::size_t Idx>
   static DerefType get_and_deref(IterTupType& iters) {
     return *std::get<Idx>(iters);
   }
 
+  template <std::size_t Idx>
+  static ArrowType get_and_arrow(IterTupType& iters) {
+    return apply_arrow(std::get<Idx>(iters));
+  }
+
   template <std::size_t Idx>
   static void get_and_increment(IterTupType& iters) {
     ++std::get<Idx>(iters);
@@ -59,12 +65,16 @@ class iter::impl::Chained {
   }
 
   using DerefFunc = DerefType (*)(IterTupType&);
+  using ArrowFunc = ArrowType (*)(IterTupType&);
   using IncFunc = void (*)(IterTupType&);
   using NeqFunc = bool (*)(const IterTupType&, const IterTupType&);
 
   constexpr static std::array<DerefFunc, sizeof...(Is)> derefers{
       {get_and_deref<Is>...}};
 
+  constexpr static std::array<ArrowFunc, sizeof...(Is)> arrowers{
+      {get_and_arrow<Is>...}};
+
   constexpr static std::array<IncFunc, sizeof...(Is)> incrementers{
       {get_and_increment<Is>...}};
 
@@ -77,7 +87,6 @@ class iter::impl::Chained {
   TupType tup;
 
  public:
-  Chained(Chained&&) = default;
   Chained(TupType&& t) : tup(std::move(t)) {}
 
   class Iterator : public std::iterator<std::input_iterator_tag, TraitsValue> {
@@ -103,6 +112,10 @@ class iter::impl::Chained {
       return derefers[this->index](this->iters);
     }
 
+    decltype(auto) operator -> () {
+      return arrowers[this->index](this->iters);
+    }
+
     Iterator& operator++() {
       incrementers[this->index](this->iters);
       this->check_for_end_and_adjust();
@@ -141,6 +154,10 @@ template <typename TupType, std::size_t... Is>
 constexpr std::array<typename iter::impl::Chained<TupType, Is...>::DerefFunc,
     sizeof...(Is)> iter::impl::Chained<TupType, Is...>::derefers;
 
+template <typename TupType, std::size_t... Is>
+constexpr std::array<typename iter::impl::Chained<TupType, Is...>::ArrowFunc,
+    sizeof...(Is)> iter::impl::Chained<TupType, Is...>::arrowers;
+
 template <typename TupType, std::size_t... Is>
 constexpr std::array<typename iter::impl::Chained<TupType, Is...>::IncFunc,
     sizeof...(Is)> iter::impl::Chained<TupType, Is...>::incrementers;

From 3fc699523184273335b94801330bf21c7fbe91fd Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 27 Aug 2015 22:50:15 -0700
Subject: [PATCH 1310/1866] adds back zip and zip_longest iter->

---
 zip.hpp         |   5 ++
 zip_longest.hpp | 201 ++++++++++++++++++++++++------------------------
 2 files changed, 104 insertions(+), 102 deletions(-)

diff --git a/zip.hpp b/zip.hpp
index 1771ed32..569ea6ee 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -33,6 +33,7 @@ class iter::impl::Zipped {
   Zipped(TupleType&& in_containers) : containers(std::move(in_containers)) {}
 
  public:
+  Zipped(Zipped&&) = default;
   class Iterator : public std::iterator<std::input_iterator_tag, ZipIterDeref> {
    private:
     iterator_tuple_type<TupleType> iters;
@@ -67,6 +68,10 @@ class iter::impl::Zipped {
     ZipIterDeref operator*() {
       return ZipIterDeref{(*std::get<Is>(this->iters))...};
     }
+
+    auto operator -> () -> ArrowProxy<decltype(**this)> {
+      return {**this};
+    }
   };
 
   Iterator begin() {
diff --git a/zip_longest.hpp b/zip_longest.hpp
index 98b20ec4..800261b7 100644
--- a/zip_longest.hpp
+++ b/zip_longest.hpp
@@ -1,124 +1,121 @@
 #ifndef ITER_ZIP_LONGEST_HPP_
 #define ITER_ZIP_LONGEST_HPP_
 
-#include "iterbase.hpp"
+#include "internal/iterbase.hpp"
 
 #include <boost/optional.hpp>
 #include <iterator>
 #include <tuple>
 #include <utility>
 
-
 namespace iter {
-
+  namespace impl {
     template <typename TupleType, std::size_t... Is>
     class ZippedLongest;
 
     template <typename TupleType, std::size_t... Is>
-    ZippedLongest<TupleType, Is...>
-        zip_longest_impl(TupleType&&, std::index_sequence<Is...>);
+    ZippedLongest<TupleType, Is...> zip_longest_impl(
+        TupleType&&, std::index_sequence<Is...>);
+  }
 
-    template <typename TupleType, std::size_t... Is>
-    class ZippedLongest {
-        private:
-            TupleType containers;
-            friend ZippedLongest zip_longest_impl<TupleType, Is...>(
-                    TupleType&&, std::index_sequence<Is...>);
-
-            template <std::size_t I>
-            using OptType = boost::optional<iterator_deref<
-                std::tuple_element_t<I, TupleType>>>;
-
-            using ZipIterDeref = std::tuple<OptType<Is>...>;
-
-            ZippedLongest(TupleType&& in_containers)
-                : containers(std::move(in_containers))
-            { }
-        public:
-            class Iterator
-                : public std::iterator<std::input_iterator_tag, ZipIterDeref>
-            {
-                private:
-                    iterator_tuple_type<TupleType> iters;
-                    iterator_tuple_type<TupleType> ends;
-
-                public:
-                    Iterator(iterator_tuple_type<TupleType>&& in_iters,
-                            iterator_tuple_type<TupleType>&& in_ends)
-                        : iters(std::move(in_iters)),
-                        ends(std::move(in_ends))
-                    { }
-
-                    Iterator& operator++() {
-                        // increment every iterator that's not already at
-                        // the end
-                        absorb(
-                            ((std::get<Is>(this->iters) !=
-                              std::get<Is>(this->ends)) ?
-                                (++std::get<Is>(this->iters), 0) : 0)...);
-                        return *this;
-                    }
-
-                    Iterator operator++(int) {
-                        auto ret = *this;
-                        ++*this;
-                        return ret;
-                    }
-
-                    bool operator!=(const Iterator& other) const {
-                        if (sizeof...(Is) == 0) return false;
-
-                        bool results[] = { false,
-                            (std::get<Is>(this->iters) !=
-                                 std::get<Is>(other.iters))...
-                        };
-                        return std::any_of(
-                                std::begin(results), std::end(results),
-                                [](bool b){ return b; } );
-                    }
-
-                    bool operator==(const Iterator& other) const {
-                        return !(*this != other);
-                    }
-
-                    ZipIterDeref operator*() {
-                        return ZipIterDeref{ 
-                            ((std::get<Is>(this->iters) !=
-                              std::get<Is>(this->ends))
-                             ? OptType<Is>{*std::get<Is>(this->iters)}
-                                : OptType<Is>{})...};
-                    }
-            };
-
-            Iterator begin() {
-                return {
-                    iterator_tuple_type<TupleType>{
-                        std::begin(std::get<Is>(this->containers))...},
-                    iterator_tuple_type<TupleType>{
-                        std::end(std::get<Is>(this->containers))...}};
-            }
-
-            Iterator end() {
-                return {
-                    iterator_tuple_type<TupleType>{
-                        std::end(std::get<Is>(this->containers))...},
-                    iterator_tuple_type<TupleType>{
-                        std::end(std::get<Is>(this->containers))...}};
-            }
-};
+  template <typename... Containers>
+  auto zip_longest(Containers&&... containers);
+}
 
-    template <typename TupleType, std::size_t... Is>
-    ZippedLongest<TupleType, Is...> zip_longest_impl(
-            TupleType&& in_containers, std::index_sequence<Is...>) {
-        return {std::move(in_containers)};
+template <typename TupleType, std::size_t... Is>
+class iter::impl::ZippedLongest {
+ private:
+  TupleType containers;
+  friend ZippedLongest zip_longest_impl<TupleType, Is...>(
+      TupleType&&, std::index_sequence<Is...>);
+
+  template <std::size_t I>
+  using OptType =
+      boost::optional<iterator_deref<std::tuple_element_t<I, TupleType>>>;
+
+  using ZipIterDeref = std::tuple<OptType<Is>...>;
+
+  ZippedLongest(TupleType&& in_containers)
+      : containers(std::move(in_containers)) {}
+
+ public:
+  ZippedLongest(ZippedLongest&&) = default;
+  class Iterator : public std::iterator<std::input_iterator_tag, ZipIterDeref> {
+   private:
+    iterator_tuple_type<TupleType> iters;
+    iterator_tuple_type<TupleType> ends;
+
+   public:
+    Iterator(iterator_tuple_type<TupleType>&& in_iters,
+        iterator_tuple_type<TupleType>&& in_ends)
+        : iters(std::move(in_iters)), ends(std::move(in_ends)) {}
+
+    Iterator& operator++() {
+      // increment every iterator that's not already at
+      // the end
+      absorb(((std::get<Is>(this->iters) != std::get<Is>(this->ends))
+                  ? (++std::get<Is>(this->iters), 0)
+                  : 0)...);
+      return *this;
     }
 
-    template <typename... Containers>
-    auto zip_longest(Containers&&... containers) {
-        return zip_longest_impl(std::tuple<Containers...>{
-            std::forward<Containers>(containers)...},
-            std::index_sequence_for<Containers...>{});
+    Iterator operator++(int) {
+      auto ret = *this;
+      ++*this;
+      return ret;
+    }
+
+    bool operator!=(const Iterator& other) const {
+      if (sizeof...(Is) == 0) return false;
+
+      bool results[] = {
+          false, (std::get<Is>(this->iters) != std::get<Is>(other.iters))...};
+      return std::any_of(
+          std::begin(results), std::end(results), [](bool b) { return b; });
     }
+
+    bool operator==(const Iterator& other) const {
+      return !(*this != other);
+    }
+
+    ZipIterDeref operator*() {
+      return ZipIterDeref{
+          ((std::get<Is>(this->iters) != std::get<Is>(this->ends))
+                  ? OptType<Is>{*std::get<Is>(this->iters)}
+                  : OptType<Is>{})...};
+    }
+
+    auto operator -> () -> ArrowProxy<decltype(**this)> {
+      return {**this};
+    }
+  };
+
+  Iterator begin() {
+    return {iterator_tuple_type<TupleType>{
+                std::begin(std::get<Is>(this->containers))...},
+        iterator_tuple_type<TupleType>{
+            std::end(std::get<Is>(this->containers))...}};
+  }
+
+  Iterator end() {
+    return {iterator_tuple_type<TupleType>{
+                std::end(std::get<Is>(this->containers))...},
+        iterator_tuple_type<TupleType>{
+            std::end(std::get<Is>(this->containers))...}};
+  }
+};
+
+template <typename TupleType, std::size_t... Is>
+iter::impl::ZippedLongest<TupleType, Is...> iter::impl::zip_longest_impl(
+    TupleType&& in_containers, std::index_sequence<Is...>) {
+  return {std::move(in_containers)};
+}
+
+template <typename... Containers>
+auto iter::zip_longest(Containers&&... containers) {
+  return impl::zip_longest_impl(
+      std::tuple<Containers...>{std::forward<Containers>(containers)...},
+      std::index_sequence_for<Containers...>{});
 }
 
 #endif

From 7fbb8b5cde31079d6c242f74af0a24d2265a4958 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 27 Aug 2015 22:51:03 -0700
Subject: [PATCH 1311/1866] make Chained ctor private

---
 chain.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/chain.hpp b/chain.hpp
index b50e520f..cc7c4d5c 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -84,10 +84,10 @@ class iter::impl::Chained {
   using TraitsValue = iterator_traits_deref<std::tuple_element_t<0, TupType>>;
 
  private:
+  Chained(TupType&& t) : tup(std::move(t)) {}
   TupType tup;
 
  public:
-  Chained(TupType&& t) : tup(std::move(t)) {}
 
   class Iterator : public std::iterator<std::input_iterator_tag, TraitsValue> {
    private:

From af2a8b1922216886373f6f57de1261faed20986a Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 27 Aug 2015 22:52:00 -0700
Subject: [PATCH 1312/1866] makes Chained move-only

---
 chain.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/chain.hpp b/chain.hpp
index cc7c4d5c..59369982 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -88,6 +88,7 @@ class iter::impl::Chained {
   TupType tup;
 
  public:
+  Chained(Chained&&) = default;
 
   class Iterator : public std::iterator<std::input_iterator_tag, TraitsValue> {
    private:

From f175c2384e8df4c800ec6d3a0cf9e115bf055f1c Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 6 Sep 2015 11:11:07 -0700
Subject: [PATCH 1313/1866] download_catch switched to download from master

instead of the devel branch which has a bunch of compiler errors.
---
 test/download_catch.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/download_catch.sh b/test/download_catch.sh
index b373a2c4..f88f5643 100755
--- a/test/download_catch.sh
+++ b/test/download_catch.sh
@@ -1,2 +1,2 @@
 #!/usr/bin/env sh
-wget -c https://raw.githubusercontent.com/philsquared/Catch/develop/single_include/catch.hpp
+wget -c https://raw.githubusercontent.com/philsquared/Catch/master/single_include/catch.hpp

From e08a1b8d63b2bc19437e95b17320a2aa03ae9aa9 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 6 Sep 2015 20:59:14 -0700
Subject: [PATCH 1314/1866] adds a test that a class is move-constructible only

not assignable at all, not copy constructible
---
 test/helpers.hpp | 313 ++++++++++++++++++++++++-----------------------
 1 file changed, 158 insertions(+), 155 deletions(-)

diff --git a/test/helpers.hpp b/test/helpers.hpp
index 06d0e035..39864222 100644
--- a/test/helpers.hpp
+++ b/test/helpers.hpp
@@ -9,107 +9,101 @@
 
 namespace itertest {
 
-// non-copyable. non-movable. non-default-constructible
-class SolidInt {
-    private:
-        const int i;
-    public:
-        constexpr SolidInt(int n)
-            : i{n}
-        { }
-
-        constexpr int getint() const {
-            return this->i;
-        }
-
-        SolidInt() = delete;
-        SolidInt(const SolidInt&) = delete;
-        SolidInt& operator=(const SolidInt&) = delete;
-        SolidInt& operator=(SolidInt&&) = delete;
-        SolidInt(SolidInt&&) = delete;
-};
-
-namespace {
+  // non-copyable. non-movable. non-default-constructible
+  class SolidInt {
+   private:
+    const int i;
+
+   public:
+    constexpr SolidInt(int n) : i{n} {}
+
+    constexpr int getint() const {
+      return this->i;
+    }
+
+    SolidInt() = delete;
+    SolidInt(const SolidInt&) = delete;
+    SolidInt& operator=(const SolidInt&) = delete;
+    SolidInt& operator=(SolidInt&&) = delete;
+    SolidInt(SolidInt&&) = delete;
+  };
+
+  namespace {
     struct DoubleDereferenceError : std::exception {
-        const char *what() const noexcept override {
-            return "Iterator dereferenced twice without increment";
-        }
+      const char* what() const noexcept override {
+        return "Iterator dereferenced twice without increment";
+      }
     };
 
     // this class's iterator will throw if it's dereference twice without
     // an increment in between
     class InputIterable {
-        public:
-            class Iterator {
-                private:
-                    int i;
-                    bool was_incremented = true;
-
-                public:
-                    Iterator(int n)
-                        : i{n}
-                    { }
-
-                    Iterator& operator++() {
-                        ++this->i;
-                        this->was_incremented = true;
-                        return *this;
-                    }
-
-                    int operator*() {
-                        if (!this->was_incremented) {
-                            throw DoubleDereferenceError{};
-                        }
-                        this->was_incremented = false;
-                        return this->i;
-                    }
-
-                    bool operator!=(const Iterator& other) const {
-                        return this->i != other.i;
-                    }
-            };
-
-            Iterator begin() {
-                return {0};
-            }
-
-            Iterator end() {
-                return {5};
-            }
-    };
-}
-
+     public:
+      class Iterator {
+       private:
+        int i;
+        bool was_incremented = true;
+
+       public:
+        Iterator(int n) : i{n} {}
+
+        Iterator& operator++() {
+          ++this->i;
+          this->was_incremented = true;
+          return *this;
+        }
 
+        int operator*() {
+          if (!this->was_incremented) {
+            throw DoubleDereferenceError{};
+          }
+          this->was_incremented = false;
+          return this->i;
+        }
 
-// BasicIterable provides a minimal forward iterator
-// operator++(), operator!=(const BasicIterable&), operator*()
-// move constructible only
-// not copy constructible, move assignable, or copy assignable
-template <typename T>
-class BasicIterable {
-    private:
-        T *data;
-        std::size_t size;
-        bool was_moved_from_ = false;
-        bool was_copied_from_ = false;
-    public:
-        BasicIterable(std::initializer_list<T> il)
-            : data{new T[il.size()]},
-            size{il.size()}
-        {
-            // would like to use enumerate, can't because it's for unit
-            // testing enumerate
-            std::size_t i = 0;
-            for (auto&& e : il) {
-                data[i] = e;
-                ++i;
-            }
+        bool operator!=(const Iterator& other) const {
+          return this->i != other.i;
         }
+      };
 
-        BasicIterable& operator=(BasicIterable&&) = delete;
-        BasicIterable& operator=(const BasicIterable&) = delete;
+      Iterator begin() {
+        return {0};
+      }
 
-        BasicIterable(const BasicIterable&) = delete;
+      Iterator end() {
+        return {5};
+      }
+    };
+  }
+
+  // BasicIterable provides a minimal forward iterator
+  // operator++(), operator!=(const BasicIterable&), operator*()
+  // move constructible only
+  // not copy constructible, move assignable, or copy assignable
+  template <typename T>
+  class BasicIterable {
+   private:
+    T* data;
+    std::size_t size;
+    bool was_moved_from_ = false;
+    bool was_copied_from_ = false;
+
+   public:
+    BasicIterable(std::initializer_list<T> il)
+        : data{new T[il.size()]}, size{il.size()} {
+      // would like to use enumerate, can't because it's for unit
+      // testing enumerate
+      std::size_t i = 0;
+      for (auto&& e : il) {
+        data[i] = e;
+        ++i;
+      }
+    }
+
+    BasicIterable& operator=(BasicIterable&&) = delete;
+    BasicIterable& operator=(const BasicIterable&) = delete;
+
+    BasicIterable(const BasicIterable&) = delete;
 #if 0
         BasicIterable(const BasicIterable& other)
             : data{new T[other.size()]},
@@ -123,79 +117,88 @@ class BasicIterable {
         }
 #endif
 
+    BasicIterable(BasicIterable&& other) : data{other.data}, size{other.size} {
+      other.data = nullptr;
+      other.was_moved_from_ = true;
+    }
 
-        BasicIterable(BasicIterable&& other)
-            : data{other.data},
-            size{other.size}
-        {
-            other.data = nullptr;
-            other.was_moved_from_ = true;
-        }
+    bool was_moved_from() const {
+      return this->was_moved_from_;
+    }
 
-        bool was_moved_from() const {
-            return this->was_moved_from_;
-        }
+    bool was_copied_from() const {
+      return this->was_copied_from_;
+    }
 
-        bool was_copied_from() const {
-            return this->was_copied_from_;
-        }
+    ~BasicIterable() {
+      delete[] this->data;
+    }
 
-        ~BasicIterable() {
-            delete [] this->data;
-        }
+    class Iterator {
+     private:
+      T* p;
 
-        class Iterator {
-            private:
-                T *p;
-            public:
+     public:
 #ifdef DEFINE_DEFAULT_ITERATOR_CTOR
-                Iterator() = default;
+      Iterator() = default;
 #endif
-                Iterator(T *b) : p{b} { }
-                bool operator!=(const Iterator& other) const {
-                    return this->p != other.p;
-                }
-
-                Iterator& operator++() {
-                    ++this->p;
-                    return *this;
-                }
-
-                T& operator*() {
-                    return *this->p;
-                }
-        };
-
-        Iterator begin() {
-            return {this->data};
-        }
-
-        Iterator end() {
-            return {this->data + this->size};
-        }
-};
-
-using iter::impl::void_t;
-
-template <typename, typename =void>
-struct IsIterator : std::false_type { };
-
-template <typename T>
-struct IsIterator <T, void_t<
-        decltype(T(std::declval<const T&>())), // copyctor
-        decltype(std::declval<T&>() = std::declval<const T&>()), // copy =
-        decltype(*std::declval<T&>()), // operator*
-        decltype(std::declval<T&>().operator->()), // operator->
-        decltype(++std::declval<T&>()), // prefix ++
-        decltype(std::declval<T&>()++), // postfix ++
-        decltype(std::declval<const T&>() != std::declval<const T&>()), //  !=
-        decltype(std::declval<const T&>() == std::declval<const T&>()) //  ==
-    >> : std::true_type { };
-
-template <typename T>
-struct IsForwardIterator : std::integral_constant<bool,
-  IsIterator<T>::value && std::is_default_constructible<T>::value> { };
+      Iterator(T* b) : p{b} {}
+      bool operator!=(const Iterator& other) const {
+        return this->p != other.p;
+      }
+
+      Iterator& operator++() {
+        ++this->p;
+        return *this;
+      }
+
+      T& operator*() {
+        return *this->p;
+      }
+    };
 
+    Iterator begin() {
+      return {this->data};
+    }
+
+    Iterator end() {
+      return {this->data + this->size};
+    }
+  };
+
+  using iter::impl::void_t;
+
+  template <typename, typename = void>
+  struct IsIterator : std::false_type {};
+
+  template <typename T>
+  struct IsIterator<T,
+      void_t<decltype(T(std::declval<const T&>())),  // copyctor
+                        decltype(std::declval<T&>() =
+                                     std::declval<const T&>()),  // copy =
+                        decltype(*std::declval<T&>()),           // operator*
+                        decltype(
+                            std::declval<T&>().operator->()),  // operator->
+                        decltype(++std::declval<T&>()),        // prefix ++
+                        decltype(std::declval<T&>()++),        // postfix ++
+                        decltype(std::declval<const T&>()
+                                 != std::declval<const T&>()),  //  !=
+                        decltype(std::declval<const T&>()
+                                 == std::declval<const T&>())  //  ==
+                        >> : std::true_type {};
+
+  template <typename T>
+  struct IsForwardIterator
+      : std::integral_constant<bool,
+            IsIterator<T>::value && std::is_default_constructible<T>::value> {};
+
+  template <typename T>
+  struct IsMoveConstructibleOnly
+      : std::integral_constant<bool,
+            !std::is_copy_constructible<T>::value
+                && !std::is_copy_assignable<T>::value
+                && !std::is_move_assignable<T>::value
+                && std::is_move_constructible<T>::value> {};
 }
 
 #endif

From a1f9e1d537dc89fd083e21344dd7c13de6a5f02d Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 6 Sep 2015 21:01:44 -0700
Subject: [PATCH 1315/1866] tests IsMoveConstructibleOnly

---
 test/test_helpers.cpp | 44 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)

diff --git a/test/test_helpers.cpp b/test/test_helpers.cpp
index 129a17d2..ad456f6c 100644
--- a/test/test_helpers.cpp
+++ b/test/test_helpers.cpp
@@ -5,6 +5,7 @@
 
 using itertest::SolidInt;
 using itertest::IsIterator;
+using itertest::IsMoveConstructibleOnly;
 
 namespace {
 
@@ -81,3 +82,46 @@ TEST_CASE("IsIterator fails when missing copy assignment", "[helpers]") {
 TEST_CASE("IsIterator passes a valid iterator", "[helpers]") {
     REQUIRE( IsIterator<ValidIter>::value );
 }
+
+struct HasNothing {
+  HasNothing(const HasNothing&) = delete;
+  HasNothing& operator=(const HasNothing&) = delete;
+};
+
+struct HasMoveAndCopyCtor {
+  HasMoveAndCopyCtor(const HasMoveAndCopyCtor&);
+  HasMoveAndCopyCtor(HasMoveAndCopyCtor&&);
+};
+
+struct HasMoveCtorAndAssign {
+  HasMoveCtorAndAssign(HasMoveCtorAndAssign&&);
+  HasMoveCtorAndAssign& operator=(HasMoveCtorAndAssign&&);
+};
+
+struct HasMoveCtorAndCopyAssign {
+  HasMoveCtorAndCopyAssign(HasMoveCtorAndCopyAssign&&);
+  HasMoveCtorAndCopyAssign&  operator=(const HasMoveCtorAndCopyAssign&);
+};
+
+struct HasMoveCtorOnly {
+  HasMoveCtorOnly(HasMoveCtorOnly&&);
+};
+
+TEST_CASE("IsMoveConstructibleOnly false without move ctor", "[helpers]") {
+  REQUIRE_FALSE( IsMoveConstructibleOnly<HasNothing>::value );
+}
+
+TEST_CASE("IsMoveConstructibleOnly false with copy ctor", "[helpers]") {
+  REQUIRE_FALSE( IsMoveConstructibleOnly<HasMoveAndCopyCtor>::value );
+}
+
+TEST_CASE("IsMoveConstructibleOnly false with move assign", "[helpers]") {
+  REQUIRE_FALSE( IsMoveConstructibleOnly<HasMoveCtorAndAssign>::value );
+}
+TEST_CASE("IsMoveConstructibleOnly false with copy assign", "[helpers]") {
+  REQUIRE_FALSE( IsMoveConstructibleOnly<HasMoveCtorAndCopyAssign>::value );
+}
+
+TEST_CASE("IsMoveConstructibleOnly true when met", "[helpers]") {
+  REQUIRE( IsMoveConstructibleOnly<HasMoveCtorOnly>::value );
+}

From 0711b74d8df835ece4556b1d9bfe232255dabedc Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 6 Sep 2015 23:21:19 -0700
Subject: [PATCH 1316/1866] tests accum impl has move ctor only

---
 test/test_accumulate.cpp | 101 +++++++++++++++++++++------------------
 1 file changed, 54 insertions(+), 47 deletions(-)

diff --git a/test/test_accumulate.cpp b/test/test_accumulate.cpp
index 1a4e9413..0d60f927 100644
--- a/test/test_accumulate.cpp
+++ b/test/test_accumulate.cpp
@@ -12,84 +12,91 @@ using itertest::BasicIterable;
 
 using Vec = const std::vector<int>;
 TEST_CASE("Simple sum", "[accumulate]") {
-    Vec ns{1,2,3,4,5};
-    auto a = accumulate(ns);
+  Vec ns{1, 2, 3, 4, 5};
+  auto a = accumulate(ns);
 
-    Vec v(std::begin(a), std::end(a));
-    Vec vc{1,3,6,10,15};
-    REQUIRE( v == vc );
+  Vec v(std::begin(a), std::end(a));
+  Vec vc{1, 3, 6, 10, 15};
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("accumulate: With subtraction lambda", "[accumulate]") {
-    Vec ns{5,4,3,2,1};
-    auto a = accumulate(ns, [](int a, int b){return a - b; });
+  Vec ns{5, 4, 3, 2, 1};
+  auto a = accumulate(ns, [](int a, int b) { return a - b; });
 
-    Vec v(std::begin(a), std::end(a));
-    Vec vc{5, 1, -2, -4, -5};
-    REQUIRE( v == vc );
+  Vec v(std::begin(a), std::end(a));
+  Vec vc{5, 1, -2, -4, -5};
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("accumulate: with initializer_list works", "[accumulate]") {
-    auto a = accumulate({1, 2, 3});
-    Vec v(std::begin(a), std::end(a));
-    Vec vc{1, 3, 6};
+  auto a = accumulate({1, 2, 3});
+  Vec v(std::begin(a), std::end(a));
+  Vec vc{1, 3, 6};
 
-    REQUIRE( v == vc );
+  REQUIRE(v == vc);
 }
 
 struct Integer {
-    const int value;
-    constexpr Integer(int i) : value{i} { }
-    constexpr Integer operator+(Integer other) const noexcept {
-        return {this->value + other.value};
-    }
+  const int value;
+  constexpr Integer(int i) : value{i} {}
+  constexpr Integer operator+(Integer other) const noexcept {
+    return {this->value + other.value};
+  }
 };
 
 TEST_CASE("accumulate: intermidate type need not be default constructible",
-        "[accumulate]") {
-    std::vector<Integer> v = {{2}, {3}, {10}};
-    auto a = accumulate(v, std::plus<Integer>{});
-    auto it = std::begin(a);
+    "[accumulate]") {
+  std::vector<Integer> v = {{2}, {3}, {10}};
+  auto a = accumulate(v, std::plus<Integer>{});
+  auto it = std::begin(a);
 }
 
 TEST_CASE("accumulate: binds reference when it should", "[accumulate]") {
-    BasicIterable<int> bi{1, 2};
-    accumulate(bi);
-    REQUIRE_FALSE( bi.was_moved_from() );
+  BasicIterable<int> bi{1, 2};
+  accumulate(bi);
+  REQUIRE_FALSE(bi.was_moved_from());
 }
 
 TEST_CASE("accumulate: moves rvalues when it should", "[accumulate]") {
-    BasicIterable<int> bi{1, 2};
-    accumulate(std::move(bi));
-    REQUIRE( bi.was_moved_from() );
+  BasicIterable<int> bi{1, 2};
+  accumulate(std::move(bi));
+  REQUIRE(bi.was_moved_from());
 }
 
 TEST_CASE("accumulate: operator==", "[accumulate]") {
-    Vec v;
-    auto a = accumulate(v);
-    REQUIRE( std::begin(a) == std::end(a) );
+  Vec v;
+  auto a = accumulate(v);
+  REQUIRE(std::begin(a) == std::end(a));
 }
 
 TEST_CASE("accumulate: postfix ++", "[accumulate]") {
-    Vec ns{2,3};
-    auto a = accumulate(ns);
-    auto it = std::begin(a);
-    it++;
-    REQUIRE( *it == 5 );
+  Vec ns{2, 3};
+  auto a = accumulate(ns);
+  auto it = std::begin(a);
+  it++;
+  REQUIRE(*it == 5);
 }
 
 TEST_CASE("accumulate: operator->", "[accumulate]") {
-    Vec ns{7, 3};
-    auto a = accumulate(ns);
-    auto it = std::begin(a);
-    const int *p = it.operator->();
-    REQUIRE( *p == 7 );
+  Vec ns{7, 3};
+  auto a = accumulate(ns);
+  auto it = std::begin(a);
+  const int* p = it.operator->();
+  REQUIRE(*p == 7);
 }
 
 TEST_CASE("accumulate: iterator meets requirements", "[accumulate]") {
-    Vec ns{};
-    auto a = accumulate(ns, [](int a, int b) { return a + b; });
-    auto it = std::begin(a);
-    it = std::begin(a);
-    REQUIRE( itertest::IsIterator<decltype(std::begin(a))>::value );
+  Vec ns{};
+  auto a = accumulate(ns, [](int a, int b) { return a + b; });
+  auto it = std::begin(a);
+  it = std::begin(a);
+  REQUIRE(itertest::IsIterator<decltype(std::begin(a))>::value);
+}
+
+template <typename T>
+using ImpT = decltype(accumulate(std::declval<T>()));
+TEST_CASE("accumulate: has correct ctor and assign ops", "[accumulate]") {
+  REQUIRE(itertest::IsMoveConstructibleOnly<ImpT<std::string&>>::value);
+  REQUIRE(itertest::IsMoveConstructibleOnly<ImpT<std::string>>::value);
 }

From b7695785b02d20d877dcffebbbae42276dceffb1 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 6 Sep 2015 23:21:36 -0700
Subject: [PATCH 1317/1866] tests chain impl has move ctor only

---
 test/test_chain.cpp | 292 +++++++++++++++++++++++---------------------
 1 file changed, 154 insertions(+), 138 deletions(-)

diff --git a/test/test_chain.cpp b/test/test_chain.cpp
index 46319d33..85844900 100644
--- a/test/test_chain.cpp
+++ b/test/test_chain.cpp
@@ -16,200 +16,216 @@ using itertest::BasicIterable;
 using Vec = const std::vector<char>;
 
 TEST_CASE("chain: three strings", "[chain]") {
-    std::string s1{"abc"};
-    std::string s2{"mno"};
-    std::string s3{"xyz"};
-    auto ch = chain(s1, s2, s3);
+  std::string s1{"abc"};
+  std::string s2{"mno"};
+  std::string s3{"xyz"};
+  auto ch = chain(s1, s2, s3);
 
-    Vec v(std::begin(ch), std::end(ch));
-    Vec vc{'a','b','c','m','n','o','x','y','z'};
+  Vec v(std::begin(ch), std::end(ch));
+  Vec vc{'a', 'b', 'c', 'm', 'n', 'o', 'x', 'y', 'z'};
 
-    REQUIRE( v == vc );
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("chain: with different container types", "[chain]") {
-    std::string s1{"abc"};
-    std::list<char> li{'m', 'n', 'o'};
-    std::vector<char> vec{'x', 'y', 'z'};
-    auto ch = chain(s1, li, vec);
+  std::string s1{"abc"};
+  std::list<char> li{'m', 'n', 'o'};
+  std::vector<char> vec{'x', 'y', 'z'};
+  auto ch = chain(s1, li, vec);
 
-    Vec v(std::begin(ch), std::end(ch));
-    Vec vc{'a','b','c','m','n','o','x','y','z'};
+  Vec v(std::begin(ch), std::end(ch));
+  Vec vc{'a', 'b', 'c', 'm', 'n', 'o', 'x', 'y', 'z'};
 
-    REQUIRE( v == vc );
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("chain: handles empty containers", "[chain]") {
-    std::string emp;
-    std::string a{"a"};
-    std::string b{"b"};
-    std::string c{"c"};
-    Vec vc{'a', 'b', 'c'};
-
-    SECTION("Empty container at front") {
-        auto ch = chain(emp, a, b, c);
-        Vec v(std::begin(ch), std::end(ch));
+  std::string emp;
+  std::string a{"a"};
+  std::string b{"b"};
+  std::string c{"c"};
+  Vec vc{'a', 'b', 'c'};
+
+  SECTION("Empty container at front") {
+    auto ch = chain(emp, a, b, c);
+    Vec v(std::begin(ch), std::end(ch));
 
-        REQUIRE( v == vc );
-    }
+    REQUIRE(v == vc);
+  }
 
-    SECTION("Empty container at back") {
-        auto ch = chain(a, b, c, emp);
-        Vec v(std::begin(ch), std::end(ch));
+  SECTION("Empty container at back") {
+    auto ch = chain(a, b, c, emp);
+    Vec v(std::begin(ch), std::end(ch));
 
-        REQUIRE( v == vc );
-    }
+    REQUIRE(v == vc);
+  }
 
-    SECTION("Empty container in middle") {
-        auto ch = chain(a, emp, b, emp, c);
-        Vec v(std::begin(ch), std::end(ch));
+  SECTION("Empty container in middle") {
+    auto ch = chain(a, emp, b, emp, c);
+    Vec v(std::begin(ch), std::end(ch));
 
-        REQUIRE( v == vc );
-    }
+    REQUIRE(v == vc);
+  }
 
-    SECTION("Consecutive empty containers at front") {
-        auto ch = chain(emp, emp, a, b, c);
-        Vec v(std::begin(ch), std::end(ch));
+  SECTION("Consecutive empty containers at front") {
+    auto ch = chain(emp, emp, a, b, c);
+    Vec v(std::begin(ch), std::end(ch));
 
-        REQUIRE( v == vc );
-    }
+    REQUIRE(v == vc);
+  }
 
-    SECTION("Consecutive empty containers at back") {
-        auto ch = chain(a, b, c, emp, emp);
-        Vec v(std::begin(ch), std::end(ch));
+  SECTION("Consecutive empty containers at back") {
+    auto ch = chain(a, b, c, emp, emp);
+    Vec v(std::begin(ch), std::end(ch));
 
-        REQUIRE( v == vc );
-    }
+    REQUIRE(v == vc);
+  }
 
-    SECTION("Consecutive empty containers in middle") {
-        auto ch = chain(a, emp, emp, b, emp, emp, c);
-        Vec v(std::begin(ch), std::end(ch));
+  SECTION("Consecutive empty containers in middle") {
+    auto ch = chain(a, emp, emp, b, emp, emp, c);
+    Vec v(std::begin(ch), std::end(ch));
 
-        REQUIRE( v == vc );
-    }
+    REQUIRE(v == vc);
+  }
 }
 
 TEST_CASE("chain: with only empty containers", "[chain]") {
-    std::string emp{};
-    SECTION("one empty container") {
-        auto ch = chain(emp);
-        REQUIRE_FALSE( std::begin(ch) != std::end(ch) );
-    }
-
-    SECTION("two empty containers") {
-        auto ch = chain(emp, emp);
-        REQUIRE_FALSE( std::begin(ch) != std::end(ch) );
-    }
-
-    SECTION("three empty containers") {
-        auto ch = chain(emp, emp, emp);
-        REQUIRE_FALSE( std::begin(ch) != std::end(ch) );
-    }
+  std::string emp{};
+  SECTION("one empty container") {
+    auto ch = chain(emp);
+    REQUIRE_FALSE(std::begin(ch) != std::end(ch));
+  }
+
+  SECTION("two empty containers") {
+    auto ch = chain(emp, emp);
+    REQUIRE_FALSE(std::begin(ch) != std::end(ch));
+  }
+
+  SECTION("three empty containers") {
+    auto ch = chain(emp, emp, emp);
+    REQUIRE_FALSE(std::begin(ch) != std::end(ch));
+  }
 }
 
 TEST_CASE("chain: doesn't move or copy elements of iterable", "[chain]") {
-    constexpr SolidInt arr[] = {{6}, {7}, {8}};
-    for (auto&& i : chain(arr, arr)) {
-        (void)i;
-    }
+  constexpr SolidInt arr[] = {{6}, {7}, {8}};
+  for (auto&& i : chain(arr, arr)) {
+    (void)i;
+  }
 }
 
 TEST_CASE("chain: binds reference to lvalue and moves rvalue", "[chain]") {
-    BasicIterable<char> bi{'x', 'y', 'z'};
-    BasicIterable<char> bi2{'a', 'j', 'm'};
-    SECTION("First moved, second ref'd") {
-        chain(std::move(bi), bi2);
-        REQUIRE( bi.was_moved_from() );
-        REQUIRE_FALSE( bi2.was_moved_from() );
-    }
-    SECTION("First ref'd, second moved") {
-        chain(bi, std::move(bi2));
-        REQUIRE_FALSE( bi.was_moved_from() );
-        REQUIRE( bi2.was_moved_from() );
-    }
+  BasicIterable<char> bi{'x', 'y', 'z'};
+  BasicIterable<char> bi2{'a', 'j', 'm'};
+  SECTION("First moved, second ref'd") {
+    chain(std::move(bi), bi2);
+    REQUIRE(bi.was_moved_from());
+    REQUIRE_FALSE(bi2.was_moved_from());
+  }
+  SECTION("First ref'd, second moved") {
+    chain(bi, std::move(bi2));
+    REQUIRE_FALSE(bi.was_moved_from());
+    REQUIRE(bi2.was_moved_from());
+  }
 }
 
 TEST_CASE("chain: operator==", "[chain]") {
-    std::string emp{};
-    auto ch = chain(emp);
-    REQUIRE( std::begin(ch) == std::end(ch) );
+  std::string emp{};
+  auto ch = chain(emp);
+  REQUIRE(std::begin(ch) == std::end(ch));
 }
 
 TEST_CASE("chain: postfix ++", "[chain]") {
-    std::string s1{"a"}, s2{"b"};
-    auto ch = chain(s1, s2);
-    auto it = std::begin(ch);
-    it++;
-    REQUIRE( *it == 'b');
+  std::string s1{"a"}, s2{"b"};
+  auto ch = chain(s1, s2);
+  auto it = std::begin(ch);
+  it++;
+  REQUIRE(*it == 'b');
 }
 
 TEST_CASE("chain: iterator meets requirements", "[chain]") {
-    Vec ns{};
-    auto c = chain(ns, ns);
-    REQUIRE( itertest::IsIterator<decltype(std::begin(c))>::value );
+  Vec ns{};
+  auto c = chain(ns, ns);
+  REQUIRE(itertest::IsIterator<decltype(std::begin(c))>::value);
 }
 
+template <typename... Ts>
+using ImpT = decltype(chain(std::declval<Ts>()...));
+TEST_CASE("chain: has correct ctor and assign ops", "[chain]") {
+  using T = ImpT<std::string&, std::vector<char>, char[10]>;
+  REQUIRE(itertest::IsMoveConstructibleOnly<T>::value);
+}
 
 TEST_CASE("chain.from_iterable: basic test", "[chain.from_iterable]") {
-    std::vector<std::string> sv{"abc", "xyz"};
-    auto ch = chain.from_iterable(sv);
-    std::vector<char> v(std::begin(ch), std::end(ch));
+  std::vector<std::string> sv{"abc", "xyz"};
+  auto ch = chain.from_iterable(sv);
+  std::vector<char> v(std::begin(ch), std::end(ch));
 
-    std::vector<char> vc{'a', 'b', 'c', 'x', 'y', 'z'};
-    REQUIRE( v == vc );
+  std::vector<char> vc{'a', 'b', 'c', 'x', 'y', 'z'};
+  REQUIRE(v == vc);
 }
 
-TEST_CASE("chain.from_iterable: iterators cant be copy constructed "
-        "and assigned", "[chain.from_iterable]") {
-    std::vector<std::string> sv{"abc", "xyz"};
-    auto ch = chain.from_iterable(sv);
-    auto it = std::begin(ch);
-
-    SECTION("Copy constructed") {
-        auto it2 = it;
-        ++it;
-        REQUIRE( it != it2 );
-    }
-
-    SECTION("Copy assigned") {
-        auto it2 = std::end(ch);
-        it2 = it;
-        REQUIRE( it == it2 );
-    }
+TEST_CASE(
+    "chain.from_iterable: iterators cant be copy constructed "
+    "and assigned",
+    "[chain.from_iterable]") {
+  std::vector<std::string> sv{"abc", "xyz"};
+  auto ch = chain.from_iterable(sv);
+  auto it = std::begin(ch);
+
+  SECTION("Copy constructed") {
+    auto it2 = it;
+    ++it;
+    REQUIRE(it != it2);
+  }
+
+  SECTION("Copy assigned") {
+    auto it2 = std::end(ch);
+    it2 = it;
+    REQUIRE(it == it2);
+  }
 }
 
 TEST_CASE("chain.from_iterable: postfix ++", "[chain.from_iterable]") {
-    std::vector<std::string> sv{"a", "n"};
-    auto ch = chain.from_iterable(sv);
-    auto it = std::begin(ch);
-    it++;
-    REQUIRE( *it == 'n' );
+  std::vector<std::string> sv{"a", "n"};
+  auto ch = chain.from_iterable(sv);
+  auto it = std::begin(ch);
+  it++;
+  REQUIRE(*it == 'n');
 }
 
-
 TEST_CASE("chain.from_iterable: moves rvalues and binds ref to lvalues",
-        "[chain.from_iterable]") {
-    BasicIterable<std::string> bi{"abc", "xyz"};
-    SECTION("Moves rvalue") {
-        chain.from_iterable(std::move(bi));
-        REQUIRE( bi.was_moved_from() );
-    }
-    SECTION("Binds ref to lvalue") {
-        chain.from_iterable(bi);
-        REQUIRE_FALSE( bi.was_moved_from() );
-    }
+    "[chain.from_iterable]") {
+  BasicIterable<std::string> bi{"abc", "xyz"};
+  SECTION("Moves rvalue") {
+    chain.from_iterable(std::move(bi));
+    REQUIRE(bi.was_moved_from());
+  }
+  SECTION("Binds ref to lvalue") {
+    chain.from_iterable(bi);
+    REQUIRE_FALSE(bi.was_moved_from());
+  }
 }
 
 TEST_CASE("chain.from_iterable: empty", "[chain.from_iterable]") {
-    const std::vector<std::string> v{};
-    auto ch = chain.from_iterable(v);
-    REQUIRE( std::begin(ch) == std::end(ch) );
+  const std::vector<std::string> v{};
+  auto ch = chain.from_iterable(v);
+  REQUIRE(std::begin(ch) == std::end(ch));
 }
 
-
 TEST_CASE("chain.from_iterable: iterator meets requirements",
-        "[chain.from_iterable]") {
-    const std::vector<std::string> v{};
-    auto c = chain.from_iterable(v);
-    REQUIRE( itertest::IsIterator<decltype(std::begin(c))>::value );
+    "[chain.from_iterable]") {
+  const std::vector<std::string> v{};
+  auto c = chain.from_iterable(v);
+  REQUIRE(itertest::IsIterator<decltype(std::begin(c))>::value);
+}
+
+template <typename T>
+using ImpT2 = decltype(chain.from_iterable(std::declval<T>()));
+TEST_CASE("chain.from_iterable: has correct ctor and assign ops",
+    "[chain.from_iterable]") {
+  REQUIRE(itertest::IsMoveConstructibleOnly<ImpT2<std::vector<std::string>>>::
+          value);
+  REQUIRE(itertest::IsMoveConstructibleOnly<ImpT2<std::vector<std::string>&>>::
+          value);
 }

From 030ad33b2d85d86150a221327103f675d63fdb3d Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 6 Sep 2015 23:21:45 -0700
Subject: [PATCH 1318/1866] tests chunked impl has move ctor only

---
 test/test_chunked.cpp | 69 ++++++++++++++++++++++++-------------------
 1 file changed, 38 insertions(+), 31 deletions(-)

diff --git a/test/test_chunked.cpp b/test/test_chunked.cpp
index e77429b0..16c948ed 100644
--- a/test/test_chunked.cpp
+++ b/test/test_chunked.cpp
@@ -13,54 +13,61 @@ using Vec = std::vector<int>;
 using ResVec = std::vector<Vec>;
 
 TEST_CASE("chunked: basic test", "[chunked]") {
-    Vec ns = {1,2,3,4,5,6};
-    ResVec results;
-    for (auto&& g : chunked(ns, 2)) {
-        results.emplace_back(std::begin(g), std::end(g));
-    }
+  Vec ns = {1, 2, 3, 4, 5, 6};
+  ResVec results;
+  for (auto&& g : chunked(ns, 2)) {
+    results.emplace_back(std::begin(g), std::end(g));
+  }
 
-    ResVec rc = { {1, 2}, {3, 4}, {5, 6} };
+  ResVec rc = {{1, 2}, {3, 4}, {5, 6}};
 
-    REQUIRE( results == rc );
+  REQUIRE(results == rc);
 }
 
 TEST_CASE("chunked: len(iterable) % groupsize != 0", "[chunked]") {
-    Vec ns = {1,2,3,4,5,6,7};
-    ResVec results;
-    for (auto&& g : chunked(ns, 3)) {
-        results.emplace_back(std::begin(g), std::end(g));
-    }
+  Vec ns = {1, 2, 3, 4, 5, 6, 7};
+  ResVec results;
+  for (auto&& g : chunked(ns, 3)) {
+    results.emplace_back(std::begin(g), std::end(g));
+  }
 
-    ResVec rc = { {1, 2, 3}, {4, 5, 6}, {7} };
+  ResVec rc = {{1, 2, 3}, {4, 5, 6}, {7}};
 
-    REQUIRE( results == rc );
+  REQUIRE(results == rc);
 }
 
 TEST_CASE("chunked: iterators can be compared", "[chunked]") {
-    Vec ns = {1,2,3,4,5,6,7};
-    auto g = chunked(ns, 3);
-    auto it = std::begin(g);
-    REQUIRE( it == std::begin(g) );
-    REQUIRE_FALSE( it != std::begin(g) );
-    ++it;
-    REQUIRE( it != std::begin(g) );
-    REQUIRE_FALSE( it == std::begin(g) );
+  Vec ns = {1, 2, 3, 4, 5, 6, 7};
+  auto g = chunked(ns, 3);
+  auto it = std::begin(g);
+  REQUIRE(it == std::begin(g));
+  REQUIRE_FALSE(it != std::begin(g));
+  ++it;
+  REQUIRE(it != std::begin(g));
+  REQUIRE_FALSE(it == std::begin(g));
 }
 
 TEST_CASE("chunked: size 0 is empty", "[chunked]") {
-    Vec ns{1, 2, 3};
-    auto g = chunked(ns, 0);
-    REQUIRE( std::begin(g) == std::end(g) );
+  Vec ns{1, 2, 3};
+  auto g = chunked(ns, 0);
+  REQUIRE(std::begin(g) == std::end(g));
 }
 
 TEST_CASE("chunked: empty iterable gives empty chunked", "[chunked]") {
-    Vec ns{};
-    auto g = chunked(ns, 1);
-    REQUIRE( std::begin(g) == std::end(g) );
+  Vec ns{};
+  auto g = chunked(ns, 1);
+  REQUIRE(std::begin(g) == std::end(g));
 }
 
 TEST_CASE("chunked: iterator meets requirements", "[chunked]") {
-    std::string s{};
-    auto c = chunked(s, 1);
-    REQUIRE( itertest::IsIterator<decltype(std::begin(c))>::value );
+  std::string s{};
+  auto c = chunked(s, 1);
+  REQUIRE(itertest::IsIterator<decltype(std::begin(c))>::value);
+}
+
+template <typename T>
+using ImpT = decltype(chunked(std::declval<T>(), 1));
+TEST_CASE("chunked: has correct ctor and assign ops", "[chunked]") {
+  REQUIRE(itertest::IsMoveConstructibleOnly<ImpT<std::string&>>::value);
+  REQUIRE(itertest::IsMoveConstructibleOnly<ImpT<std::string>>::value);
 }

From 5de4b7d0ac50e6b62b23d1f881b911f7c622f861 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 6 Sep 2015 23:21:58 -0700
Subject: [PATCH 1319/1866] tests comb impl has move ctor only

---
 test/test_combinations.cpp | 115 +++++++++++++++++++------------------
 1 file changed, 60 insertions(+), 55 deletions(-)

diff --git a/test/test_combinations.cpp b/test/test_combinations.cpp
index 278c6225..5ce91e6e 100644
--- a/test/test_combinations.cpp
+++ b/test/test_combinations.cpp
@@ -11,88 +11,93 @@
 
 #include "catch.hpp"
 
-
 using iter::combinations;
 using itertest::BasicIterable;
 using itertest::SolidInt;
 using CharCombSet = std::vector<std::vector<char>>;
 
 TEST_CASE("combinations: Simple combination of 4", "[combinations]") {
-    std::string s{"ABCD"};
-    CharCombSet sc;
-    for (auto v : combinations(s, 2)) {
-        sc.emplace_back(std::begin(v), std::end(v));
-    }
-
-    CharCombSet ans = 
-        {{'A','B'}, {'A','C'}, {'A','D'}, {'B','C'}, {'B','D'}, {'C','D'}};
-    REQUIRE( ans == sc );
+  std::string s{"ABCD"};
+  CharCombSet sc;
+  for (auto v : combinations(s, 2)) {
+    sc.emplace_back(std::begin(v), std::end(v));
+  }
+
+  CharCombSet ans = {
+      {'A', 'B'}, {'A', 'C'}, {'A', 'D'}, {'B', 'C'}, {'B', 'D'}, {'C', 'D'}};
+  REQUIRE(ans == sc);
 }
 
 TEST_CASE("combinations: iterators can be compared", "[combinations]") {
-    std::string s{"ABCD"};
-    auto c = combinations(s, 2);
-    auto it = std::begin(c);
-    REQUIRE( it == std::begin(c) );
-    REQUIRE_FALSE( it != std::begin(c) );
-    ++it;
-    REQUIRE( it != std::begin(c) );
-    REQUIRE_FALSE( it == std::begin(c) );
+  std::string s{"ABCD"};
+  auto c = combinations(s, 2);
+  auto it = std::begin(c);
+  REQUIRE(it == std::begin(c));
+  REQUIRE_FALSE(it != std::begin(c));
+  ++it;
+  REQUIRE(it != std::begin(c));
+  REQUIRE_FALSE(it == std::begin(c));
 }
 
 TEST_CASE("combinations: operator->", "[combinations]") {
-    std::string s{"ABCD"};
-    auto c = combinations(s, 2);
-    auto it = std::begin(c);
-    REQUIRE( it->size() == 2 );
+  std::string s{"ABCD"};
+  auto c = combinations(s, 2);
+  auto it = std::begin(c);
+  REQUIRE(it->size() == 2);
 }
 
-
 TEST_CASE("combinations: size too large gives no results", "[combinations]") {
-    std::string s{"ABCD"};
-    auto c = combinations(s, 5);
-    REQUIRE( std::begin(c) == std::end(c) );
+  std::string s{"ABCD"};
+  auto c = combinations(s, 5);
+  REQUIRE(std::begin(c) == std::end(c));
 }
 
 TEST_CASE("combinations: size 0 gives nothing", "[combinations]") {
-    std::string s{"ABCD"};
-    auto c = combinations(s, 0);
-    REQUIRE( std::begin(c) == std::end(c) );
+  std::string s{"ABCD"};
+  auto c = combinations(s, 0);
+  REQUIRE(std::begin(c) == std::end(c));
 }
 
-TEST_CASE("combinations: iterable without operator*() const", "[combinations]")
-{
-    BasicIterable<char> bi{'x', 'y', 'z'};
-    auto c = combinations(bi, 1);
-    auto it = std::begin(c);
-    ++it;
-    (*it)[0];
+TEST_CASE(
+    "combinations: iterable without operator*() const", "[combinations]") {
+  BasicIterable<char> bi{'x', 'y', 'z'};
+  auto c = combinations(bi, 1);
+  auto it = std::begin(c);
+  ++it;
+  (*it)[0];
 }
 
 TEST_CASE("combinations: binds to lvalues, moves rvalues", "[combinations]") {
-    BasicIterable<char> bi{'x', 'y', 'z'};
-    SECTION("binds to lvalues") {
-        combinations(bi, 1);
-        REQUIRE_FALSE( bi.was_moved_from() );
-    }
-    SECTION("moves rvalues") {
-        combinations(std::move(bi), 1);
-        REQUIRE( bi.was_moved_from() );
-    }
+  BasicIterable<char> bi{'x', 'y', 'z'};
+  SECTION("binds to lvalues") {
+    combinations(bi, 1);
+    REQUIRE_FALSE(bi.was_moved_from());
+  }
+  SECTION("moves rvalues") {
+    combinations(std::move(bi), 1);
+    REQUIRE(bi.was_moved_from());
+  }
 }
 
 TEST_CASE("combinations: doesn't move or copy elements of iterable",
-        "[combinations]") {
-    constexpr SolidInt arr[] = {{6}, {7}, {8}};
-    for (auto&& i : combinations(arr, 1)) {
-        (void)i;
-    }
+    "[combinations]") {
+  constexpr SolidInt arr[] = {{6}, {7}, {8}};
+  for (auto&& i : combinations(arr, 1)) {
+    (void)i;
+  }
 }
 
 TEST_CASE("combinations: iterator meets requirements", "[combinations]") {
-    std::string s{"abc"};
-    auto c = combinations(s, 1);
-    REQUIRE( itertest::IsIterator<decltype(std::begin(c))>::value );
-    auto&& row = *std::begin(c);
-    REQUIRE( itertest::IsIterator<decltype(std::begin(row))>::value );
+  std::string s{"abc"};
+  auto c = combinations(s, 1);
+  REQUIRE(itertest::IsIterator<decltype(std::begin(c))>::value);
+  auto&& row = *std::begin(c);
+  REQUIRE(itertest::IsIterator<decltype(std::begin(row))>::value);
+}
+
+template <typename T>
+using ImpT = decltype(combinations(std::declval<T>(), 1));
+TEST_CASE("combinations: has correct ctor and assign ops", "[combinations]") {
+  REQUIRE(itertest::IsMoveConstructibleOnly<ImpT<std::string&>>::value);
+  REQUIRE(itertest::IsMoveConstructibleOnly<ImpT<std::string>>::value);
 }

From cc038b59b8f4766b77f3804ec08f39451b13f56e Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 6 Sep 2015 23:22:15 -0700
Subject: [PATCH 1320/1866] tests comb_w_repl impl has move ctor only

---
 test/test_combinations_with_replacement.cpp | 129 +++++++++++---------
 1 file changed, 69 insertions(+), 60 deletions(-)

diff --git a/test/test_combinations_with_replacement.cpp b/test/test_combinations_with_replacement.cpp
index e5e91f25..5f0fc4ef 100644
--- a/test/test_combinations_with_replacement.cpp
+++ b/test/test_combinations_with_replacement.cpp
@@ -13,83 +13,92 @@ using itertest::BasicIterable;
 using CharCombSet = std::vector<std::vector<char>>;
 
 TEST_CASE("combinations_with_replacement: Simple combination",
-        "[combinations_with_replacement]") {
-    std::string s{"ABC"};
-    CharCombSet sc;
-    for (auto v : combinations_with_replacement(s, 2)) {
-        sc.emplace_back(std::begin(v), std::end(v));
-    }
-    CharCombSet ans =
-        {{'A','A'}, {'A','B'}, {'A','C'}, {'B','B'}, {'B','C'}, {'C','C'}};
-    REQUIRE( ans == sc );
+    "[combinations_with_replacement]") {
+  std::string s{"ABC"};
+  CharCombSet sc;
+  for (auto v : combinations_with_replacement(s, 2)) {
+    sc.emplace_back(std::begin(v), std::end(v));
+  }
+  CharCombSet ans = {
+      {'A', 'A'}, {'A', 'B'}, {'A', 'C'}, {'B', 'B'}, {'B', 'C'}, {'C', 'C'}};
+  REQUIRE(ans == sc);
 }
 
 TEST_CASE("combinations_with_replacement: iterators can be compared",
-        "[combinations_with_replacement]") {
-    std::string s{"ABCD"};
-    auto c = combinations_with_replacement(s, 2);
-    auto it = std::begin(c);
-    REQUIRE( it == std::begin(c) );
-    REQUIRE_FALSE( it != std::begin(c) );
-    ++it;
-    REQUIRE( it != std::begin(c) );
-    REQUIRE_FALSE( it == std::begin(c) );
+    "[combinations_with_replacement]") {
+  std::string s{"ABCD"};
+  auto c = combinations_with_replacement(s, 2);
+  auto it = std::begin(c);
+  REQUIRE(it == std::begin(c));
+  REQUIRE_FALSE(it != std::begin(c));
+  ++it;
+  REQUIRE(it != std::begin(c));
+  REQUIRE_FALSE(it == std::begin(c));
 }
 
 TEST_CASE("combinations_with_replacement: big size is no problem",
-        "[combinations_with_replacement]") {
-    std::string s{"AB"};
-    CharCombSet sc;
-    for (auto v : combinations_with_replacement(s, 3)) {
-        sc.emplace_back(std::begin(v), std::end(v));
-    }
-    CharCombSet ans =
-        {{'A', 'A', 'A'}, {'A', 'A', 'B'}, {'A', 'B', 'B'}, {'B', 'B', 'B'}};
-    REQUIRE( ans == sc );
+    "[combinations_with_replacement]") {
+  std::string s{"AB"};
+  CharCombSet sc;
+  for (auto v : combinations_with_replacement(s, 3)) {
+    sc.emplace_back(std::begin(v), std::end(v));
+  }
+  CharCombSet ans = {
+      {'A', 'A', 'A'}, {'A', 'A', 'B'}, {'A', 'B', 'B'}, {'B', 'B', 'B'}};
+  REQUIRE(ans == sc);
 }
-    
+
 TEST_CASE("combinations_with_replacement: 0 size is empty",
-        "[combinations_with_replacement]") {
-    std::string s{"A"};
-    auto cwr = combinations_with_replacement(s, 0);
-    REQUIRE( std::begin(cwr) == std::end(cwr) );
+    "[combinations_with_replacement]") {
+  std::string s{"A"};
+  auto cwr = combinations_with_replacement(s, 0);
+  REQUIRE(std::begin(cwr) == std::end(cwr));
 }
 
 TEST_CASE("combinations_with_replacement: operator->",
-        "[combinations_with_replacement]") {
-    std::string s{"ABCD"};
-    auto c = combinations_with_replacement(s, 2);
-    auto it = std::begin(c);
-    REQUIRE( it->size() == 2 );
+    "[combinations_with_replacement]") {
+  std::string s{"ABCD"};
+  auto c = combinations_with_replacement(s, 2);
+  auto it = std::begin(c);
+  REQUIRE(it->size() == 2);
 }
 
 TEST_CASE("combinations_with_replacement: binds to lvalues, moves rvalues",
-        "[combinations_with_replacement]") {
-    BasicIterable<char> bi{'x', 'y', 'z'};
-    SECTION("binds to lvalues") {
-        combinations_with_replacement(bi, 1);
-        REQUIRE_FALSE( bi.was_moved_from() );
-    }
-    SECTION("moves rvalues") {
-        combinations_with_replacement(std::move(bi), 1);
-        REQUIRE( bi.was_moved_from() );
-    }
+    "[combinations_with_replacement]") {
+  BasicIterable<char> bi{'x', 'y', 'z'};
+  SECTION("binds to lvalues") {
+    combinations_with_replacement(bi, 1);
+    REQUIRE_FALSE(bi.was_moved_from());
+  }
+  SECTION("moves rvalues") {
+    combinations_with_replacement(std::move(bi), 1);
+    REQUIRE(bi.was_moved_from());
+  }
 }
 
-TEST_CASE("combinations_with_replacement: "
-        "doesn't move or copy elements of iterable",
-        "[combinations_with_replacement]") {
-    constexpr itertest::SolidInt arr[] = {{6}, {7}, {8}};
-    for (auto&& i : combinations_with_replacement(arr, 1)) {
-        (void)i;
-    }
+TEST_CASE(
+    "combinations_with_replacement: "
+    "doesn't move or copy elements of iterable",
+    "[combinations_with_replacement]") {
+  constexpr itertest::SolidInt arr[] = {{6}, {7}, {8}};
+  for (auto&& i : combinations_with_replacement(arr, 1)) {
+    (void)i;
+  }
 }
 
 TEST_CASE("combinations_with_replacement: iterator meets requirements",
-        "[combinations_with_replacement]") {
-    std::string s{"abc"};
-    auto c = combinations_with_replacement(s, 1);
-    REQUIRE( itertest::IsIterator<decltype(std::begin(c))>::value );
-    auto&& row = *std::begin(c);
-    REQUIRE( itertest::IsIterator<decltype(std::begin(row))>::value );
+    "[combinations_with_replacement]") {
+  std::string s{"abc"};
+  auto c = combinations_with_replacement(s, 1);
+  REQUIRE(itertest::IsIterator<decltype(std::begin(c))>::value);
+  auto&& row = *std::begin(c);
+  REQUIRE(itertest::IsIterator<decltype(std::begin(row))>::value);
+}
+
+template <typename T>
+using ImpT = decltype(combinations_with_replacement(std::declval<T>(), 1));
+TEST_CASE("combinations_with_replacement: has correct ctor and assign ops",
+    "[combinations_with_replacement]") {
+  REQUIRE(itertest::IsMoveConstructibleOnly<ImpT<std::string&>>::value);
+  REQUIRE(itertest::IsMoveConstructibleOnly<ImpT<std::string>>::value);
 }

From bc0efea91bcf1828c624b3e081e15f81db47b0e7 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 6 Sep 2015 23:22:27 -0700
Subject: [PATCH 1321/1866] tests compress impl has move ctor only

---
 test/test_compress.cpp | 156 ++++++++++++++++++++++-------------------
 1 file changed, 82 insertions(+), 74 deletions(-)

diff --git a/test/test_compress.cpp b/test/test_compress.cpp
index 1152b60a..9a0c30b2 100644
--- a/test/test_compress.cpp
+++ b/test/test_compress.cpp
@@ -15,124 +15,132 @@ using itertest::BasicIterable;
 using Vec = const std::vector<int>;
 
 TEST_CASE("compress: alternating", "[compress]") {
-    std::vector<int> ivec{1, 2, 3, 4, 5, 6};
-    std::vector<bool> bvec{true, false, true, false, true, false};
-    auto c = compress(ivec, bvec);
-    Vec v(std::begin(c), std::end(c));
-    Vec vc = {1,3,5};
+  std::vector<int> ivec{1, 2, 3, 4, 5, 6};
+  std::vector<bool> bvec{true, false, true, false, true, false};
+  auto c = compress(ivec, bvec);
+  Vec v(std::begin(c), std::end(c));
+  Vec vc = {1, 3, 5};
 
-    REQUIRE( v  == vc );
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("compress: consecutive falses", "[compress]") {
-    std::vector<int> ivec{1, 2, 3, 4, 5};
-    std::vector<bool> bvec{true, false, false, false, true};
-    auto c = compress(ivec, bvec);
-    Vec v(std::begin(c), std::end(c));
-    Vec vc = {1,5};
+  std::vector<int> ivec{1, 2, 3, 4, 5};
+  std::vector<bool> bvec{true, false, false, false, true};
+  auto c = compress(ivec, bvec);
+  Vec v(std::begin(c), std::end(c));
+  Vec vc = {1, 5};
 
-    REQUIRE( v == vc );
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("compress: consecutive trues", "[compress]") {
-    std::vector<int> ivec{1, 2, 3, 4, 5};
-    std::vector<bool> bvec{false, true, true, true, false};
-    auto c = compress(ivec, bvec);
-    Vec v(std::begin(c), std::end(c));
-    Vec vc = {2,3,4};
+  std::vector<int> ivec{1, 2, 3, 4, 5};
+  std::vector<bool> bvec{false, true, true, true, false};
+  auto c = compress(ivec, bvec);
+  Vec v(std::begin(c), std::end(c));
+  Vec vc = {2, 3, 4};
 
-    REQUIRE( v == vc );
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("compress: all true", "[compress]") {
-    std::vector<int> ivec{1, 2, 3, 4, 5};
-    std::vector<bool> bvec(ivec.size(), true);
-    auto c = compress(ivec, bvec);
-    Vec v(std::begin(c), std::end(c));
+  std::vector<int> ivec{1, 2, 3, 4, 5};
+  std::vector<bool> bvec(ivec.size(), true);
+  auto c = compress(ivec, bvec);
+  Vec v(std::begin(c), std::end(c));
 
-    REQUIRE( v == ivec );
+  REQUIRE(v == ivec);
 }
 
 TEST_CASE("compress: all false", "[compress]") {
-    std::vector<int> ivec{1, 2, 3, 4, 5};
-    std::vector<bool> bvec(ivec.size(), false);
-    auto c = compress(ivec, bvec);
-    REQUIRE( std::begin(c) == std::end(c) );
+  std::vector<int> ivec{1, 2, 3, 4, 5};
+  std::vector<bool> bvec(ivec.size(), false);
+  auto c = compress(ivec, bvec);
+  REQUIRE(std::begin(c) == std::end(c));
 }
 
 TEST_CASE("compress: operator->", "[compress") {
-    std::vector<std::string> svec = {"a", "abc", "abcde"};
-    std::vector<bool> bvec = {false, false, true};
-    auto c = compress(svec, bvec);
-    auto it = std::begin(c);
-    REQUIRE( it->size() == 5 );
+  std::vector<std::string> svec = {"a", "abc", "abcde"};
+  std::vector<bool> bvec = {false, false, true};
+  auto c = compress(svec, bvec);
+  auto it = std::begin(c);
+  REQUIRE(it->size() == 5);
 }
 
-
 TEST_CASE("compress: binds to lvalues, moves rvalues", "[compress]") {
-    BasicIterable<char> bi{'x', 'y', 'z'};
-    std::vector<bool> bl{true, true, true};
-    SECTION("binds to lvalues") {
-        compress(bi, bl);
-        REQUIRE_FALSE( bi.was_moved_from() );
-    }
-    SECTION("moves rvalues") {
-        compress(std::move(bi), bl);
-        REQUIRE( bi.was_moved_from() );
-    }
+  BasicIterable<char> bi{'x', 'y', 'z'};
+  std::vector<bool> bl{true, true, true};
+  SECTION("binds to lvalues") {
+    compress(bi, bl);
+    REQUIRE_FALSE(bi.was_moved_from());
+  }
+  SECTION("moves rvalues") {
+    compress(std::move(bi), bl);
+    REQUIRE(bi.was_moved_from());
+  }
 }
 
 struct BoolLike {
-    public:
-        bool state;
-        explicit operator bool() const {
-            return this->state;
-        }
+ public:
+  bool state;
+  explicit operator bool() const {
+    return this->state;
+  }
 };
 
 TEST_CASE("compress: workds with truthy and falsey values", "[compress]") {
-    std::vector<BoolLike> bvec{{true}, {false}, {true}, {false}};
+  std::vector<BoolLike> bvec{{true}, {false}, {true}, {false}};
 
-    Vec ivec{1,2,3,4};
+  Vec ivec{1, 2, 3, 4};
 
-    auto c = compress(ivec, bvec);
-    Vec v(std::begin(c), std::end(c));
+  auto c = compress(ivec, bvec);
+  Vec v(std::begin(c), std::end(c));
 
-    Vec vc = {1,3};
-    REQUIRE( v == vc );
+  Vec vc = {1, 3};
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("compress: terminates on shorter selectors", "[compress]") {
-    std::vector<int> ivec{1, 2, 3, 4, 5};
-    std::vector<bool> bvec{true};
-    auto c = compress(ivec, bvec);
-    REQUIRE( std::distance(std::begin(c), std::end(c)) == 1 );
+  std::vector<int> ivec{1, 2, 3, 4, 5};
+  std::vector<bool> bvec{true};
+  auto c = compress(ivec, bvec);
+  REQUIRE(std::distance(std::begin(c), std::end(c)) == 1);
 }
 
 TEST_CASE("compress: terminates on shorter data", "[compress]") {
-    std::vector<int> ivec{1};
-    std::vector<bool> bvec{true, true, true, true, true};
-    auto c = compress(ivec, bvec);
-    REQUIRE( std::distance(std::begin(c), std::end(c)) == 1 );
+  std::vector<int> ivec{1};
+  std::vector<bool> bvec{true, true, true, true, true};
+  auto c = compress(ivec, bvec);
+  REQUIRE(std::distance(std::begin(c), std::end(c)) == 1);
 }
 
 TEST_CASE("compress: nothing on empty selectors", "[compress]") {
-    std::vector<int> ivec{1,2,3};
-    std::vector<bool> bvec{};
-    auto c = compress(ivec, bvec);
-    REQUIRE( std::begin(c) == std::end(c) );
+  std::vector<int> ivec{1, 2, 3};
+  std::vector<bool> bvec{};
+  auto c = compress(ivec, bvec);
+  REQUIRE(std::begin(c) == std::end(c));
 }
 
 TEST_CASE("compress: nothing on empty data", "[compress]") {
-    std::vector<int> ivec{};
-    std::vector<bool> bvec{true, true, true};
-    auto c = compress(ivec, bvec);
-    REQUIRE( std::begin(c) == std::end(c) );
+  std::vector<int> ivec{};
+  std::vector<bool> bvec{true, true, true};
+  auto c = compress(ivec, bvec);
+  REQUIRE(std::begin(c) == std::end(c));
 }
 
 TEST_CASE("compress: iterator meets requirements", "[compress]") {
-    std::string s{};
-    std::vector<bool> bv;
-    auto c = compress(s, bv);
-    REQUIRE( itertest::IsIterator<decltype(std::begin(c))>::value );
+  std::string s{};
+  std::vector<bool> bv;
+  auto c = compress(s, bv);
+  REQUIRE(itertest::IsIterator<decltype(std::begin(c))>::value);
+}
+
+template <typename T, typename U>
+using ImpT = decltype(compress(std::declval<T>(), std::declval<U>()));
+TEST_CASE("compress: has correct ctor and assign ops", "[compress]") {
+  using T1 = ImpT<std::string&, std::vector<bool>&>;
+  using T2 = ImpT<std::string, std::vector<bool>>;
+  REQUIRE(itertest::IsMoveConstructibleOnly<T1>::value);
+  REQUIRE(itertest::IsMoveConstructibleOnly<T2>::value);
 }

From 8ac15c27cad164f8958442ea04d658d17b0e6098 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 6 Sep 2015 23:22:48 -0700
Subject: [PATCH 1322/1866] tests cycle impl has move ctor only

---
 test/test_cycle.cpp | 78 ++++++++++++++++++++++++---------------------
 1 file changed, 42 insertions(+), 36 deletions(-)

diff --git a/test/test_cycle.cpp b/test/test_cycle.cpp
index 5b09ab25..ea5bf3e7 100644
--- a/test/test_cycle.cpp
+++ b/test/test_cycle.cpp
@@ -11,55 +11,61 @@
 using iter::cycle;
 
 TEST_CASE("cycle: iterate twice", "[cycle]") {
-    std::vector<int> ns {2,4,6};
-    std::vector<int> v{};
-    std::size_t count = 0;
-    for (auto i : cycle(ns)) {
-        v.push_back(i);
-        ++count;
-        if (count == ns.size() * 2) break;
-    }
+  std::vector<int> ns{2, 4, 6};
+  std::vector<int> v{};
+  std::size_t count = 0;
+  for (auto i : cycle(ns)) {
+    v.push_back(i);
+    ++count;
+    if (count == ns.size() * 2) break;
+  }
 
-    auto vc = ns;
-    vc.insert(std::end(vc), std::begin(ns), std::end(ns));
-    REQUIRE( v == vc );
+  auto vc = ns;
+  vc.insert(std::end(vc), std::begin(ns), std::end(ns));
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("cycle: empty cycle terminates", "[cycle]") {
-    std::vector<int> ns;
-    auto c = cycle(ns);
-    std::vector<int> v(std::begin(c), std::end(c)); 
-    REQUIRE( v.empty() );
+  std::vector<int> ns;
+  auto c = cycle(ns);
+  std::vector<int> v(std::begin(c), std::end(c));
+  REQUIRE(v.empty());
 }
 
 TEST_CASE("cycle: binds to lvalues, moves rvalues", "[cycle]") {
-    itertest::BasicIterable<char> bi{'x', 'y', 'z'};
-    SECTION("binds to lvalues") {
-        cycle(bi);
-        REQUIRE_FALSE( bi.was_moved_from() );
-    }
-    SECTION("moves rvalues") {
-        cycle(std::move(bi));
-        REQUIRE( bi.was_moved_from() );
-    }
+  itertest::BasicIterable<char> bi{'x', 'y', 'z'};
+  SECTION("binds to lvalues") {
+    cycle(bi);
+    REQUIRE_FALSE(bi.was_moved_from());
+  }
+  SECTION("moves rvalues") {
+    cycle(std::move(bi));
+    REQUIRE(bi.was_moved_from());
+  }
 }
 
-TEST_CASE("cycle: doesn't move or copy elements of iterable",
-        "[cycle]") {
-    constexpr itertest::SolidInt arr[] = {{6}, {7}, {8}};
-    auto c = cycle(arr);
-    *std::begin(c);
+TEST_CASE("cycle: doesn't move or copy elements of iterable", "[cycle]") {
+  constexpr itertest::SolidInt arr[] = {{6}, {7}, {8}};
+  auto c = cycle(arr);
+  *std::begin(c);
 }
 
 TEST_CASE("cycle: iterator meets requirements", "[cycle]") {
-    std::string s{};
-    auto c = cycle(s);
-    REQUIRE( itertest::IsIterator<decltype(std::begin(c))>::value );
+  std::string s{};
+  auto c = cycle(s);
+  REQUIRE(itertest::IsIterator<decltype(std::begin(c))>::value);
 }
 
 TEST_CASE("cycle: arrow works", "[cycle]") {
-    std::vector<std::string> v = {"hello"};
-    auto c = cycle(v);
-    auto it = std::begin(c);
-    REQUIRE( it->size() == 5 );
+  std::vector<std::string> v = {"hello"};
+  auto c = cycle(v);
+  auto it = std::begin(c);
+  REQUIRE(it->size() == 5);
+}
+
+template <typename T>
+using ImpT = decltype(cycle(std::declval<T>()));
+TEST_CASE("cycle: has correct ctor and assign ops", "[cycle]") {
+  REQUIRE(itertest::IsMoveConstructibleOnly<ImpT<std::string&>>::value);
+  REQUIRE(itertest::IsMoveConstructibleOnly<ImpT<std::string>>::value);
 }

From eecb116676b48708bd88b447d3f37fba500a381e Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 6 Sep 2015 23:22:56 -0700
Subject: [PATCH 1323/1866] tests dropwhile impl has move ctor only

---
 test/test_dropwhile.cpp | 117 +++++++++++++++++++++-------------------
 1 file changed, 63 insertions(+), 54 deletions(-)

diff --git a/test/test_dropwhile.cpp b/test/test_dropwhile.cpp
index c0b1707d..a05e1048 100644
--- a/test/test_dropwhile.cpp
+++ b/test/test_dropwhile.cpp
@@ -13,87 +13,96 @@ using iter::dropwhile;
 using Vec = const std::vector<int>;
 
 TEST_CASE("dropwhile: skips initial elements", "[dropwhile]") {
-    Vec ns{1,2,3,4,5,6,7,8};
-    auto d = dropwhile([](int i){return i < 5; }, ns);
-    Vec v(std::begin(d), std::end(d));
-    Vec vc = {5,6,7,8};
-    REQUIRE( v == vc );
+  Vec ns{1, 2, 3, 4, 5, 6, 7, 8};
+  auto d = dropwhile([](int i) { return i < 5; }, ns);
+  Vec v(std::begin(d), std::end(d));
+  Vec vc = {5, 6, 7, 8};
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("dropwhile: doesn't skip anything if it shouldn't", "[dropwhile]") {
-    Vec ns {3,4,5,6};
-    auto d = dropwhile([](int i){return i < 3; }, ns);
-    Vec v(std::begin(d), std::end(d));
-    Vec vc = {3,4,5,6};
-    REQUIRE( v == vc );
+  Vec ns{3, 4, 5, 6};
+  auto d = dropwhile([](int i) { return i < 3; }, ns);
+  Vec v(std::begin(d), std::end(d));
+  Vec vc = {3, 4, 5, 6};
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("dropwhile: skips all elements when all are true under predicate",
-        "[dropwhile]") {
-    Vec ns {3,4,5,6};
-    auto d = dropwhile([](int i){return i != 0; }, ns);
-    REQUIRE( std::begin(d) == std::end(d) );
+    "[dropwhile]") {
+  Vec ns{3, 4, 5, 6};
+  auto d = dropwhile([](int i) { return i != 0; }, ns);
+  REQUIRE(std::begin(d) == std::end(d));
 }
 
 TEST_CASE("dropwhile: empty case is empty", "[dropwhile]") {
-    Vec ns{};
-    auto d = dropwhile([](int i){return i != 0; }, ns);
-    REQUIRE( std::begin(d) == std::end(d) );
+  Vec ns{};
+  auto d = dropwhile([](int i) { return i != 0; }, ns);
+  REQUIRE(std::begin(d) == std::end(d));
 }
 
 TEST_CASE("dropwhile: only drops from beginning", "[dropwhile]") {
-    Vec ns {1,2,3,4,5,6,5,4,3,2,1};
-    auto d = dropwhile([](int i){return i < 5; }, ns);
-    Vec v(std::begin(d), std::end(d));
-    Vec vc = {5,6,5,4,3,2,1};
-    REQUIRE( v == vc );
+  Vec ns{1, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1};
+  auto d = dropwhile([](int i) { return i < 5; }, ns);
+  Vec v(std::begin(d), std::end(d));
+  Vec vc = {5, 6, 5, 4, 3, 2, 1};
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("dropwhile: operator->", "[dropwhile]") {
-    std::vector<std::string> vs = {"a", "ab", "abcdef", "abcdefghi"};
-    auto d = dropwhile(
-            [](const std::string& str) { return str.size() < 3; }, vs);
-    auto it = std::begin(d);
-    REQUIRE( it->size() == 6 );
+  std::vector<std::string> vs = {"a", "ab", "abcdef", "abcdefghi"};
+  auto d = dropwhile([](const std::string& str) { return str.size() < 3; }, vs);
+  auto it = std::begin(d);
+  REQUIRE(it->size() == 6);
 }
 
 namespace {
-    int less_than_five(int i) {
-        return i < 5;
-    }
+  int less_than_five(int i) {
+    return i < 5;
+  }
 }
 
 TEST_CASE("dropwhile: works with function pointer", "[dropwhile]") {
-    Vec ns{1,2,3,4,5,6,7,8};
-    auto d = dropwhile(less_than_five, ns);
-    Vec v(std::begin(d), std::end(d));
-    Vec vc = {5,6,7,8};
-    REQUIRE( v == vc );
+  Vec ns{1, 2, 3, 4, 5, 6, 7, 8};
+  auto d = dropwhile(less_than_five, ns);
+  Vec v(std::begin(d), std::end(d));
+  Vec vc = {5, 6, 7, 8};
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("dropwhile: binds to lvalues, moves rvalues", "[dropwhile]") {
-    itertest::BasicIterable<int> bi{1,2,3,4};
-    SECTION("binds to lvalues") {
-        dropwhile(less_than_five, bi);
-        REQUIRE_FALSE( bi.was_moved_from() );
-    }
-    SECTION("moves rvalues") {
-        dropwhile(less_than_five, std::move(bi));
-        REQUIRE( bi.was_moved_from() );
-    }
+  itertest::BasicIterable<int> bi{1, 2, 3, 4};
+  SECTION("binds to lvalues") {
+    dropwhile(less_than_five, bi);
+    REQUIRE_FALSE(bi.was_moved_from());
+  }
+  SECTION("moves rvalues") {
+    dropwhile(less_than_five, std::move(bi));
+    REQUIRE(bi.was_moved_from());
+  }
 }
 
-TEST_CASE("dropwhile: doesn't move or copy elements of iterable",
-        "[dropwhile]") {
-    constexpr itertest::SolidInt arr[] = {{6}, {7}, {8}};
-    for (auto&& i : dropwhile(
-                [](const itertest::SolidInt&){return false;} , arr)) {
-        (void)i;
-    }
+TEST_CASE(
+    "dropwhile: doesn't move or copy elements of iterable", "[dropwhile]") {
+  constexpr itertest::SolidInt arr[] = {{6}, {7}, {8}};
+  for (auto&& i :
+      dropwhile([](const itertest::SolidInt&) { return false; }, arr)) {
+    (void)i;
+  }
 }
 
 TEST_CASE("dropwhile: iterator meets requirements", "[dropwhile]") {
-    std::string s{};
-    auto c = dropwhile([]{return true;}, s);
-    REQUIRE( itertest::IsIterator<decltype(std::begin(c))>::value );
+  std::string s{};
+  auto c = dropwhile([] { return true; }, s);
+  REQUIRE(itertest::IsIterator<decltype(std::begin(c))>::value);
+}
+
+template <typename T, typename U>
+using ImpT = decltype(dropwhile(std::declval<T>(), std::declval<U>()));
+TEST_CASE("dropwhile: has correct ctor and assign ops", "[dropwhile]") {
+  using T1 = ImpT<bool (*)(char c), std::string&>;
+  auto lam = [](char) { return false; };
+  using T2 = ImpT<decltype(lam), std::string>;
+  REQUIRE(itertest::IsMoveConstructibleOnly<T1>::value);
+  REQUIRE(itertest::IsMoveConstructibleOnly<T2>::value);
 }

From 7ca3c7b15b51f9afc96906eec5ed710691197a09 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 6 Sep 2015 23:23:13 -0700
Subject: [PATCH 1324/1866] tests enumerate impl has move ctor only

---
 test/test_enumerate.cpp | 139 +++++++++++++++++++++-------------------
 1 file changed, 73 insertions(+), 66 deletions(-)

diff --git a/test/test_enumerate.cpp b/test/test_enumerate.cpp
index 6f25b3bd..778cce39 100644
--- a/test/test_enumerate.cpp
+++ b/test/test_enumerate.cpp
@@ -9,12 +9,12 @@
 #include <sstream>
 
 namespace Catch {
-template <typename A, typename B>
-std::string toString( const std::pair<A, B>& p) {
+  template <typename A, typename B>
+  std::string toString(const std::pair<A, B>& p) {
     std::ostringstream oss;
     oss << '{' << p.first << ", " << p.second << '}';
     return oss.str();
-}
+  }
 }
 
 #include "catch.hpp"
@@ -26,26 +26,26 @@ using itertest::BasicIterable;
 using itertest::SolidInt;
 
 TEST_CASE("Basic Functioning enumerate", "[enumerate]") {
-    std::string str = "abc";
-    auto e = enumerate(str);
-    Vec v(std::begin(e), std::end(e));
-    Vec vc{{0, 'a'}, {1, 'b'}, {2, 'c'}};
+  std::string str = "abc";
+  auto e = enumerate(str);
+  Vec v(std::begin(e), std::end(e));
+  Vec vc{{0, 'a'}, {1, 'b'}, {2, 'c'}};
 
-    REQUIRE( v == vc );
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("Empty enumerate", "[enumerate]") {
-    std::string emp{};
-    auto e = enumerate(emp);
-    REQUIRE( std::begin(e) == std::end(e) );
+  std::string emp{};
+  auto e = enumerate(emp);
+  REQUIRE(std::begin(e) == std::end(e));
 }
 
 TEST_CASE("Postfix ++ enumerate", "[enumerate]") {
-    std::string s{"amz"};
-    auto e = enumerate(s);
-    auto it = std::begin(e);
-    it++;
-    REQUIRE( (*it).first == 1 );
+  std::string s{"amz"};
+  auto e = enumerate(s);
+  auto it = std::begin(e);
+  it++;
+  REQUIRE((*it).first == 1);
 }
 
 TEST_CASE("enumerate: with starting value", "[enumerate]") {
@@ -54,85 +54,92 @@ TEST_CASE("enumerate: with starting value", "[enumerate]") {
   Vec v(std::begin(e), std::end(e));
   Vec vc{{5, 'h'}, {6, 'e'}, {7, 'y'}};
 
-  REQUIRE( v == vc );
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("Modifications through enumerate affect container", "[enumerate]") {
-    std::vector<int> v{1, 2, 3, 4};
-    std::vector<int> vc(v.size(), -1);
-    for (auto&& p : enumerate(v)){
-        p.second = -1;
-    }
+  std::vector<int> v{1, 2, 3, 4};
+  std::vector<int> vc(v.size(), -1);
+  for (auto&& p : enumerate(v)) {
+    p.second = -1;
+  }
 
-    REQUIRE( v == vc );
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("enumerate with static array works", "[enumerate]") {
-    char arr[] = {'w', 'x', 'y'};
+  char arr[] = {'w', 'x', 'y'};
 
-    SECTION("Conversion to vector") {
-        auto e = enumerate(arr);
-        Vec v(std::begin(e), std::end(e));
-        Vec vc{{0, 'w'}, {1, 'x'}, {2, 'y'}};
-        REQUIRE( v == vc );
-    }
+  SECTION("Conversion to vector") {
+    auto e = enumerate(arr);
+    Vec v(std::begin(e), std::end(e));
+    Vec vc{{0, 'w'}, {1, 'x'}, {2, 'y'}};
+    REQUIRE(v == vc);
+  }
 
-    SECTION("Modification through enumerate") {
-        for (auto&& p : enumerate(arr)) {
-            p.second = 'z';
-        }
-        std::vector<char> v(std::begin(arr), std::end(arr));
-        decltype(v) vc(v.size(), 'z');
-        REQUIRE( v == vc );
+  SECTION("Modification through enumerate") {
+    for (auto&& p : enumerate(arr)) {
+      p.second = 'z';
     }
+    std::vector<char> v(std::begin(arr), std::end(arr));
+    decltype(v) vc(v.size(), 'z');
+    REQUIRE(v == vc);
+  }
 }
 
 TEST_CASE("initializer_list works", "[enumerate]") {
-    auto e = enumerate({'a', 'b', 'c'});
-    Vec v(std::begin(e), std::end(e));
-    Vec vc{{0, 'a'}, {1, 'b'}, {2, 'c'}};
-    REQUIRE( v == vc );
+  auto e = enumerate({'a', 'b', 'c'});
+  Vec v(std::begin(e), std::end(e));
+  Vec vc{{0, 'a'}, {1, 'b'}, {2, 'c'}};
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("binds reference when it should", "[enumerate]") {
-    BasicIterable<char> bi{'x', 'y', 'z'};
-    auto e = enumerate(bi);
-    (void)e;
-    REQUIRE_FALSE( bi.was_moved_from() );
+  BasicIterable<char> bi{'x', 'y', 'z'};
+  auto e = enumerate(bi);
+  (void)e;
+  REQUIRE_FALSE(bi.was_moved_from());
 }
 
 TEST_CASE("moves rvalues into enumerable object", "[enumerate]") {
-    BasicIterable<char> bi{'x', 'y', 'z'};
-    auto e = enumerate(std::move(bi));
-    REQUIRE( bi.was_moved_from());
-    (void)e;
+  BasicIterable<char> bi{'x', 'y', 'z'};
+  auto e = enumerate(std::move(bi));
+  REQUIRE(bi.was_moved_from());
+  (void)e;
 }
 
 TEST_CASE("enumerate: operator->", "[enumerate]") {
-    std::vector<int> ns = {50, 60, 70};
-    auto e = enumerate(ns);
-    auto it = std::begin(e);
-    REQUIRE( it->first == 0 );
-    REQUIRE( it->second == 50 );
+  std::vector<int> ns = {50, 60, 70};
+  auto e = enumerate(ns);
+  auto it = std::begin(e);
+  REQUIRE(it->first == 0);
+  REQUIRE(it->second == 50);
 }
 
 TEST_CASE("Works with const iterable", "[enumerate]") {
-    const std::string s{"ace"};
-    auto e = enumerate(s);
-    Vec v(std::begin(e), std::end(e));
-    Vec vc{{0, 'a'}, {1, 'c'}, {2, 'e'}};
-    REQUIRE( v == vc );
+  const std::string s{"ace"};
+  auto e = enumerate(s);
+  Vec v(std::begin(e), std::end(e));
+  Vec vc{{0, 'a'}, {1, 'c'}, {2, 'e'}};
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("Doesn't move or copy elements of iterable", "[enumerate]") {
-    constexpr SolidInt arr[] = {{6}, {7}, {8}};
-    for (auto&& i : enumerate(arr)) {
-        (void)i;
-    }
+  constexpr SolidInt arr[] = {{6}, {7}, {8}};
+  for (auto&& i : enumerate(arr)) {
+    (void)i;
+  }
 }
 
 TEST_CASE("enumerate: iterator meets requirements", "[enumerate]") {
-    std::string s{};
-    auto c = enumerate(s);
-    REQUIRE( itertest::IsIterator<decltype(std::begin(c))>::value );
+  std::string s{};
+  auto c = enumerate(s);
+  REQUIRE(itertest::IsIterator<decltype(std::begin(c))>::value);
+}
+
+template <typename T>
+using ImpT = decltype(enumerate(std::declval<T>()));
+TEST_CASE("enumerate: has correct ctor and assign ops", "[enumerate]") {
+  REQUIRE(itertest::IsMoveConstructibleOnly<ImpT<std::string&>>::value);
+  REQUIRE(itertest::IsMoveConstructibleOnly<ImpT<std::string>>::value);
 }

From c2c99b65c4757dfc07e258afdcfbab3bd4857a4e Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 6 Sep 2015 23:23:25 -0700
Subject: [PATCH 1325/1866] tests filter impl has move ctor only

---
 test/test_filter.cpp | 164 +++++++++++++++++++++++--------------------
 1 file changed, 86 insertions(+), 78 deletions(-)

diff --git a/test/test_filter.cpp b/test/test_filter.cpp
index 650925f9..28ac6938 100644
--- a/test/test_filter.cpp
+++ b/test/test_filter.cpp
@@ -13,113 +13,121 @@ using iter::filter;
 using Vec = const std::vector<int>;
 
 namespace {
-    bool less_than_five(int i) {
-        return i < 5;
-    }
+  bool less_than_five(int i) {
+    return i < 5;
+  }
 
-    class LessThanValue {
-        private:
-            int compare_val;
+  class LessThanValue {
+   private:
+    int compare_val;
 
-        public:
-            LessThanValue(int v) : compare_val(v) { }
+   public:
+    LessThanValue(int v) : compare_val(v) {}
 
-            bool operator() (int i) {
-                return i < this->compare_val;
-            }
-    };
+    bool operator()(int i) {
+      return i < this->compare_val;
+    }
+  };
 }
 
 TEST_CASE("filter: handles different functor types", "[filter]") {
-    Vec ns = {1,2, 5,6, 3,1, 7, -1, 5};
-    Vec vc = {1,2,3,1,-1};
-    SECTION("with function pointer") {
-        auto f = filter(less_than_five, ns);
-        Vec v(std::begin(f), std::end(f));
-        REQUIRE( v == vc );
-    }
+  Vec ns = {1, 2, 5, 6, 3, 1, 7, -1, 5};
+  Vec vc = {1, 2, 3, 1, -1};
+  SECTION("with function pointer") {
+    auto f = filter(less_than_five, ns);
+    Vec v(std::begin(f), std::end(f));
+    REQUIRE(v == vc);
+  }
 
-    SECTION("with callable object") {
-        auto f = filter(LessThanValue{5}, ns);
-        Vec v(std::begin(f), std::end(f));
-        REQUIRE( v == vc );
-    }
+  SECTION("with callable object") {
+    auto f = filter(LessThanValue{5}, ns);
+    Vec v(std::begin(f), std::end(f));
+    REQUIRE(v == vc);
+  }
 
-    SECTION("with lambda") {
-        auto ltf = [](int i) {return i < 5;};
-        auto f = filter(ltf, ns);
-        Vec v(std::begin(f), std::end(f));
-        REQUIRE( v == vc );
-    }
+  SECTION("with lambda") {
+    auto ltf = [](int i) { return i < 5; };
+    auto f = filter(ltf, ns);
+    Vec v(std::begin(f), std::end(f));
+    REQUIRE(v == vc);
+  }
 }
 
 TEST_CASE("filter: iterator with lambda can be assigned", "[filter]") {
-    Vec ns{};
-    auto ltf = [](int i) {return i < 5;};
-    auto f = filter(ltf, ns);
-    auto it = std::begin(f);
-    it = std::begin(f);
+  Vec ns{};
+  auto ltf = [](int i) { return i < 5; };
+  auto f = filter(ltf, ns);
+  auto it = std::begin(f);
+  it = std::begin(f);
 }
 
 TEST_CASE("filter: using identity", "[filter]") {
-    Vec ns{0, 1, 2, 0, 3, 0, 0, 0, 4, 5, 0};
-    auto f = filter(ns);
-    Vec v(std::begin(f), std::end(f));
+  Vec ns{0, 1, 2, 0, 3, 0, 0, 0, 4, 5, 0};
+  auto f = filter(ns);
+  Vec v(std::begin(f), std::end(f));
 
-    Vec vc = {1,2,3,4,5};
-    REQUIRE( v == vc );
+  Vec vc = {1, 2, 3, 4, 5};
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("filter: binds to lvalues, moves rvales", "[filter]") {
-    itertest::BasicIterable<int> bi{1,2,3,4};
-
-    SECTION("one-arg binds to lvalues") {
-        filter(bi);
-        REQUIRE_FALSE(bi.was_moved_from());
-    }
-
-    SECTION("two-arg binds to lvalues") {
-        filter(less_than_five, bi);
-        REQUIRE_FALSE(bi.was_moved_from());
-    }
-
-    SECTION("one-arg moves rvalues") {
-        filter(std::move(bi));
-        REQUIRE(bi.was_moved_from());
-    }
-
-    SECTION("two-arg moves rvalues") {
-        filter(less_than_five, std::move(bi));
-        REQUIRE(bi.was_moved_from());
-    }
+  itertest::BasicIterable<int> bi{1, 2, 3, 4};
+
+  SECTION("one-arg binds to lvalues") {
+    filter(bi);
+    REQUIRE_FALSE(bi.was_moved_from());
+  }
+
+  SECTION("two-arg binds to lvalues") {
+    filter(less_than_five, bi);
+    REQUIRE_FALSE(bi.was_moved_from());
+  }
+
+  SECTION("one-arg moves rvalues") {
+    filter(std::move(bi));
+    REQUIRE(bi.was_moved_from());
+  }
+
+  SECTION("two-arg moves rvalues") {
+    filter(less_than_five, std::move(bi));
+    REQUIRE(bi.was_moved_from());
+  }
 }
 
-
 TEST_CASE("filter: operator->", "[filter]") {
-    std::vector<std::string> vs = {"ab", "abc", "abcdef"};
-    auto f = filter([](const std::string& str) {return str.size() > 4;}, vs);
-    auto it = std::begin(f);
-    REQUIRE( it->size() == 6 );
+  std::vector<std::string> vs = {"ab", "abc", "abcdef"};
+  auto f = filter([](const std::string& str) { return str.size() > 4; }, vs);
+  auto it = std::begin(f);
+  REQUIRE(it->size() == 6);
 }
 
-
 TEST_CASE("filter: all elements fail predicate", "[filter]") {
-    Vec ns{10,20,30,40,50};
-    auto f = filter(less_than_five, ns);
+  Vec ns{10, 20, 30, 40, 50};
+  auto f = filter(less_than_five, ns);
 
-    REQUIRE( std::begin(f) == std::end(f) );
+  REQUIRE(std::begin(f) == std::end(f));
 }
 
 TEST_CASE("filter: doesn't move or copy elements of iterable", "[filter]") {
-    constexpr itertest::SolidInt arr[] = {{1}, {0}, {2}};
-    for (auto&& i : filter(
-                [](const itertest::SolidInt& si) {return si.getint();},arr)) {
-        (void)i;
-    }
+  constexpr itertest::SolidInt arr[] = {{1}, {0}, {2}};
+  for (auto&& i :
+      filter([](const itertest::SolidInt& si) { return si.getint(); }, arr)) {
+    (void)i;
+  }
 }
 
 TEST_CASE("filter: iterator meets requirements", "[filter]") {
-    std::string s{};
-    auto c = filter([]{return true;}, s);
-    REQUIRE( itertest::IsIterator<decltype(std::begin(c))>::value );
+  std::string s{};
+  auto c = filter([] { return true; }, s);
+  REQUIRE(itertest::IsIterator<decltype(std::begin(c))>::value);
+}
+
+template <typename T, typename U>
+using ImpT = decltype(filter(std::declval<T>(), std::declval<U>()));
+TEST_CASE("filter: has correct ctor and assign ops", "[filter]") {
+  using T1 = ImpT<bool (*)(char c), std::string&>;
+  auto lam = [](char) { return false; };
+  using T2 = ImpT<decltype(lam), std::string>;
+  REQUIRE(itertest::IsMoveConstructibleOnly<T1>::value);
+  REQUIRE(itertest::IsMoveConstructibleOnly<T2>::value);
 }

From ab005ea7c2a1769d2a1c948defe1d13bf66cd8d0 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 6 Sep 2015 23:23:37 -0700
Subject: [PATCH 1326/1866] tests filterfalse impl has move ctor only

---
 test/test_filterfalse.cpp | 134 ++++++++++++++++++++------------------
 1 file changed, 72 insertions(+), 62 deletions(-)

diff --git a/test/test_filterfalse.cpp b/test/test_filterfalse.cpp
index cb09d897..2116b30f 100644
--- a/test/test_filterfalse.cpp
+++ b/test/test_filterfalse.cpp
@@ -13,88 +13,98 @@ using iter::filterfalse;
 using Vec = const std::vector<int>;
 
 namespace {
-    bool less_than_five(int i) {
-        return i < 5;
-    }
+  bool less_than_five(int i) {
+    return i < 5;
+  }
 
-    class LessThanValue {
-        private:
-            int compare_val;
+  class LessThanValue {
+   private:
+    int compare_val;
 
-        public:
-            LessThanValue(int v) : compare_val(v) { }
+   public:
+    LessThanValue(int v) : compare_val(v) {}
 
-            bool operator() (int i) {
-                return i < this->compare_val;
-            }
-    };
+    bool operator()(int i) {
+      return i < this->compare_val;
+    }
+  };
 }
 
 TEST_CASE("filterfalse: handles different functor types", "[filterfalse]") {
-    Vec ns = {1,2, 5,6, 3,1, 7, -1, 5};
-    Vec vc = {5,6,7,5};
-    SECTION("with function pointer") {
-        auto f = filterfalse(less_than_five, ns);
-        Vec v(std::begin(f), std::end(f));
-        REQUIRE( v == vc );
-    }
+  Vec ns = {1, 2, 5, 6, 3, 1, 7, -1, 5};
+  Vec vc = {5, 6, 7, 5};
+  SECTION("with function pointer") {
+    auto f = filterfalse(less_than_five, ns);
+    Vec v(std::begin(f), std::end(f));
+    REQUIRE(v == vc);
+  }
 
-    SECTION("with callable object") {
-        auto f = filterfalse(LessThanValue{5}, ns);
-        Vec v(std::begin(f), std::end(f));
-        REQUIRE( v == vc );
-    }
+  SECTION("with callable object") {
+    auto f = filterfalse(LessThanValue{5}, ns);
+    Vec v(std::begin(f), std::end(f));
+    REQUIRE(v == vc);
+  }
 
-    SECTION("with lambda") {
-        auto ltf = [](int i) {return i < 5;};
-        auto f = filterfalse(ltf, ns);
-        Vec v(std::begin(f), std::end(f));
-        REQUIRE( v == vc );
-    }
+  SECTION("with lambda") {
+    auto ltf = [](int i) { return i < 5; };
+    auto f = filterfalse(ltf, ns);
+    Vec v(std::begin(f), std::end(f));
+    REQUIRE(v == vc);
+  }
 }
 
 TEST_CASE("filterfalse: using identity", "[filterfalse]") {
-    Vec ns{0, 1, 2, 0, 3, 0, 0, 0, 4, 5, 0};
-    auto f = filterfalse(ns);
-    Vec v(std::begin(f), std::end(f));
+  Vec ns{0, 1, 2, 0, 3, 0, 0, 0, 4, 5, 0};
+  auto f = filterfalse(ns);
+  Vec v(std::begin(f), std::end(f));
 
-    Vec vc = {0, 0, 0, 0, 0, 0};
-    REQUIRE( v == vc );
+  Vec vc = {0, 0, 0, 0, 0, 0};
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("filterfalse: binds to lvalues, moves rvales", "[filterfalse]") {
-    itertest::BasicIterable<int> bi{1,2,3,4};
-
-    SECTION("one-arg binds to lvalues") {
-        filterfalse(bi);
-        REQUIRE_FALSE(bi.was_moved_from());
-    }
-
-    SECTION("two-arg binds to lvalues") {
-        filterfalse(less_than_five, bi);
-        REQUIRE_FALSE(bi.was_moved_from());
-    }
-
-    SECTION("one-arg moves rvalues") {
-        filterfalse(std::move(bi));
-        REQUIRE(bi.was_moved_from());
-    }
-
-    SECTION("two-arg moves rvalues") {
-        filterfalse(less_than_five, std::move(bi));
-        REQUIRE(bi.was_moved_from());
-    }
+  itertest::BasicIterable<int> bi{1, 2, 3, 4};
+
+  SECTION("one-arg binds to lvalues") {
+    filterfalse(bi);
+    REQUIRE_FALSE(bi.was_moved_from());
+  }
+
+  SECTION("two-arg binds to lvalues") {
+    filterfalse(less_than_five, bi);
+    REQUIRE_FALSE(bi.was_moved_from());
+  }
+
+  SECTION("one-arg moves rvalues") {
+    filterfalse(std::move(bi));
+    REQUIRE(bi.was_moved_from());
+  }
+
+  SECTION("two-arg moves rvalues") {
+    filterfalse(less_than_five, std::move(bi));
+    REQUIRE(bi.was_moved_from());
+  }
 }
 
 TEST_CASE("filterfalse: all elements pass predicate", "[filterfalse]") {
-    Vec ns{0,1,2,3,4};
-    auto f = filterfalse(less_than_five, ns);
+  Vec ns{0, 1, 2, 3, 4};
+  auto f = filterfalse(less_than_five, ns);
 
-    REQUIRE( std::begin(f) == std::end(f) );
+  REQUIRE(std::begin(f) == std::end(f));
 }
 
 TEST_CASE("filterfalse: iterator meets requirements", "[filterfalse]") {
-    std::string s{};
-    auto c = filterfalse([]{return true;}, s);
-    REQUIRE( itertest::IsIterator<decltype(std::begin(c))>::value );
+  std::string s{};
+  auto c = filterfalse([] { return true; }, s);
+  REQUIRE(itertest::IsIterator<decltype(std::begin(c))>::value);
+}
+
+template <typename T, typename U>
+using ImpT = decltype(filterfalse(std::declval<T>(), std::declval<U>()));
+TEST_CASE("filterfalse: has correct ctor and assign ops", "[filterfalse]") {
+  using T1 = ImpT<bool (*)(char c), std::string&>;
+  auto lam = [](char) { return false; };
+  using T2 = ImpT<decltype(lam), std::string>;
+  REQUIRE(itertest::IsMoveConstructibleOnly<T1>::value);
+  REQUIRE(itertest::IsMoveConstructibleOnly<T2>::value);
 }

From 5078624588c8dc5c9992e7cf8a72cd7accae0ce4 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 6 Sep 2015 23:23:46 -0700
Subject: [PATCH 1327/1866] tests groupby impl has move ctor only

---
 test/test_groupby.cpp | 298 +++++++++++++++++++++---------------------
 1 file changed, 146 insertions(+), 152 deletions(-)

diff --git a/test/test_groupby.cpp b/test/test_groupby.cpp
index ad74be9d..1bbc7864 100644
--- a/test/test_groupby.cpp
+++ b/test/test_groupby.cpp
@@ -11,210 +11,204 @@
 using iter::groupby;
 
 namespace {
-    int length(const std::string& s) {
-        return s.size();
+  int length(const std::string& s) {
+    return s.size();
+  }
+
+  struct Sizer {
+    int operator()(const std::string& s) {
+      return s.size();
     }
+  };
 
-    struct Sizer {
-        int operator()(const std::string& s) {
-            return s.size();
-        }
-    };
-
-    const std::vector<std::string> vec = {
-        "hi", "ab", "ho",
-        "abc", "def",
-        "abcde", "efghi"
-    };
+  const std::vector<std::string> vec = {
+      "hi", "ab", "ho", "abc", "def", "abcde", "efghi"};
 }
 
 TEST_CASE("groupby: works with lambda, callable, and function pointer") {
-    std::vector<int> keys;
-    std::vector<std::vector<std::string>> groups;
-
-    SECTION("Function pointer") {
-        for (auto&& gb : groupby(vec, length)) {
-            keys.push_back(gb.first);
-            groups.emplace_back(std::begin(gb.second), std::end(gb.second));
-        }
+  std::vector<int> keys;
+  std::vector<std::vector<std::string>> groups;
+
+  SECTION("Function pointer") {
+    for (auto&& gb : groupby(vec, length)) {
+      keys.push_back(gb.first);
+      groups.emplace_back(std::begin(gb.second), std::end(gb.second));
     }
+  }
 
-    SECTION("Callable object") {
-        for (auto&& gb : groupby(vec, Sizer{})) {
-            keys.push_back(gb.first);
-            groups.emplace_back(std::begin(gb.second), std::end(gb.second));
-        }
+  SECTION("Callable object") {
+    for (auto&& gb : groupby(vec, Sizer{})) {
+      keys.push_back(gb.first);
+      groups.emplace_back(std::begin(gb.second), std::end(gb.second));
     }
+  }
 
-    SECTION("lambda function") {
-        for (auto&& gb : groupby(vec,
-                    [](const std::string& s){return s.size();})) {
-            keys.push_back(gb.first);
-            groups.emplace_back(std::begin(gb.second), std::end(gb.second));
-        }
+  SECTION("lambda function") {
+    for (auto&& gb :
+        groupby(vec, [](const std::string& s) { return s.size(); })) {
+      keys.push_back(gb.first);
+      groups.emplace_back(std::begin(gb.second), std::end(gb.second));
     }
+  }
 
-    const std::vector<int> kc = {2, 3, 5};
-    REQUIRE( keys == kc );
+  const std::vector<int> kc = {2, 3, 5};
+  REQUIRE(keys == kc);
 
-    const std::vector<std::vector<std::string>> gc = {
-        {"hi", "ab", "ho"},
-        {"abc", "def"},
-        {"abcde", "efghi"},
-    };
+  const std::vector<std::vector<std::string>> gc = {
+      {"hi", "ab", "ho"}, {"abc", "def"}, {"abcde", "efghi"},
+  };
 
-    REQUIRE( groups == gc );
+  REQUIRE(groups == gc);
 }
 
 TEST_CASE("groupby: groups can be skipped completely", "[groupby]") {
-    std::vector<int> keys;
-    std::vector<std::vector<std::string>> groups;
-    for (auto&& gb : groupby(vec, &length)) {
-        if (gb.first == 3) {
-            continue;
-        }
-        keys.push_back(gb.first);
-        groups.emplace_back(std::begin(gb.second), std::end(gb.second));
+  std::vector<int> keys;
+  std::vector<std::vector<std::string>> groups;
+  for (auto&& gb : groupby(vec, &length)) {
+    if (gb.first == 3) {
+      continue;
     }
+    keys.push_back(gb.first);
+    groups.emplace_back(std::begin(gb.second), std::end(gb.second));
+  }
 
-    const std::vector<int> kc = {2, 5};
-    REQUIRE( keys == kc );
+  const std::vector<int> kc = {2, 5};
+  REQUIRE(keys == kc);
 
-    const std::vector<std::vector<std::string>> gc = {
-        {"hi", "ab", "ho"},
-        {"abcde", "efghi"},
-    };
+  const std::vector<std::vector<std::string>> gc = {
+      {"hi", "ab", "ho"}, {"abcde", "efghi"},
+  };
 
-    REQUIRE( groups == gc );
+  REQUIRE(groups == gc);
 }
 
 TEST_CASE("groupby: groups can be skipped partially", "[groupby]") {
-    std::vector<int> keys;
-    std::vector<std::vector<std::string>> groups;
-    for (auto&& gb : groupby(vec, &length)) {
-        keys.push_back(gb.first);
-        if (gb.first == 3) {
-            std::vector<std::string> cut_short = {*std::begin(gb.second)};
-            groups.push_back(cut_short);
-        } else {
-            groups.emplace_back(std::begin(gb.second), std::end(gb.second));
-        }
+  std::vector<int> keys;
+  std::vector<std::vector<std::string>> groups;
+  for (auto&& gb : groupby(vec, &length)) {
+    keys.push_back(gb.first);
+    if (gb.first == 3) {
+      std::vector<std::string> cut_short = {*std::begin(gb.second)};
+      groups.push_back(cut_short);
+    } else {
+      groups.emplace_back(std::begin(gb.second), std::end(gb.second));
     }
+  }
 
-    const std::vector<int> kc = {2, 3, 5};
-    REQUIRE( keys == kc );
+  const std::vector<int> kc = {2, 3, 5};
+  REQUIRE(keys == kc);
 
-    const std::vector<std::vector<std::string>> gc = {
-        {"hi", "ab", "ho"},
-        {"abc"},
-        {"abcde", "efghi"},
-    };
+  const std::vector<std::vector<std::string>> gc = {
+      {"hi", "ab", "ho"}, {"abc"}, {"abcde", "efghi"},
+  };
 
-    REQUIRE( groups == gc );
+  REQUIRE(groups == gc);
 }
 
 TEST_CASE("groupby: single argument uses elements as keys", "[groupby]") {
-    std::vector<int> ivec = {5, 5, 6, 6, 19, 19, 19, 19, 69, 0, 10, 10};
-    std::vector<int> keys;
-    std::vector<std::vector<int>> groups;
-    for (auto&& gb : groupby(ivec)) {
-        keys.push_back(gb.first);
-        groups.emplace_back(std::begin(gb.second), std::end(gb.second));
-    }
-
-    const std::vector<int> kc = {5, 6, 19, 69, 0, 10};
-    REQUIRE( keys == kc );
-
-    std::vector<std::vector<int>> gc = {
-        {5, 5},
-        {6, 6},
-        {19, 19, 19, 19},
-        {69},
-        {0},
-        {10, 10},
-    };
-
-    REQUIRE( groups == gc );
+  std::vector<int> ivec = {5, 5, 6, 6, 19, 19, 19, 19, 69, 0, 10, 10};
+  std::vector<int> keys;
+  std::vector<std::vector<int>> groups;
+  for (auto&& gb : groupby(ivec)) {
+    keys.push_back(gb.first);
+    groups.emplace_back(std::begin(gb.second), std::end(gb.second));
+  }
+
+  const std::vector<int> kc = {5, 6, 19, 69, 0, 10};
+  REQUIRE(keys == kc);
+
+  std::vector<std::vector<int>> gc = {
+      {5, 5}, {6, 6}, {19, 19, 19, 19}, {69}, {0}, {10, 10},
+  };
+
+  REQUIRE(groups == gc);
 }
 
 TEST_CASE("groupby: empty iterable yields nothing", "[groupby]") {
-    std::vector<int> ivec{};
-    auto g = groupby(ivec);
-    REQUIRE( std::begin(g) == std::end(g) );
+  std::vector<int> ivec{};
+  auto g = groupby(ivec);
+  REQUIRE(std::begin(g) == std::end(g));
 }
 
 TEST_CASE("groupby: inner iterator (group) not used", "[groupby]") {
-    std::vector<int> keys;
-    for (auto&& gb : groupby(vec, length)) {
-        keys.push_back(gb.first);
-    }
-    
-    std::vector<int> kc = {2, 3, 5};
-    REQUIRE( keys == kc );
+  std::vector<int> keys;
+  for (auto&& gb : groupby(vec, length)) {
+    keys.push_back(gb.first);
+  }
+
+  std::vector<int> kc = {2, 3, 5};
+  REQUIRE(keys == kc);
 }
 
 TEST_CASE("groupby: doesn't double dereference", "[groupby]") {
-    itertest::InputIterable seq;
-    for (auto&& kg : groupby(seq, [](int i){return i < 3;})) {
-        for (auto&& e : kg.second) {
-            (void)e;
-        }
+  itertest::InputIterable seq;
+  for (auto&& kg : groupby(seq, [](int i) { return i < 3; })) {
+    for (auto&& e : kg.second) {
+      (void)e;
     }
+  }
 }
 
 TEST_CASE("grouby: iterator doesn't need to be dereferenced before advanced",
-        "[groupby]") {
-    std::vector<int> ns = {2, 4, 7};
-    auto g = groupby(ns);
-    auto it = std::begin(g);
-    ++it;
-    REQUIRE( (*it).first == 4 );
+    "[groupby]") {
+  std::vector<int> ns = {2, 4, 7};
+  auto g = groupby(ns);
+  auto it = std::begin(g);
+  ++it;
+  REQUIRE((*it).first == 4);
 }
 
-TEST_CASE("groupby: iterator can be dereferenced multiple times", "[groupby]"){
-    std::vector<int> ns = {2, 4, 7};
-    auto g = groupby(ns);
-    auto it = std::begin(g);
-    auto k1 = (*it).first;
-    auto k2 = (*it).first;
-    REQUIRE( k1 == k2 );
+TEST_CASE("groupby: iterator can be dereferenced multiple times", "[groupby]") {
+  std::vector<int> ns = {2, 4, 7};
+  auto g = groupby(ns);
+  auto it = std::begin(g);
+  auto k1 = (*it).first;
+  auto k2 = (*it).first;
+  REQUIRE(k1 == k2);
 }
 
-
-TEST_CASE("groupby: copy constructed iterators behave as expected",
-        "[groupby]") {
-    std::vector<int> ns = {2, 3, 4, 5};
-    auto g = groupby(ns);
-    auto it = std::begin(g);
-    REQUIRE( it->first == 2 );
-    {
-        auto it2 = it;
-        REQUIRE( it2->first == 2);
-        ++it;
-        REQUIRE( it->first == 3 );
-        REQUIRE( *std::begin(it->second) == 3 );
-    }
-    REQUIRE( it->first == 3 );
-    REQUIRE( *std::begin(it->second) == 3 );
+TEST_CASE(
+    "groupby: copy constructed iterators behave as expected", "[groupby]") {
+  std::vector<int> ns = {2, 3, 4, 5};
+  auto g = groupby(ns);
+  auto it = std::begin(g);
+  REQUIRE(it->first == 2);
+  {
+    auto it2 = it;
+    REQUIRE(it2->first == 2);
+    ++it;
+    REQUIRE(it->first == 3);
+    REQUIRE(*std::begin(it->second) == 3);
+  }
+  REQUIRE(it->first == 3);
+  REQUIRE(*std::begin(it->second) == 3);
 }
 
-
 TEST_CASE("groupby: operator-> on both iterator types", "[groupby]") {
-    std::vector<std::string> ns = {"a", "abc"};
-    auto g = groupby(ns, [](const std::string& str){return str.size();});
-    auto it = std::begin(g);
-    REQUIRE( it->first == 1 );
-    auto it2 = std::begin(it->second);
-    REQUIRE( it2->size() == 1 );
+  std::vector<std::string> ns = {"a", "abc"};
+  auto g = groupby(ns, [](const std::string& str) { return str.size(); });
+  auto it = std::begin(g);
+  REQUIRE(it->first == 1);
+  auto it2 = std::begin(it->second);
+  REQUIRE(it2->size() == 1);
 }
 
 TEST_CASE("groupby: iterator and groupiterator are correct", "[groupby]") {
-    std::string s{"abc"};
-    auto c = groupby(s);
-    auto it = std::begin(c);
-    REQUIRE( itertest::IsIterator<decltype(it)>::value );
-    auto&& gp = (*it).second;
-    auto it2 = std::begin(gp);
-    REQUIRE( itertest::IsIterator<decltype(it2)>::value );
+  std::string s{"abc"};
+  auto c = groupby(s);
+  auto it = std::begin(c);
+  REQUIRE(itertest::IsIterator<decltype(it)>::value);
+  auto&& gp = (*it).second;
+  auto it2 = std::begin(gp);
+  REQUIRE(itertest::IsIterator<decltype(it2)>::value);
+}
 
+template <typename T, typename U>
+using ImpT = decltype(groupby(std::declval<T>(), std::declval<U>()));
+TEST_CASE("groupby: has correct ctor and assign ops", "[groupby]") {
+  using T1 = ImpT<std::string&, bool (*)(char c)>;
+  auto lam = [](char) { return false; };
+  using T2 = ImpT<std::string, decltype(lam)>;
+  REQUIRE(itertest::IsMoveConstructibleOnly<T1>::value);
+  REQUIRE(itertest::IsMoveConstructibleOnly<T2>::value);
 }

From 2afd601714577bc900a2a1f6d9865b1a8df4e10a Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 6 Sep 2015 23:23:58 -0700
Subject: [PATCH 1328/1866] tests imap impl has move ctor only

---
 test/test_imap.cpp | 198 +++++++++++++++++++++++----------------------
 1 file changed, 103 insertions(+), 95 deletions(-)

diff --git a/test/test_imap.cpp b/test/test_imap.cpp
index 6911c0fa..634bc6c8 100644
--- a/test/test_imap.cpp
+++ b/test/test_imap.cpp
@@ -12,133 +12,141 @@ using iter::imap;
 using Vec = const std::vector<int>;
 
 namespace {
-    int plusone(int i) {
-        return i + 1;
+  int plusone(int i) {
+    return i + 1;
+  }
+
+  class PlusOner {
+   public:
+    int operator()(int i) {
+      return i + 1;
     }
+  };
 
-    class PlusOner {
-        public:
-            int operator()(int i) {
-                return i + 1;
-            }
-    };
-
-    int power(int b, int e) {
-        int acc = 1;
-        for (int i = 0; i < e; ++i) {
-            acc *= b;
-        }
-        return acc;
+  int power(int b, int e) {
+    int acc = 1;
+    for (int i = 0; i < e; ++i) {
+      acc *= b;
     }
+    return acc;
+  }
 }
 
 TEST_CASE("imap: works with lambda, callable, and function", "[imap]") {
-    Vec ns = {10, 20, 30};
-    SECTION("with lambda") {
-        auto im = imap([](int i) { return i + 1; }, ns);
-        Vec v(std::begin(im), std::end(im));
-        Vec vc = {11, 21, 31};
-        REQUIRE( v == vc );
-    }
-
-    SECTION("with function") {
-        auto im = imap(plusone, ns);
-        Vec v(std::begin(im), std::end(im));
-        Vec vc = {11, 21, 31};
-        REQUIRE( v == vc );
-    }
+  Vec ns = {10, 20, 30};
+  SECTION("with lambda") {
+    auto im = imap([](int i) { return i + 1; }, ns);
+    Vec v(std::begin(im), std::end(im));
+    Vec vc = {11, 21, 31};
+    REQUIRE(v == vc);
+  }
 
-    SECTION("with function") {
-        auto im = imap(PlusOner{}, ns);
-        Vec v(std::begin(im), std::end(im));
-        Vec vc = {11, 21, 31};
-        REQUIRE( v == vc );
-    }
+  SECTION("with function") {
+    auto im = imap(plusone, ns);
+    Vec v(std::begin(im), std::end(im));
+    Vec vc = {11, 21, 31};
+    REQUIRE(v == vc);
+  }
 
+  SECTION("with function") {
+    auto im = imap(PlusOner{}, ns);
+    Vec v(std::begin(im), std::end(im));
+    Vec vc = {11, 21, 31};
+    REQUIRE(v == vc);
+  }
 }
 
 TEST_CASE("imap: works with multiple sequences", "[imap]") {
-    Vec bases = {0, 1, 2, 3};
-    Vec exps = {1, 2, 3, 4};
+  Vec bases = {0, 1, 2, 3};
+  Vec exps = {1, 2, 3, 4};
 
-    auto im = imap(power, bases, exps);
-    Vec v(std::begin(im), std::end(im));
-    Vec vc = {0, 1, 8, 81};
+  auto im = imap(power, bases, exps);
+  Vec v(std::begin(im), std::end(im));
+  Vec vc = {0, 1, 8, 81};
 
-    REQUIRE( v == vc );
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("imap: terminates on shortest squence", "[imap]") {
-    Vec ns1 = {1, 2, 3, 4};
-    Vec ns2 = {2, 4, 6, 8, 10};
-    Vec vc = {3, 6, 9, 12};
-    SECTION("shortest sequence first") {
-        auto im = imap([](int a, int b){ return a + b; }, ns1, ns2);
-        Vec v(std::begin(im), std::end(im));
-        REQUIRE( v == vc );
-    }
-    SECTION("shortest sequence second") {
-        auto im = imap([](int a, int b){ return a + b; }, ns2, ns1);
-        Vec v(std::begin(im), std::end(im));
-        REQUIRE( v == vc );
-    }
+  Vec ns1 = {1, 2, 3, 4};
+  Vec ns2 = {2, 4, 6, 8, 10};
+  Vec vc = {3, 6, 9, 12};
+  SECTION("shortest sequence first") {
+    auto im = imap([](int a, int b) { return a + b; }, ns1, ns2);
+    Vec v(std::begin(im), std::end(im));
+    REQUIRE(v == vc);
+  }
+  SECTION("shortest sequence second") {
+    auto im = imap([](int a, int b) { return a + b; }, ns2, ns1);
+    Vec v(std::begin(im), std::end(im));
+    REQUIRE(v == vc);
+  }
 }
 
 TEST_CASE("imap: operator->", "[imap]") {
-    std::vector<std::string> vs = {"ab", "abcd", "abcdefg"};
-    {
-        auto m = imap([](std::string& s) { return s; }, vs);
-        auto it = std::begin(m);
-        REQUIRE( it->size() == 2 );
-    }
-
-    {
-        auto m = imap([](std::string& s) -> std::string& { return s; }, vs);
-        auto it = std::begin(m);
-        REQUIRE( it->size() == 2 );
-    }
+  std::vector<std::string> vs = {"ab", "abcd", "abcdefg"};
+  {
+    auto m = imap([](std::string& s) { return s; }, vs);
+    auto it = std::begin(m);
+    REQUIRE(it->size() == 2);
+  }
+
+  {
+    auto m = imap([](std::string& s) -> std::string& { return s; }, vs);
+    auto it = std::begin(m);
+    REQUIRE(it->size() == 2);
+  }
 }
 
-
 TEST_CASE("imap: empty sequence gives nothing", "[imap]") {
-    Vec v{};
-    auto im = imap(plusone, v);
-    REQUIRE( std::begin(im) == std::end(im) );
+  Vec v{};
+  auto im = imap(plusone, v);
+  REQUIRE(std::begin(im) == std::end(im));
 }
 
 TEST_CASE("imap: binds to lvalues, moves rvalues", "[imap]") {
-    itertest::BasicIterable<int> bi{1, 2};
-    SECTION("binds to lvalues") {
-        imap(plusone, bi);
-        REQUIRE_FALSE(bi.was_moved_from());
-    }
-
-    SECTION("moves rvalues") {
-        imap(plusone, std::move(bi));
-        REQUIRE(bi.was_moved_from());
-    }
+  itertest::BasicIterable<int> bi{1, 2};
+  SECTION("binds to lvalues") {
+    imap(plusone, bi);
+    REQUIRE_FALSE(bi.was_moved_from());
+  }
+
+  SECTION("moves rvalues") {
+    imap(plusone, std::move(bi));
+    REQUIRE(bi.was_moved_from());
+  }
 }
 
 TEST_CASE("imap: doesn't move or copy elements of iterable", "[imap]") {
-    constexpr itertest::SolidInt arr[] = {{1}, {0}, {2}};
-    for (auto&& i : imap([](const itertest::SolidInt& si){return si.getint();},
-                arr)) {
-        (void)i;
-    }
+  constexpr itertest::SolidInt arr[] = {{1}, {0}, {2}};
+  for (auto&& i :
+      imap([](const itertest::SolidInt& si) { return si.getint(); }, arr)) {
+    (void)i;
+  }
 }
 
 TEST_CASE("imap: postfix ++", "[imap]") {
-    Vec ns = {10, 20};
-    auto im = imap(plusone, ns);
-    auto it = std::begin(im);
-    it++;
-    REQUIRE( (*it) == 21 );
-    it++;
-    REQUIRE( it == std::end(im) );
+  Vec ns = {10, 20};
+  auto im = imap(plusone, ns);
+  auto it = std::begin(im);
+  it++;
+  REQUIRE((*it) == 21);
+  it++;
+  REQUIRE(it == std::end(im));
 }
 
 TEST_CASE("imap: iterator meets requirements", "[imap]") {
-    std::string s{};
-    auto c = imap([](char){return 1;}, s);
-    REQUIRE( itertest::IsIterator<decltype(std::begin(c))>::value );
+  std::string s{};
+  auto c = imap([](char) { return 1; }, s);
+  REQUIRE(itertest::IsIterator<decltype(std::begin(c))>::value);
+}
+
+template <typename T, typename U>
+using ImpT = decltype(imap(std::declval<T>(), std::declval<U>()));
+TEST_CASE("imap: has correct ctor and assign ops", "[imap]") {
+  using T1 = ImpT<bool (*)(char c), std::string&>;
+  auto lam = [](char) { return false; };
+  using T2 = ImpT<decltype(lam), std::string>;
+  REQUIRE(itertest::IsMoveConstructibleOnly<T1>::value);
+  REQUIRE(itertest::IsMoveConstructibleOnly<T2>::value);
 }

From c0bf33235145b89c390bc80bb22389fc8fbc23c6 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 6 Sep 2015 23:24:11 -0700
Subject: [PATCH 1329/1866] tests permutations impl has move ctor only

---
 test/test_permutations.cpp | 116 +++++++++++++++++++------------------
 1 file changed, 61 insertions(+), 55 deletions(-)

diff --git a/test/test_permutations.cpp b/test/test_permutations.cpp
index 2e012131..68fa24f9 100644
--- a/test/test_permutations.cpp
+++ b/test/test_permutations.cpp
@@ -12,79 +12,85 @@ using iter::permutations;
 using IntPermSet = std::multiset<std::vector<int>>;
 
 TEST_CASE("permutations: basic test, 3 element sequence", "[permutations]") {
-    const std::vector<int> ns = {1, 7, 9};
-    auto p = permutations(ns);
+  const std::vector<int> ns = {1, 7, 9};
+  auto p = permutations(ns);
 
-    IntPermSet v;
-    for (auto&& st : p) {
-        v.emplace(std::begin(st), std::end(st));
-    }
+  IntPermSet v;
+  for (auto&& st : p) {
+    v.emplace(std::begin(st), std::end(st));
+  }
 
-    const IntPermSet vc =
-        {{1, 7, 9}, {1, 9, 7}, {7, 1, 9}, {7, 9, 1}, {9, 1, 7}, {9, 7, 1}};
-    REQUIRE( v == vc );
+  const IntPermSet vc = {
+      {1, 7, 9}, {1, 9, 7}, {7, 1, 9}, {7, 9, 1}, {9, 1, 7}, {9, 7, 1}};
+  REQUIRE(v == vc);
 }
 
-TEST_CASE("permutations: empty sequence has one empy permutation",
-        "[permutations]") {
-    const std::vector<int> ns{};
-    auto p = permutations(ns);
-    auto it = std::begin(p);
-    REQUIRE( (*it).empty() );
-    it++;
-    REQUIRE( it == std::end(p) );
+TEST_CASE(
+    "permutations: empty sequence has one empy permutation", "[permutations]") {
+  const std::vector<int> ns{};
+  auto p = permutations(ns);
+  auto it = std::begin(p);
+  REQUIRE((*it).empty());
+  it++;
+  REQUIRE(it == std::end(p));
 }
 
 TEST_CASE("permutations: iterators can be compared", "[permutations]") {
-    const std::vector<int> ns = {1, 2};
-    auto p = permutations(ns);
-    auto it = std::begin(p);
-    REQUIRE( it == std::begin(p) );
-    REQUIRE_FALSE( it != std::begin(p) );
-    REQUIRE( it != std::end(p) );
-    REQUIRE_FALSE( it == std::end(p) );
-    ++it;
-    REQUIRE_FALSE( it == std::begin(p) );
-    REQUIRE( it != std::begin(p) );
-    REQUIRE_FALSE( it == std::end(p) );
-    REQUIRE( it != std::end(p) );
-    ++it;
-    REQUIRE( it == std::end(p) );
-    REQUIRE_FALSE( it != std::end(p) );
+  const std::vector<int> ns = {1, 2};
+  auto p = permutations(ns);
+  auto it = std::begin(p);
+  REQUIRE(it == std::begin(p));
+  REQUIRE_FALSE(it != std::begin(p));
+  REQUIRE(it != std::end(p));
+  REQUIRE_FALSE(it == std::end(p));
+  ++it;
+  REQUIRE_FALSE(it == std::begin(p));
+  REQUIRE(it != std::begin(p));
+  REQUIRE_FALSE(it == std::end(p));
+  REQUIRE(it != std::end(p));
+  ++it;
+  REQUIRE(it == std::end(p));
+  REQUIRE_FALSE(it != std::end(p));
 }
 
-
 TEST_CASE("permutations: binds to lvalues, moves rvalues", "[permutations]") {
-    itertest::BasicIterable<int> bi{1, 2};
-    SECTION("binds to lvalues") {
-        permutations(bi);
-        REQUIRE_FALSE(bi.was_moved_from());
-    }
+  itertest::BasicIterable<int> bi{1, 2};
+  SECTION("binds to lvalues") {
+    permutations(bi);
+    REQUIRE_FALSE(bi.was_moved_from());
+  }
 
-    SECTION("moves rvalues") {
-        permutations(std::move(bi));
-        REQUIRE(bi.was_moved_from());
-    }
+  SECTION("moves rvalues") {
+    permutations(std::move(bi));
+    REQUIRE(bi.was_moved_from());
+  }
 }
 
 namespace itertest {
-    bool operator<(const SolidInt& lhs, const SolidInt& rhs) {
-        return lhs.getint() < rhs.getint();
-    }
+  bool operator<(const SolidInt& lhs, const SolidInt& rhs) {
+    return lhs.getint() < rhs.getint();
+  }
 }
 
 TEST_CASE("permutations doesn't move or copy elements of iterable",
-        "[permutations]") {
-    constexpr itertest::SolidInt arr[] = {{1}, {0}, {2}};
-    for (auto&& st : permutations(arr)) {
-        (void)st;
-    }
+    "[permutations]") {
+  constexpr itertest::SolidInt arr[] = {{1}, {0}, {2}};
+  for (auto&& st : permutations(arr)) {
+    (void)st;
+  }
 }
 
 TEST_CASE("permutations: iterator meets requirements", "[permutations]") {
-    std::string s{"abc"};
-    auto c = permutations(s);
-    REQUIRE( itertest::IsIterator<decltype(std::begin(c))>::value );
-    auto&& row = *std::begin(c);
-    REQUIRE( itertest::IsIterator<decltype(std::begin(row))>::value );
+  std::string s{"abc"};
+  auto c = permutations(s);
+  REQUIRE(itertest::IsIterator<decltype(std::begin(c))>::value);
+  auto&& row = *std::begin(c);
+  REQUIRE(itertest::IsIterator<decltype(std::begin(row))>::value);
+}
+
+template <typename T>
+using ImpT = decltype(permutations(std::declval<T>()));
+TEST_CASE("permutations: has correct ctor and assign ops", "[permutations]") {
+  REQUIRE(itertest::IsMoveConstructibleOnly<ImpT<std::string&>>::value);
+  REQUIRE(itertest::IsMoveConstructibleOnly<ImpT<std::string>>::value);
 }

From 31d3b8a3467898ab299708ab2a5555cfaff7bb9a Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 6 Sep 2015 23:24:23 -0700
Subject: [PATCH 1330/1866] tests powerset impl has move ctor only

---
 test/test_powerset.cpp | 157 +++++++++++++++++++++--------------------
 1 file changed, 82 insertions(+), 75 deletions(-)

diff --git a/test/test_powerset.cpp b/test/test_powerset.cpp
index 3c13e09f..fae08df8 100644
--- a/test/test_powerset.cpp
+++ b/test/test_powerset.cpp
@@ -12,98 +12,105 @@ using iter::powerset;
 using IntPermSet = std::multiset<std::multiset<int>>;
 
 TEST_CASE("powerset: basic test, [1, 2, 3]", "[powerset]") {
-    const std::vector<int> ns = {1, 2, 3};
-    IntPermSet v;
-    for (auto&& st : powerset(ns)) {
-        v.emplace(std::begin(st), std::end(st));
-    }
-
-    const IntPermSet vc = { std::multiset<int>{},
-      {1}, {2}, {3,}, {1,2}, {1,3}, {2,3}, {1,2,3} };
-    REQUIRE( v == vc );
+  const std::vector<int> ns = {1, 2, 3};
+  IntPermSet v;
+  for (auto&& st : powerset(ns)) {
+    v.emplace(std::begin(st), std::end(st));
+  }
+
+  const IntPermSet vc = {std::multiset<int>{}, {1}, {2},
+      {
+          3,
+      },
+      {1, 2}, {1, 3}, {2, 3}, {1, 2, 3}};
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("powerset: empty sequence gives only empty set", "[powerset]") {
-    const std::vector<int> ns = {};
-    auto ps = powerset(ns);
-    auto it = std::begin(ps);
-    REQUIRE( std::begin(*it) == std::end(*it) ); // it's empty
-    ++it;
-    REQUIRE( it == std::end(ps) );
+  const std::vector<int> ns = {};
+  auto ps = powerset(ns);
+  auto it = std::begin(ps);
+  REQUIRE(std::begin(*it) == std::end(*it));  // it's empty
+  ++it;
+  REQUIRE(it == std::end(ps));
 }
 
 TEST_CASE("powerset: iterators can be compared", "[powerset]") {
-    std::vector<int> ns = {1, 2};
-    auto p = powerset(ns);
-    {
-        auto it = std::begin(p);
-        REQUIRE( it == std::begin(p) );
-        REQUIRE_FALSE( it != std::begin(p) );
-        REQUIRE( it != std::end(p) );
-        REQUIRE_FALSE( it == std::end(p) );
-        ++it;
-        REQUIRE_FALSE( it == std::begin(p) );
-        REQUIRE( it != std::begin(p) );
-        REQUIRE_FALSE( it == std::end(p) );
-        REQUIRE( it != std::end(p) );
-        ++it;
-        ++it;
-        ++it;
-        REQUIRE( it == std::end(p) );
-    }
-
-    ns.push_back(3);
-    {
-        auto it = std::begin(p);
-        auto it2 = std::begin(p);
-        std::advance(it, 4);
-        std::advance(it2, 4);
-        REQUIRE( it == it2 );
-        ++it2;
-        REQUIRE( it != it2 );
-    }
-
-}
+  std::vector<int> ns = {1, 2};
+  auto p = powerset(ns);
+  {
+    auto it = std::begin(p);
+    REQUIRE(it == std::begin(p));
+    REQUIRE_FALSE(it != std::begin(p));
+    REQUIRE(it != std::end(p));
+    REQUIRE_FALSE(it == std::end(p));
+    ++it;
+    REQUIRE_FALSE(it == std::begin(p));
+    REQUIRE(it != std::begin(p));
+    REQUIRE_FALSE(it == std::end(p));
+    REQUIRE(it != std::end(p));
+    ++it;
+    ++it;
+    ++it;
+    REQUIRE(it == std::end(p));
+  }
 
-TEST_CASE("powerset: iterator copy ctor is correct", "[powerset]") {
-    // { {}, {1}, {2}, {1, 2} }
-    std::vector<int> ns = {1, 2};
-    auto p = powerset(ns);
+  ns.push_back(3);
+  {
     auto it = std::begin(p);
-    auto it2(it);
-    REQUIRE( it == it2 );
+    auto it2 = std::begin(p);
+    std::advance(it, 4);
+    std::advance(it2, 4);
+    REQUIRE(it == it2);
     ++it2;
-    REQUIRE( it != it2 );
-    REQUIRE( std::begin(*it) == std::end(*it) );
+    REQUIRE(it != it2);
+  }
 }
 
-
+TEST_CASE("powerset: iterator copy ctor is correct", "[powerset]") {
+  // { {}, {1}, {2}, {1, 2} }
+  std::vector<int> ns = {1, 2};
+  auto p = powerset(ns);
+  auto it = std::begin(p);
+  auto it2(it);
+  REQUIRE(it == it2);
+  ++it2;
+  REQUIRE(it != it2);
+  REQUIRE(std::begin(*it) == std::end(*it));
+}
 
 TEST_CASE("powerset: binds to lvalues, moves rvalues", "[powerset]") {
-    itertest::BasicIterable<int> bi{1, 2};
-    SECTION("binds to lvalues") {
-        powerset(bi);
-        REQUIRE_FALSE(bi.was_moved_from());
-    }
-    SECTION("moves rvalues") {
-        powerset(std::move(bi));
-        REQUIRE(bi.was_moved_from());
-    }
+  itertest::BasicIterable<int> bi{1, 2};
+  SECTION("binds to lvalues") {
+    powerset(bi);
+    REQUIRE_FALSE(bi.was_moved_from());
+  }
+  SECTION("moves rvalues") {
+    powerset(std::move(bi));
+    REQUIRE(bi.was_moved_from());
+  }
 }
 
-TEST_CASE("powerset: doesn't move or copy elements of iterable", "[powerset]"){
-    constexpr itertest::SolidInt arr[] = {{1}, {0}, {2}};
-    for (auto&& st : powerset(arr)) {
-        for (auto&& i : st) {
-            (void)i;
-        }
+TEST_CASE("powerset: doesn't move or copy elements of iterable", "[powerset]") {
+  constexpr itertest::SolidInt arr[] = {{1}, {0}, {2}};
+  for (auto&& st : powerset(arr)) {
+    for (auto&& i : st) {
+      (void)i;
     }
+  }
 }
 
 TEST_CASE("powerset: iterator meets requirements", "[powerset]") {
-    std::string s{"abc"};
-    auto c = powerset(s);
-    REQUIRE( itertest::IsIterator<decltype(std::begin(c))>::value );
-    auto&& row = *std::begin(c);
-    REQUIRE( itertest::IsIterator<decltype(std::begin(row))>::value );
+  std::string s{"abc"};
+  auto c = powerset(s);
+  REQUIRE(itertest::IsIterator<decltype(std::begin(c))>::value);
+  auto&& row = *std::begin(c);
+  REQUIRE(itertest::IsIterator<decltype(std::begin(row))>::value);
+}
+
+template <typename T>
+using ImpT = decltype(powerset(std::declval<T>()));
+TEST_CASE("powerset: has correct ctor and assign ops", "[powerset]") {
+  REQUIRE(itertest::IsMoveConstructibleOnly<ImpT<std::string&>>::value);
+  REQUIRE(itertest::IsMoveConstructibleOnly<ImpT<std::string>>::value);
 }

From de7bd62bfa012fd9d31df8c16d5dde947cac9169 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 6 Sep 2015 23:24:30 -0700
Subject: [PATCH 1331/1866] tests product impl has move ctor only

---
 test/test_product.cpp | 153 +++++++++++++++++++++---------------------
 1 file changed, 77 insertions(+), 76 deletions(-)

diff --git a/test/test_product.cpp b/test/test_product.cpp
index fb6ea0cc..d42cde31 100644
--- a/test/test_product.cpp
+++ b/test/test_product.cpp
@@ -12,110 +12,111 @@ using iter::product;
 using Vec = const std::vector<int>;
 
 TEST_CASE("product: basic test, two sequences", "[product]") {
-    using TP = std::tuple<int, char>;
-    using ResType = std::vector<TP>;
+  using TP = std::tuple<int, char>;
+  using ResType = std::vector<TP>;
 
-    Vec n1 = {0, 1};
-    const std::string s{"abc"};
+  Vec n1 = {0, 1};
+  const std::string s{"abc"};
 
-    auto p = product(n1, s);
-    ResType v(std::begin(p), std::end(p));
-    ResType vc = {TP{0,'a'}, TP{0,'b'}, TP{0,'c'},
-                  TP{1,'a'}, TP{1,'b'}, TP{1,'c'}};
+  auto p = product(n1, s);
+  ResType v(std::begin(p), std::end(p));
+  ResType vc = {
+      TP{0, 'a'}, TP{0, 'b'}, TP{0, 'c'}, TP{1, 'a'}, TP{1, 'b'}, TP{1, 'c'}};
 
-    REQUIRE( v == vc );
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("product: three sequences", "[product]") {
-    using TP = std::tuple <int, char, int>;
-    using ResType = const std::vector<TP>;
+  using TP = std::tuple<int, char, int>;
+  using ResType = const std::vector<TP>;
 
-    Vec n1 = {0, 1};
-    const std::string s{"ab"};
-    Vec n2 = {2};
+  Vec n1 = {0, 1};
+  const std::string s{"ab"};
+  Vec n2 = {2};
 
-    auto p = product(n1, s, n2);
-    ResType v(std::begin(p), std::end(p));
+  auto p = product(n1, s, n2);
+  ResType v(std::begin(p), std::end(p));
 
-    ResType vc = {
-        TP{0, 'a', 2},
-        TP{0, 'b', 2},
-        TP{1, 'a', 2},
-        TP{1, 'b', 2}
-    };
+  ResType vc = {TP{0, 'a', 2}, TP{0, 'b', 2}, TP{1, 'a', 2}, TP{1, 'b', 2}};
 
-    REQUIRE( v == vc );
+  REQUIRE(v == vc);
 }
 
-
 TEST_CASE("product: empty when any iterable is empty", "[product]") {
-    Vec n1 = {0, 1};
-    Vec n2 = {0, 1, 2};
-    Vec emp = {};
-
-    SECTION("first iterable is empty") {
-        auto p = product(emp, n1, n2);
-        REQUIRE( std::begin(p) == std::end(p) );
-    }
-
-    SECTION("middle iterable is empty") {
-        auto p = product(n1, emp, n2);
-        REQUIRE( std::begin(p) == std::end(p) );
-    }
-
-    SECTION("last iterable is empty") {
-        auto p = product(n1, n2, emp);
-        REQUIRE( std::begin(p) == std::end(p) );
-    }
+  Vec n1 = {0, 1};
+  Vec n2 = {0, 1, 2};
+  Vec emp = {};
+
+  SECTION("first iterable is empty") {
+    auto p = product(emp, n1, n2);
+    REQUIRE(std::begin(p) == std::end(p));
+  }
+
+  SECTION("middle iterable is empty") {
+    auto p = product(n1, emp, n2);
+    REQUIRE(std::begin(p) == std::end(p));
+  }
+
+  SECTION("last iterable is empty") {
+    auto p = product(n1, n2, emp);
+    REQUIRE(std::begin(p) == std::end(p));
+  }
 }
 
 TEST_CASE("product: single iterable", "[product]") {
-    const std::string s{"ab"};
-    using TP = std::tuple<char>;
-    using ResType = const std::vector<TP>;
+  const std::string s{"ab"};
+  using TP = std::tuple<char>;
+  using ResType = const std::vector<TP>;
 
-    auto p = product(s);
-    ResType v(std::begin(p), std::end(p));
-    ResType vc = {TP{'a'}, TP{'b'}};
+  auto p = product(s);
+  ResType v(std::begin(p), std::end(p));
+  ResType vc = {TP{'a'}, TP{'b'}};
 
-    REQUIRE( v == vc );
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("product: no arguments gives one empty tuple", "[product") {
-    auto p = product();
-    auto it = std::begin(p);
-    REQUIRE( it != std::end(p) );
-    REQUIRE( *it == std::make_tuple() );
-    ++it;
-    REQUIRE( it == std::end(p) );
+  auto p = product();
+  auto it = std::begin(p);
+  REQUIRE(it != std::end(p));
+  REQUIRE(*it == std::make_tuple());
+  ++it;
+  REQUIRE(it == std::end(p));
 }
 
 TEST_CASE("product: binds to lvalues and moves rvalues", "[product]") {
-    itertest::BasicIterable<char> bi{'x', 'y'};
-    itertest::BasicIterable<int> bi2{0, 1};
-    
-    SECTION("First ref'd, second moved") {
-        product(bi, std::move(bi2));
-        REQUIRE_FALSE( bi.was_moved_from() );
-        REQUIRE( bi2.was_moved_from() );
-    }
-
-    SECTION("First moved, second ref'd") {
-        product(std::move(bi), bi2);
-        REQUIRE( bi.was_moved_from() );
-        REQUIRE_FALSE( bi2.was_moved_from() );
-    }
+  itertest::BasicIterable<char> bi{'x', 'y'};
+  itertest::BasicIterable<int> bi2{0, 1};
+
+  SECTION("First ref'd, second moved") {
+    product(bi, std::move(bi2));
+    REQUIRE_FALSE(bi.was_moved_from());
+    REQUIRE(bi2.was_moved_from());
+  }
+
+  SECTION("First moved, second ref'd") {
+    product(std::move(bi), bi2);
+    REQUIRE(bi.was_moved_from());
+    REQUIRE_FALSE(bi2.was_moved_from());
+  }
 }
 
 TEST_CASE("product: doesn't move or copy elements of iterable", "[product]") {
-    constexpr itertest::SolidInt arr[] = {{1}, {0}, {2}};
-    for (auto&& t : product(arr)) {
-        (void)std::get<0>(t);
-    }
+  constexpr itertest::SolidInt arr[] = {{1}, {0}, {2}};
+  for (auto&& t : product(arr)) {
+    (void)std::get<0>(t);
+  }
 }
 
 TEST_CASE("product: iterator meets requirements", "[product]") {
-    std::string s{"abc"};
-    auto c = product(s, s);
-    REQUIRE( itertest::IsIterator<decltype(std::begin(c))>::value );
+  std::string s{"abc"};
+  auto c = product(s, s);
+  REQUIRE(itertest::IsIterator<decltype(std::begin(c))>::value);
+}
+
+template <typename... Ts>
+using ImpT = decltype(product(std::declval<Ts>()...));
+TEST_CASE("product: has correct ctor and assign ops", "[product]") {
+  using T = ImpT<std::string&, std::vector<double>, std::vector<std::string>>;
+  REQUIRE(itertest::IsMoveConstructibleOnly<T>::value);
 }

From ddb330607d86b8cab1a206b3019378876594fdee Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 6 Sep 2015 23:24:40 -0700
Subject: [PATCH 1332/1866] tests repeat impl has move ctor only

---
 test/test_repeat.cpp | 110 ++++++++++++++++++++++++-------------------
 1 file changed, 62 insertions(+), 48 deletions(-)

diff --git a/test/test_repeat.cpp b/test/test_repeat.cpp
index ee7c03e4..3cd928df 100644
--- a/test/test_repeat.cpp
+++ b/test/test_repeat.cpp
@@ -11,70 +11,84 @@
 using iter::repeat;
 
 TEST_CASE("repeat: one argument keeps giving value back", "[repeat]") {
-    auto r = repeat('a');
-    auto it = std::begin(r);
-    REQUIRE( *it == 'a' );
-    ++it;
-    REQUIRE( *it == 'a' );
-    ++it;
-    REQUIRE( *it == 'a' );
-    ++it;
-    REQUIRE( *it == 'a' );
-    ++it;
-    REQUIRE( *it == 'a' );
+  auto r = repeat('a');
+  auto it = std::begin(r);
+  REQUIRE(*it == 'a');
+  ++it;
+  REQUIRE(*it == 'a');
+  ++it;
+  REQUIRE(*it == 'a');
+  ++it;
+  REQUIRE(*it == 'a');
+  ++it;
+  REQUIRE(*it == 'a');
 }
 
 TEST_CASE("repeat: can be used as constexpr", "[repeat]") {
-    static constexpr char c = 'a';
-    {
-        constexpr auto r = repeat(c);
-        constexpr auto i = r.begin();
-        constexpr char c2 = *i;
-        static_assert(c == c2, "repeat value not as expected");
-        constexpr auto i2 = ++i; (void)i2;
-    }
-
-    {
-      constexpr static auto r = repeat('a');
-      constexpr auto i = r.begin();
-      constexpr char c2 = *i;
-      static_assert(c2 == 'a', "repeat value not as expected");
-    }
-
-    {
-        constexpr auto r = repeat(c, 2);
-        constexpr auto i = r.begin();
-        constexpr char c2 = *i;
-        static_assert( c2 == c, "repeat value not as expected");
-    }
+  static constexpr char c = 'a';
+  {
+    constexpr auto r = repeat(c);
+    constexpr auto i = r.begin();
+    constexpr char c2 = *i;
+    static_assert(c == c2, "repeat value not as expected");
+    constexpr auto i2 = ++i;
+    (void)i2;
+  }
+
+  {
+    constexpr static auto r = repeat('a');
+    constexpr auto i = r.begin();
+    constexpr char c2 = *i;
+    static_assert(c2 == 'a', "repeat value not as expected");
+  }
+
+  {
+    constexpr auto r = repeat(c, 2);
+    constexpr auto i = r.begin();
+    constexpr char c2 = *i;
+    static_assert(c2 == c, "repeat value not as expected");
+  }
 }
 
 TEST_CASE("repeat: two argument repeats a number of times", "[repeat]") {
-    auto r = repeat('a', 3);
-    std::string s(std::begin(r), std::end(r));
-    REQUIRE( s == "aaa" );
+  auto r = repeat('a', 3);
+  std::string s(std::begin(r), std::end(r));
+  REQUIRE(s == "aaa");
 }
 
 TEST_CASE("repeat: 0 count gives empty sequence", "[repeat]") {
-    auto r = repeat('a', 0);
-    REQUIRE( std::begin(r) == std::end(r) );
+  auto r = repeat('a', 0);
+  REQUIRE(std::begin(r) == std::end(r));
 }
 
 TEST_CASE("repeat: negative count gives empty sequence", "[repeat]") {
-    auto r = repeat('a', -2);
-    REQUIRE( std::begin(r) == std::end(r) );
-    auto r2 = repeat('a', -1);
-    REQUIRE( std::begin(r2) == std::end(r2) );
+  auto r = repeat('a', -2);
+  REQUIRE(std::begin(r) == std::end(r));
+  auto r2 = repeat('a', -1);
+  REQUIRE(std::begin(r2) == std::end(r2));
 }
 
 TEST_CASE("repeat: doesn't duplicate item", "[repeat]") {
-    itertest::SolidInt si{2};
-    auto r = repeat(si);
-    auto it = std::begin(r);
-    (void)*it;
+  itertest::SolidInt si{2};
+  auto r = repeat(si);
+  auto it = std::begin(r);
+  (void)*it;
 }
 
 TEST_CASE("repeat: iterator meets requirements", "[repeat]") {
-    auto r = repeat(1);
-    REQUIRE( itertest::IsIterator<decltype(std::begin(r))>::value );
+  auto r = repeat(1);
+  REQUIRE(itertest::IsIterator<decltype(std::begin(r))>::value);
+}
+
+template <typename T>
+using ImpT = decltype(repeat(std::declval<T>()));
+
+template <typename T>
+using ImpT2 = decltype(repeat(std::declval<T>(), 1));
+
+TEST_CASE("repeat: has correct ctor and assign ops", "[repeat]") {
+  REQUIRE(itertest::IsMoveConstructibleOnly<ImpT<std::string&>>::value);
+  REQUIRE(itertest::IsMoveConstructibleOnly<ImpT<std::string>>::value);
+  REQUIRE(itertest::IsMoveConstructibleOnly<ImpT2<std::string&>>::value);
+  REQUIRE(itertest::IsMoveConstructibleOnly<ImpT2<std::string>>::value);
 }

From 1be704d461c86b124da6ef1965eb09bd34a9eb4a Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 6 Sep 2015 23:24:50 -0700
Subject: [PATCH 1333/1866] tests reversed impl has move ctor only

---
 test/test_reversed.cpp | 73 +++++++++++++++++++++++-------------------
 1 file changed, 40 insertions(+), 33 deletions(-)

diff --git a/test/test_reversed.cpp b/test/test_reversed.cpp
index cade9326..c245e82a 100644
--- a/test/test_reversed.cpp
+++ b/test/test_reversed.cpp
@@ -12,61 +12,68 @@ using iter::reversed;
 using Vec = const std::vector<int>;
 
 TEST_CASE("reversed: can reverse a vector", "[reversed]") {
-    Vec ns = {10, 20, 30, 40};
-    auto r = reversed(ns);
+  Vec ns = {10, 20, 30, 40};
+  auto r = reversed(ns);
 
-    Vec v(std::begin(r), std::end(r));
-    Vec vc = {40, 30, 20, 10};
+  Vec v(std::begin(r), std::end(r));
+  Vec vc = {40, 30, 20, 10};
 
-    REQUIRE( v == vc );
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("reversed: can reverse an array", "[reversed]") {
-    int ns[] = {10, 20, 30, 40};
-    auto r = reversed(ns);
+  int ns[] = {10, 20, 30, 40};
+  auto r = reversed(ns);
 
-    Vec v(std::begin(r), std::end(r));
-    Vec vc = {40, 30, 20, 10};
+  Vec v(std::begin(r), std::end(r));
+  Vec vc = {40, 30, 20, 10};
 
-    REQUIRE( v == vc );
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("reversed: empty when iterable is empty", "[reversed]") {
-    Vec emp{};
-    auto r = reversed(emp);
-    REQUIRE( std::begin(r) == std::end(r) );
+  Vec emp{};
+  auto r = reversed(emp);
+  REQUIRE(std::begin(r) == std::end(r));
 }
 
 TEST_CASE("reversed: moves rvalues and binds to lvalues", "[reversed]") {
-    itertest::BasicIterable<int> bi{1, 2};
-    itertest::BasicIterable<int> bi2{1, 2};
-    reversed(bi);
-    REQUIRE_FALSE( bi.was_moved_from() );
+  itertest::BasicIterable<int> bi{1, 2};
+  itertest::BasicIterable<int> bi2{1, 2};
+  reversed(bi);
+  REQUIRE_FALSE(bi.was_moved_from());
 
-    reversed(std::move(bi2));
-    REQUIRE( bi2.was_moved_from() );
+  reversed(std::move(bi2));
+  REQUIRE(bi2.was_moved_from());
 }
 
 TEST_CASE("reversed: doesn't move or copy elements of array", "[reversed]") {
-    constexpr itertest::SolidInt arr[] = {{6}, {7}, {8}};
-    for (auto&& i : reversed(arr)) {
-        (void)i;
-    }
+  constexpr itertest::SolidInt arr[] = {{6}, {7}, {8}};
+  for (auto&& i : reversed(arr)) {
+    (void)i;
+  }
 }
 
 TEST_CASE("reversed: with iterable doesn't move or copy elems", "[reversed]") {
-    constexpr std::array<itertest::SolidInt, 3> arr{{{6}, {7}, {8}}};
-    for (auto&& i : reversed(arr)) {
-        (void)i;
-    }
+  constexpr std::array<itertest::SolidInt, 3> arr{{{6}, {7}, {8}}};
+  for (auto&& i : reversed(arr)) {
+    (void)i;
+  }
 }
 
 TEST_CASE("reversed: iterator meets requirements", "[reversed]") {
-    Vec v;
-    auto r = reversed(v);
-    REQUIRE( itertest::IsIterator<decltype(std::begin(r))>::value );
+  Vec v;
+  auto r = reversed(v);
+  REQUIRE(itertest::IsIterator<decltype(std::begin(r))>::value);
 
-    int a[1];
-    auto ra = reversed(a);
-    REQUIRE( itertest::IsIterator<decltype(std::begin(ra))>::value );
+  int a[1];
+  auto ra = reversed(a);
+  REQUIRE(itertest::IsIterator<decltype(std::begin(ra))>::value);
+}
+
+template <typename T>
+using ImpT = decltype(reversed(std::declval<T>()));
+TEST_CASE("reversed: has correct ctor and assign ops", "[reversed]") {
+  REQUIRE(itertest::IsMoveConstructibleOnly<ImpT<std::string&>>::value);
+  REQUIRE(itertest::IsMoveConstructibleOnly<ImpT<std::string>>::value);
 }

From c3321696bbba1f318d7079997a4092d6c4d4fc61 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 6 Sep 2015 23:25:00 -0700
Subject: [PATCH 1334/1866] tests slice impl has move ctor only

---
 test/test_slice.cpp | 116 +++++++++++++++++++++++---------------------
 1 file changed, 61 insertions(+), 55 deletions(-)

diff --git a/test/test_slice.cpp b/test/test_slice.cpp
index 921fab44..a94e8a14 100644
--- a/test/test_slice.cpp
+++ b/test/test_slice.cpp
@@ -11,99 +11,105 @@ using iter::slice;
 using Vec = const std::vector<int>;
 
 TEST_CASE("slice: take from beginning", "[slice]") {
-    Vec ns = {10,11,12,13,14,15,16,17,18,19};
-    auto sl = slice(ns, 5);
+  Vec ns = {10, 11, 12, 13, 14, 15, 16, 17, 18, 19};
+  auto sl = slice(ns, 5);
 
-    Vec v(std::begin(sl), std::end(sl));
-    Vec vc = {10,11,12,13,14};
+  Vec v(std::begin(sl), std::end(sl));
+  Vec vc = {10, 11, 12, 13, 14};
 
-    REQUIRE( v == vc );
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("slice: start and stop", "[slice]") {
-    Vec ns = {10,11,12,13,14,15,16,17,18,19};
-    auto sl = slice(ns, 2, 6);
+  Vec ns = {10, 11, 12, 13, 14, 15, 16, 17, 18, 19};
+  auto sl = slice(ns, 2, 6);
 
-    Vec v(std::begin(sl), std::end(sl));
-    Vec vc = {12, 13, 14, 15};
+  Vec v(std::begin(sl), std::end(sl));
+  Vec vc = {12, 13, 14, 15};
 
-    REQUIRE( v == vc );
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("slice: start, stop, step", "[slice]") {
-    Vec ns = {10,11,12,13,14,15,16,17,18,19};
-    auto sl = slice(ns, 2, 8, 2);
+  Vec ns = {10, 11, 12, 13, 14, 15, 16, 17, 18, 19};
+  auto sl = slice(ns, 2, 8, 2);
 
-    Vec v(std::begin(sl), std::end(sl));
-    Vec vc = {12,14,16};
+  Vec v(std::begin(sl), std::end(sl));
+  Vec vc = {12, 14, 16};
 
-    REQUIRE( v == vc );
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("slice: empty iterable", "[slice]") {
-    Vec ns{};
-    auto sl = slice(ns, 3);
-    REQUIRE( std::begin(sl) == std::end(sl) );
+  Vec ns{};
+  auto sl = slice(ns, 3);
+  REQUIRE(std::begin(sl) == std::end(sl));
 }
 
 TEST_CASE("slice: stop is beyond end of iterable", "[slice]") {
-    Vec ns = {1, 2, 3};
-    auto sl = slice(ns, 10);
+  Vec ns = {1, 2, 3};
+  auto sl = slice(ns, 10);
 
-    Vec v(std::begin(sl), std::end(sl));
-    REQUIRE( v == ns );
+  Vec v(std::begin(sl), std::end(sl));
+  REQUIRE(v == ns);
 }
 
 TEST_CASE("slice: start is beyond end of iterable", "[slice]") {
-    Vec ns = {1, 2, 3};
-    auto sl = slice(ns, 5, 10);
-    REQUIRE( std::begin(sl) == std::end(sl) );
+  Vec ns = {1, 2, 3};
+  auto sl = slice(ns, 5, 10);
+  REQUIRE(std::begin(sl) == std::end(sl));
 }
 
 TEST_CASE("slice: (stop - start) % step != 0", "[slice]") {
-    Vec ns = {1, 2, 3, 4};
-    auto sl = slice(ns, 0, 2, 3);
-    Vec v(std::begin(sl), std::end(sl));
-    Vec vc = {1}; 
+  Vec ns = {1, 2, 3, 4};
+  auto sl = slice(ns, 0, 2, 3);
+  Vec v(std::begin(sl), std::end(sl));
+  Vec vc = {1};
 
-    REQUIRE( v == vc );
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("slice: invalid ranges give 0 size slices", "[slice]") {
-    Vec ns = {1, 2, 3};
-    SECTION("negative step") {
-        auto sl = slice(ns, 1, 10, -1);
-        REQUIRE( std::begin(sl) == std::end(sl) );
-    }
-    SECTION("stop < start") {
-        auto sl = slice(ns, 2, 0, 3);
-        REQUIRE( std::begin(sl) == std::end(sl) );
-    }
+  Vec ns = {1, 2, 3};
+  SECTION("negative step") {
+    auto sl = slice(ns, 1, 10, -1);
+    REQUIRE(std::begin(sl) == std::end(sl));
+  }
+  SECTION("stop < start") {
+    auto sl = slice(ns, 2, 0, 3);
+    REQUIRE(std::begin(sl) == std::end(sl));
+  }
 }
 
 TEST_CASE("slice: moves rvalues and binds to lvalues", "[slice]") {
-    itertest::BasicIterable<int> bi{1, 2, 3, 4};
-    slice(bi, 1, 3);
-    REQUIRE_FALSE( bi.was_moved_from() );
-    auto sl = slice(std::move(bi), 1, 3);
-    REQUIRE( bi.was_moved_from() );
+  itertest::BasicIterable<int> bi{1, 2, 3, 4};
+  slice(bi, 1, 3);
+  REQUIRE_FALSE(bi.was_moved_from());
+  auto sl = slice(std::move(bi), 1, 3);
+  REQUIRE(bi.was_moved_from());
 
-    Vec v(std::begin(sl), std::end(sl));
-    Vec vc = {2, 3};
+  Vec v(std::begin(sl), std::end(sl));
+  Vec vc = {2, 3};
 
-    REQUIRE( v == vc );
+  REQUIRE(v == vc);
 }
 
-
 TEST_CASE("slice: with iterable doesn't move or copy elems", "[slice]") {
-    constexpr itertest::SolidInt arr[] = {{6}, {7}, {8}};
-    for (auto&& i : slice(arr, 2)) {
-        (void)i;
-    }
+  constexpr itertest::SolidInt arr[] = {{6}, {7}, {8}};
+  for (auto&& i : slice(arr, 2)) {
+    (void)i;
+  }
 }
 
 TEST_CASE("slice: iterator meets requirements", "[slice]") {
-    std::string s{"abcdef"};
-    auto c = slice(s, 1, 3);
-    REQUIRE( itertest::IsIterator<decltype(std::begin(c))>::value );
+  std::string s{"abcdef"};
+  auto c = slice(s, 1, 3);
+  REQUIRE(itertest::IsIterator<decltype(std::begin(c))>::value);
+}
+
+template <typename T>
+using ImpT = decltype(slice(std::declval<T>(), 1));
+TEST_CASE("slice: has correct ctor and assign ops", "[slice]") {
+  REQUIRE(itertest::IsMoveConstructibleOnly<ImpT<std::string&>>::value);
+  REQUIRE(itertest::IsMoveConstructibleOnly<ImpT<std::string>>::value);
 }

From 1486f6f057ff9b15cf9777e9588a3ac7cb52901d Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 6 Sep 2015 23:25:13 -0700
Subject: [PATCH 1335/1866] tests sliding_window impl has move ctor only

---
 test/test_sliding_window.cpp | 141 ++++++++++++++++++-----------------
 1 file changed, 74 insertions(+), 67 deletions(-)

diff --git a/test/test_sliding_window.cpp b/test/test_sliding_window.cpp
index d413b431..d1c8cb18 100644
--- a/test/test_sliding_window.cpp
+++ b/test/test_sliding_window.cpp
@@ -12,96 +12,103 @@ using iter::sliding_window;
 using Vec = const std::vector<int>;
 
 TEST_CASE("sliding_window: window of size 3", "[sliding_window]") {
-    Vec ns = { 10, 20, 30, 40, 50};
-    auto sw = sliding_window(ns, 3);
-    auto it = std::begin(sw);
-    REQUIRE( it != std::end(sw) );
-    {
-        Vec v(std::begin(*it), std::end(*it));
-        Vec vc = {10, 20, 30};
-        REQUIRE( v == vc );
-
-    }
-    ++it;
-    REQUIRE( it != std::end(sw) );
-    {
-        Vec v(std::begin(*it), std::end(*it));
-        Vec vc = {20, 30, 40};
-        REQUIRE( v == vc );
-    }
-    ++it;
-    REQUIRE( it != std::end(sw) );
-    {
-        Vec v(std::begin(*it), std::end(*it));
-        Vec vc = {30, 40, 50};
-        REQUIRE( v == vc );
-    }
-    ++it;
-    REQUIRE( it == std::end(sw) );
+  Vec ns = {10, 20, 30, 40, 50};
+  auto sw = sliding_window(ns, 3);
+  auto it = std::begin(sw);
+  REQUIRE(it != std::end(sw));
+  {
+    Vec v(std::begin(*it), std::end(*it));
+    Vec vc = {10, 20, 30};
+    REQUIRE(v == vc);
+  }
+  ++it;
+  REQUIRE(it != std::end(sw));
+  {
+    Vec v(std::begin(*it), std::end(*it));
+    Vec vc = {20, 30, 40};
+    REQUIRE(v == vc);
+  }
+  ++it;
+  REQUIRE(it != std::end(sw));
+  {
+    Vec v(std::begin(*it), std::end(*it));
+    Vec vc = {30, 40, 50};
+    REQUIRE(v == vc);
+  }
+  ++it;
+  REQUIRE(it == std::end(sw));
 }
 
 TEST_CASE("sliding window: oversized window is empty", "[sliding_window]") {
-    Vec ns = {10, 20, 30};
-    auto sw = sliding_window(ns, 5);
-    REQUIRE( std::begin(sw) == std::end(sw) );
+  Vec ns = {10, 20, 30};
+  auto sw = sliding_window(ns, 5);
+  REQUIRE(std::begin(sw) == std::end(sw));
 }
 
 TEST_CASE("sliding window: window size == len(iterable)", "[sliding_window]") {
-    Vec ns = {10, 20, 30};
-    auto sw = sliding_window(ns, 3);
-    auto it = std::begin(sw);
-    REQUIRE( it != std::end(sw) );
+  Vec ns = {10, 20, 30};
+  auto sw = sliding_window(ns, 3);
+  auto it = std::begin(sw);
+  REQUIRE(it != std::end(sw));
 
-    Vec v(std::begin(*it), std::end(*it));
+  Vec v(std::begin(*it), std::end(*it));
 
-    REQUIRE( ns == v );
-    ++it;
-    REQUIRE( it == std::end(sw) );
+  REQUIRE(ns == v);
+  ++it;
+  REQUIRE(it == std::end(sw));
 }
 
 TEST_CASE("sliding window: empty iterable is empty", "[sliding_window]") {
-    Vec ns{};
-    auto sw = sliding_window(ns, 1);
-    REQUIRE( std::begin(sw) == std::end(sw) );
+  Vec ns{};
+  auto sw = sliding_window(ns, 1);
+  REQUIRE(std::begin(sw) == std::end(sw));
 }
 
 TEST_CASE("sliding window: window size of 1", "[sliding_window]") {
-    Vec ns = {10, 20, 30};
-    auto sw = sliding_window(ns, 1);
-    auto it = std::begin(sw);
-    REQUIRE( *std::begin(*it) == 10 );
-    ++it;
-    REQUIRE( *std::begin(*it) == 20 );
-    ++it;
-    REQUIRE( *std::begin(*it) == 30 );
-    ++it;
-    REQUIRE( it == std::end(sw) );
+  Vec ns = {10, 20, 30};
+  auto sw = sliding_window(ns, 1);
+  auto it = std::begin(sw);
+  REQUIRE(*std::begin(*it) == 10);
+  ++it;
+  REQUIRE(*std::begin(*it) == 20);
+  ++it;
+  REQUIRE(*std::begin(*it) == 30);
+  ++it;
+  REQUIRE(it == std::end(sw));
 }
 
 TEST_CASE("sliding window: window size of 0", "[sliding_window]") {
-    Vec ns = {10, 20, 30};
-    auto sw = sliding_window(ns, 0);
-    REQUIRE( std::begin(sw) == std::end(sw) );
+  Vec ns = {10, 20, 30};
+  auto sw = sliding_window(ns, 0);
+  REQUIRE(std::begin(sw) == std::end(sw));
 }
 
-TEST_CASE("sliding window: moves rvalues and binds to lvalues",
-        "[sliding_window]") {
-    itertest::BasicIterable<int> bi{1, 2};
-    sliding_window(bi, 1);
-    REQUIRE_FALSE( bi.was_moved_from() );
-    sliding_window(std::move(bi), 1);
-    REQUIRE( bi.was_moved_from() );
+TEST_CASE(
+    "sliding window: moves rvalues and binds to lvalues", "[sliding_window]") {
+  itertest::BasicIterable<int> bi{1, 2};
+  sliding_window(bi, 1);
+  REQUIRE_FALSE(bi.was_moved_from());
+  sliding_window(std::move(bi), 1);
+  REQUIRE(bi.was_moved_from());
 }
 
 TEST_CASE("sliding window: doesn't copy elements", "[sliding_window]") {
-    constexpr std::array<itertest::SolidInt, 3> arr{{{6}, {7}, {8}}};
-    for (auto&& i : sliding_window(arr, 1)) {
-        (void)*std::begin(i);
-    }
+  constexpr std::array<itertest::SolidInt, 3> arr{{{6}, {7}, {8}}};
+  for (auto&& i : sliding_window(arr, 1)) {
+    (void)*std::begin(i);
+  }
 }
 
 TEST_CASE("sliding_window: iterator meets requirements", "[sliding_window]") {
-    std::string s{"abcdef"};
-    auto c = sliding_window(s, 2);
-    REQUIRE( itertest::IsIterator<decltype(std::begin(c))>::value );
+  std::string s{"abcdef"};
+  auto c = sliding_window(s, 2);
+  REQUIRE(itertest::IsIterator<decltype(std::begin(c))>::value);
+}
+
+template <typename T>
+using ImpT = decltype(sliding_window(std::declval<T>(), 1));
+TEST_CASE(
+    "sliding_window: has correct ctor and assign ops", "[sliding_window]") {
+  REQUIRE(itertest::IsMoveConstructibleOnly<ImpT<std::string&>>::value);
+  REQUIRE(itertest::IsMoveConstructibleOnly<ImpT<std::string>>::value);
 }

From 17c67334c57852698ba9d95b3f4576bf30575a7d Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 6 Sep 2015 23:25:23 -0700
Subject: [PATCH 1336/1866] tests sorted impl has move ctor only

---
 test/test_sorted.cpp | 258 ++++++++++++++++++++++---------------------
 1 file changed, 133 insertions(+), 125 deletions(-)

diff --git a/test/test_sorted.cpp b/test/test_sorted.cpp
index 918dec7d..374bdcba 100644
--- a/test/test_sorted.cpp
+++ b/test/test_sorted.cpp
@@ -14,160 +14,168 @@ using iter::sorted;
 
 using Vec = const std::vector<int>;
 
-TEST_CASE("sorted: iterates through a vector in sorted order", "[sorted]" ){
-    Vec ns = {4, 0, 5, 1, 6, 7, 9, 3, 2, 8};
-    auto s = sorted(ns);
-    Vec v(std::begin(s), std::end(s));
-    Vec vc = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
-    REQUIRE( v == vc );
+TEST_CASE("sorted: iterates through a vector in sorted order", "[sorted]") {
+  Vec ns = {4, 0, 5, 1, 6, 7, 9, 3, 2, 8};
+  auto s = sorted(ns);
+  Vec v(std::begin(s), std::end(s));
+  Vec vc = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("sorted: can modify elements through sorted", "[sorted]") {
-    std::vector<int> ns(3, 9);
-    for (auto&& n : sorted(ns)) {
-        n = -1;
-    }
-    Vec vc(3, -1);
-    REQUIRE( ns == vc );
+  std::vector<int> ns(3, 9);
+  for (auto&& n : sorted(ns)) {
+    n = -1;
+  }
+  Vec vc(3, -1);
+  REQUIRE(ns == vc);
 }
 
 TEST_CASE("sorted: can iterate over unordered container", "[sorted]") {
-    std::unordered_set<int> ns = {1, 3, 2, 0, 4};
-    auto s = sorted(ns);
+  std::unordered_set<int> ns = {1, 3, 2, 0, 4};
+  auto s = sorted(ns);
 
-    Vec v(std::begin(s), std::end(s));
-    Vec vc = {0, 1, 2, 3, 4};
-    REQUIRE( v == vc );
+  Vec v(std::begin(s), std::end(s));
+  Vec vc = {0, 1, 2, 3, 4};
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("sorted: empty when iterable is empty", "[sorted]") {
-    Vec ns{};
-    auto s = sorted(ns);
-    REQUIRE( std::begin(s) == std::end(s) );
+  Vec ns{};
+  auto s = sorted(ns);
+  REQUIRE(std::begin(s) == std::end(s));
 }
 
 namespace {
-    bool int_greater_than(int lhs, int rhs) {
-        return lhs > rhs;
-    }
+  bool int_greater_than(int lhs, int rhs) {
+    return lhs > rhs;
+  }
 
-    struct IntGreaterThan {
-        bool operator() (int lhs, int rhs) const {
-            return lhs > rhs;
-        }
-    };
+  struct IntGreaterThan {
+    bool operator()(int lhs, int rhs) const {
+      return lhs > rhs;
+    }
+  };
 }
 
 TEST_CASE("sorted: works with different functor types", "[sorted]") {
-    Vec ns = {4, 1, 3, 2, 0};
-    std::vector<int> v;
-    SECTION("with function pointer") {
-        auto s = sorted(ns, int_greater_than);
-        v.insert(v.begin(), std::begin(s), std::end(s));
+  Vec ns = {4, 1, 3, 2, 0};
+  std::vector<int> v;
+  SECTION("with function pointer") {
+    auto s = sorted(ns, int_greater_than);
+    v.insert(v.begin(), std::begin(s), std::end(s));
+  }
+
+  SECTION("with callable object") {
+    auto s = sorted(ns, IntGreaterThan{});
+    v.insert(v.begin(), std::begin(s), std::end(s));
+  }
+
+  SECTION("with lambda") {
+    auto s = sorted(ns, [](int lhs, int rhs) { return lhs > rhs; });
+    v.insert(v.begin(), std::begin(s), std::end(s));
+  }
+
+  Vec vc = {4, 3, 2, 1, 0};
+  REQUIRE(v == vc);
+}
+
+namespace {
+  template <typename T>
+  class BasicIterableWithConstDeref {
+   private:
+    T* data;
+    std::size_t size;
+    bool was_moved_from_ = false;
+
+   public:
+    BasicIterableWithConstDeref(std::initializer_list<T> il)
+        : data{new T[il.size()]}, size{il.size()} {
+      // would like to use enumerate, can't because it's for unit
+      // testing enumerate
+      std::size_t i = 0;
+      for (auto&& e : il) {
+        data[i] = e;
+        ++i;
+      }
     }
 
-    SECTION("with callable object") {
-        auto s = sorted(ns, IntGreaterThan{});
-        v.insert(v.begin(), std::begin(s), std::end(s));
+    BasicIterableWithConstDeref& operator=(
+        BasicIterableWithConstDeref&&) = delete;
+    BasicIterableWithConstDeref& operator=(
+        const BasicIterableWithConstDeref&) = delete;
+    BasicIterableWithConstDeref(const BasicIterableWithConstDeref&) = delete;
+
+    BasicIterableWithConstDeref(BasicIterableWithConstDeref&& other)
+        : data{other.data}, size{other.size} {
+      other.data = nullptr;
+      other.was_moved_from_ = true;
     }
 
-    SECTION("with lambda") {
-        auto s = sorted(ns, [](int lhs, int rhs){return lhs > rhs;});
-        v.insert(v.begin(), std::begin(s), std::end(s));
+    bool was_moved_from() const {
+      return this->was_moved_from_;
     }
 
-    Vec vc = {4, 3, 2, 1, 0};
-    REQUIRE( v == vc );
-}
+    ~BasicIterableWithConstDeref() {
+      delete[] this->data;
+    }
 
-namespace {
-template <typename T>
-class BasicIterableWithConstDeref {
-    private:
-        T *data;
-        std::size_t size;
-        bool was_moved_from_ = false;
-    public:
-        BasicIterableWithConstDeref(std::initializer_list<T> il)
-            : data{new T[il.size()]},
-            size{il.size()}
-        {
-            // would like to use enumerate, can't because it's for unit
-            // testing enumerate
-            std::size_t i = 0;
-            for (auto&& e : il) {
-                data[i] = e;
-                ++i;
-            }
-        }
-
-        BasicIterableWithConstDeref& operator=(BasicIterableWithConstDeref&&) = delete;
-        BasicIterableWithConstDeref& operator=(const BasicIterableWithConstDeref&) = delete;
-        BasicIterableWithConstDeref(const BasicIterableWithConstDeref&) = delete;
-
-        BasicIterableWithConstDeref(BasicIterableWithConstDeref&& other)
-            : data{other.data},
-            size{other.size}
-        {
-            other.data = nullptr;
-            other.was_moved_from_ = true;
-        }
-
-        bool was_moved_from() const {
-            return this->was_moved_from_;
-        }
-
-        ~BasicIterableWithConstDeref() {
-            delete [] this->data;
-        }
-
-        class Iterator {
-            private:
-                T *p;
-            public:
-                Iterator(T *b) : p{b} { }
-                bool operator!=(const Iterator& other) const {
-                    return this->p != other.p;
-                }
-
-                Iterator& operator++() {
-                    ++this->p;
-                    return *this;
-                }
-
-                T& operator*() {
-                    return *this->p;
-                }
-
-                const T& operator*() const {
-                    return *this->p;
-                }
-        };
-
-        Iterator begin() {
-            return {this->data};
-        }
-
-        Iterator end() {
-            return {this->data + this->size};
-        }
-};
+    class Iterator {
+     private:
+      T* p;
+
+     public:
+      Iterator(T* b) : p{b} {}
+      bool operator!=(const Iterator& other) const {
+        return this->p != other.p;
+      }
+
+      Iterator& operator++() {
+        ++this->p;
+        return *this;
+      }
+
+      T& operator*() {
+        return *this->p;
+      }
+
+      const T& operator*() const {
+        return *this->p;
+      }
+    };
+
+    Iterator begin() {
+      return {this->data};
+    }
+
+    Iterator end() {
+      return {this->data + this->size};
+    }
+  };
 }
 
 TEST_CASE("sorted: moves rvalues and binds to lvalues", "[sorted]") {
-    BasicIterableWithConstDeref<int> bi{1, 2};
-    sorted(bi);
-    REQUIRE_FALSE( bi.was_moved_from() );
+  BasicIterableWithConstDeref<int> bi{1, 2};
+  sorted(bi);
+  REQUIRE_FALSE(bi.was_moved_from());
 
-    sorted(std::move(bi));
-    REQUIRE( bi.was_moved_from() );
+  sorted(std::move(bi));
+  REQUIRE(bi.was_moved_from());
 }
 
 TEST_CASE("sorted: doesn't move or copy elements of iterable", "[sorted]") {
-    using itertest::SolidInt;
-    constexpr SolidInt arr[] = {{6}, {7}, {8}};
-    for (auto&& i : sorted(arr, [](const SolidInt& lhs, const SolidInt& rhs){
-                return lhs.getint() < rhs.getint();})) {
-        (void)i;
-    }
+  using itertest::SolidInt;
+  constexpr SolidInt arr[] = {{6}, {7}, {8}};
+  for (auto &&i : sorted(arr, [](const SolidInt &lhs, const SolidInt &rhs) {
+         return lhs.getint() < rhs.getint();
+       })) {
+    (void)i;
+  }
+}
+
+template <typename T>
+using ImpT = decltype(sorted(std::declval<T>()));
+TEST_CASE("sorted: has correct ctor and assign ops", "[sorted]") {
+  REQUIRE(itertest::IsMoveConstructibleOnly<ImpT<std::string&>>::value);
+  REQUIRE(itertest::IsMoveConstructibleOnly<ImpT<std::string>>::value);
 }

From 1bff0b7470156523566fa654b2ceac7c2c9ebfbb Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 6 Sep 2015 23:25:43 -0700
Subject: [PATCH 1337/1866] tests takewhile impl has move ctor only

---
 test/test_takewhile.cpp | 137 +++++++++++++++++++++-------------------
 1 file changed, 73 insertions(+), 64 deletions(-)

diff --git a/test/test_takewhile.cpp b/test/test_takewhile.cpp
index 1d28b4d2..de3ecb60 100644
--- a/test/test_takewhile.cpp
+++ b/test/test_takewhile.cpp
@@ -11,93 +11,102 @@
 using iter::takewhile;
 using Vec = const std::vector<int>;
 
-
 namespace {
-    bool under_ten(int i) {
-        return i < 10;
-    }
+  bool under_ten(int i) {
+    return i < 10;
+  }
 
-    struct UnderTen {
-        bool operator()(int i) {
-            return i < 10;
-        }
-    };
+  struct UnderTen {
+    bool operator()(int i) {
+      return i < 10;
+    }
+  };
 }
 
 TEST_CASE("takewhile: works with lambda, callable, and function pointer",
-        "[takewhile]") {
-    Vec ns = {1, 3, 5, 20, 2, 4, 6, 8};
-    SECTION("function pointer") {
-        auto tw = takewhile(under_ten, ns);
-        Vec v(std::begin(tw), std::end(tw));
-        Vec vc = {1, 3, 5};
-        REQUIRE( v == vc );
-    }
+    "[takewhile]") {
+  Vec ns = {1, 3, 5, 20, 2, 4, 6, 8};
+  SECTION("function pointer") {
+    auto tw = takewhile(under_ten, ns);
+    Vec v(std::begin(tw), std::end(tw));
+    Vec vc = {1, 3, 5};
+    REQUIRE(v == vc);
+  }
 
-    SECTION("callable object") {
-        auto tw = takewhile(UnderTen{}, ns);
-        Vec v(std::begin(tw), std::end(tw));
-        Vec vc = {1, 3, 5};
-        REQUIRE( v == vc );
-    }
+  SECTION("callable object") {
+    auto tw = takewhile(UnderTen{}, ns);
+    Vec v(std::begin(tw), std::end(tw));
+    Vec vc = {1, 3, 5};
+    REQUIRE(v == vc);
+  }
 
-    SECTION("lambda") {
-        auto tw = takewhile([](int i){ return i < 10; }, ns);
-        Vec v(std::begin(tw), std::end(tw));
-        Vec vc = {1, 3, 5};
-        REQUIRE( v == vc );
-    }
+  SECTION("lambda") {
+    auto tw = takewhile([](int i) { return i < 10; }, ns);
+    Vec v(std::begin(tw), std::end(tw));
+    Vec vc = {1, 3, 5};
+    REQUIRE(v == vc);
+  }
 }
 
 TEST_CASE("takewhile: everything passes predicate", "[takewhile]") {
-    Vec ns{1, 2, 3};
-    auto tw = takewhile(under_ten, ns);
-    Vec v(std::begin(tw), std::end(tw));
-    Vec vc = {1, 2, 3};
+  Vec ns{1, 2, 3};
+  auto tw = takewhile(under_ten, ns);
+  Vec v(std::begin(tw), std::end(tw));
+  Vec vc = {1, 2, 3};
 }
 
 TEST_CASE("takewhile: empty iterable is empty", "[takewhile]") {
-    Vec ns{};
-    auto tw = takewhile(under_ten, ns);
-    REQUIRE( std::begin(tw) == std::end(tw) );
+  Vec ns{};
+  auto tw = takewhile(under_ten, ns);
+  REQUIRE(std::begin(tw) == std::end(tw));
 }
 
-TEST_CASE("takewhile: when first element fails predicate, it's empty"
-        "[takewhile]") {
-    SECTION("First element is only element") {
-        Vec ns = {20};
-        auto tw = takewhile(under_ten, ns);
-        REQUIRE( std::begin(tw) == std::end(tw) );
-    }
+TEST_CASE(
+    "takewhile: when first element fails predicate, it's empty"
+    "[takewhile]") {
+  SECTION("First element is only element") {
+    Vec ns = {20};
+    auto tw = takewhile(under_ten, ns);
+    REQUIRE(std::begin(tw) == std::end(tw));
+  }
 
-    SECTION("First element followed by elements that pass") {
-        Vec ns = {20, 1, 1};
-        auto tw = takewhile(under_ten, ns);
-        REQUIRE( std::begin(tw) == std::end(tw) );
-    }
+  SECTION("First element followed by elements that pass") {
+    Vec ns = {20, 1, 1};
+    auto tw = takewhile(under_ten, ns);
+    REQUIRE(std::begin(tw) == std::end(tw));
+  }
 }
 
 TEST_CASE("takewhile: moves rvalues, binds to lvalues", "[takewhile]") {
-    itertest::BasicIterable<int> bi{1, 2};
-    takewhile(under_ten, bi);
-    REQUIRE_FALSE( bi.was_moved_from() );
+  itertest::BasicIterable<int> bi{1, 2};
+  takewhile(under_ten, bi);
+  REQUIRE_FALSE(bi.was_moved_from());
 
-    takewhile(under_ten, std::move(bi));
-    REQUIRE( bi.was_moved_from() );
+  takewhile(under_ten, std::move(bi));
+  REQUIRE(bi.was_moved_from());
 }
 
-TEST_CASE("takewhile: with iterable doesn't move or copy elements",
-        "[takewhile]") {
-    constexpr std::array<itertest::SolidInt, 3> arr{{{8}, {9}, {10}}};
-    auto func =
-        [](const itertest::SolidInt& si){return si.getint() < 10;};
-    for (auto&& i : takewhile(func, arr)) {
-        (void)i;
-    }
+TEST_CASE(
+    "takewhile: with iterable doesn't move or copy elements", "[takewhile]") {
+  constexpr std::array<itertest::SolidInt, 3> arr{{{8}, {9}, {10}}};
+  auto func = [](const itertest::SolidInt& si) { return si.getint() < 10; };
+  for (auto&& i : takewhile(func, arr)) {
+    (void)i;
+  }
 }
 
 TEST_CASE("takewhile: iterator meets requirements", "[takewhile]") {
-    std::string s{};
-    auto c = takewhile([]{return true;}, s);
-    REQUIRE( itertest::IsIterator<decltype(std::begin(c))>::value );
+  std::string s{};
+  auto c = takewhile([] { return true; }, s);
+  REQUIRE(itertest::IsIterator<decltype(std::begin(c))>::value);
+}
+
+template <typename T, typename U>
+using ImpT = decltype(takewhile(std::declval<T>(), std::declval<U>()));
+TEST_CASE("takewhile: has correct ctor and assign ops", "[takewhile]") {
+  using T1 = ImpT<bool (*)(char c), std::string&>;
+  auto lam = [](char) { return false; };
+  using T2 = ImpT<decltype(lam), std::string>;
+  REQUIRE(itertest::IsMoveConstructibleOnly<T1>::value);
+  REQUIRE(itertest::IsMoveConstructibleOnly<T2>::value);
 }

From cc3bcd3d0f0e53a877e3c176e52c357f172480e5 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 6 Sep 2015 23:25:52 -0700
Subject: [PATCH 1338/1866] tests justseen impl has move ctor only

---
 test/test_unique_justseen.cpp | 54 ++++++++++++++++++++---------------
 1 file changed, 31 insertions(+), 23 deletions(-)

diff --git a/test/test_unique_justseen.cpp b/test/test_unique_justseen.cpp
index 4285f364..1167594f 100644
--- a/test/test_unique_justseen.cpp
+++ b/test/test_unique_justseen.cpp
@@ -13,40 +13,48 @@ using iter::unique_justseen;
 using Vec = const std::vector<int>;
 
 TEST_CASE("unique justseen: adjacent repeating values", "[unique_justseen]") {
-    Vec ns = {1,1,1,2,2,3,4,4,5,6,7,8,8,8,8,9,9};
-    auto ue = unique_justseen(ns);
-    Vec v(std::begin(ue), std::end(ue));
-    Vec vc = {1,2,3,4,5,6,7,8,9};
-    REQUIRE( v == vc );
+  Vec ns = {1, 1, 1, 2, 2, 3, 4, 4, 5, 6, 7, 8, 8, 8, 8, 9, 9};
+  auto ue = unique_justseen(ns);
+  Vec v(std::begin(ue), std::end(ue));
+  Vec vc = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("unique justseen: some repeating values", "[unique_justseen]") {
-    Vec ns = {1,2,2,3,4,4,5,6,6};
-    auto ue = unique_justseen(ns);
-    Vec v(std::begin(ue), std::end(ue));
-    Vec vc = {1,2,3,4,5,6};
-    REQUIRE( v == vc );
+  Vec ns = {1, 2, 2, 3, 4, 4, 5, 6, 6};
+  auto ue = unique_justseen(ns);
+  Vec v(std::begin(ue), std::end(ue));
+  Vec vc = {1, 2, 3, 4, 5, 6};
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("unique justseen: doesn't omit non-adjacent duplicates",
-        "[unique_justseen]") {
-    Vec ns = {1,2,3,2,1,2,3,2,1};
-    auto ue = unique_justseen(ns);
-    Vec v(std::begin(ue), std::end(ue));
-    REQUIRE( v == ns );
+    "[unique_justseen]") {
+  Vec ns = {1, 2, 3, 2, 1, 2, 3, 2, 1};
+  auto ue = unique_justseen(ns);
+  Vec v(std::begin(ue), std::end(ue));
+  REQUIRE(v == ns);
 }
 
 TEST_CASE("unique justseen: moves and binds correctly", "[unique_justseen]") {
-    itertest::BasicIterable<int> bi{1, 2};
-    unique_justseen(bi);
-    REQUIRE_FALSE( bi.was_moved_from() );
+  itertest::BasicIterable<int> bi{1, 2};
+  unique_justseen(bi);
+  REQUIRE_FALSE(bi.was_moved_from());
 
-    unique_justseen(std::move(bi));
-    REQUIRE( bi.was_moved_from() );
+  unique_justseen(std::move(bi));
+  REQUIRE(bi.was_moved_from());
 }
 
 TEST_CASE("unique_justseen: iterator meets requirements", "[unique_justseen]") {
-    std::string s{};
-    auto c = unique_justseen(s);
-    REQUIRE( itertest::IsIterator<decltype(std::begin(c))>::value );
+  std::string s{};
+  auto c = unique_justseen(s);
+  REQUIRE(itertest::IsIterator<decltype(std::begin(c))>::value);
+}
+
+template <typename T>
+using ImpT = decltype(unique_justseen(std::declval<T>()));
+TEST_CASE(
+    "unique_justseen: has correct ctor and assign ops", "[unique_justseen]") {
+  REQUIRE(itertest::IsMoveConstructibleOnly<ImpT<std::string&>>::value);
+  REQUIRE(itertest::IsMoveConstructibleOnly<ImpT<std::string>>::value);
 }

From a43682efeed5f4165a05387f630b571b7c268b7b Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 6 Sep 2015 23:26:17 -0700
Subject: [PATCH 1339/1866] tests everseen impl has move ctor only

---
 test/test_unique_everseen.cpp | 52 ++++++++++++++++++++---------------
 1 file changed, 30 insertions(+), 22 deletions(-)

diff --git a/test/test_unique_everseen.cpp b/test/test_unique_everseen.cpp
index 4cd94cd2..76151efe 100644
--- a/test/test_unique_everseen.cpp
+++ b/test/test_unique_everseen.cpp
@@ -13,34 +13,42 @@ using iter::unique_everseen;
 using Vec = const std::vector<int>;
 
 TEST_CASE("unique everseen: adjacent repeating values", "[unique_everseen]") {
-    Vec ns = {1,1,1,2,2,3,4,4,5,6,7,8,8,8,8,9,9};
-    auto ue = unique_everseen(ns);
-    Vec v(std::begin(ue), std::end(ue));
-    Vec vc = {1,2,3,4,5,6,7,8,9};
-    REQUIRE( v == vc );
+  Vec ns = {1, 1, 1, 2, 2, 3, 4, 4, 5, 6, 7, 8, 8, 8, 8, 9, 9};
+  auto ue = unique_everseen(ns);
+  Vec v(std::begin(ue), std::end(ue));
+  Vec vc = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+  REQUIRE(v == vc);
 }
 
-TEST_CASE("unique everseen: nonadjacent repeating values",
-        "[unique_everseen]") {
-    Vec ns = {1,2,3,4,3,2,1,5,6};
-    auto ue = unique_everseen(ns);
-    Vec v(std::begin(ue), std::end(ue));
-    Vec vc = {1,2,3,4,5,6};
-    REQUIRE( v == vc );
+TEST_CASE(
+    "unique everseen: nonadjacent repeating values", "[unique_everseen]") {
+  Vec ns = {1, 2, 3, 4, 3, 2, 1, 5, 6};
+  auto ue = unique_everseen(ns);
+  Vec v(std::begin(ue), std::end(ue));
+  Vec vc = {1, 2, 3, 4, 5, 6};
+  REQUIRE(v == vc);
 }
 
-TEST_CASE("unique everseen: moves rvalues, binds to lvalues",
-        "[unique_everseen]") {
-    itertest::BasicIterable<int> bi{1, 2};
-    unique_everseen(bi);
-    REQUIRE_FALSE( bi.was_moved_from() );
+TEST_CASE(
+    "unique everseen: moves rvalues, binds to lvalues", "[unique_everseen]") {
+  itertest::BasicIterable<int> bi{1, 2};
+  unique_everseen(bi);
+  REQUIRE_FALSE(bi.was_moved_from());
 
-    unique_everseen(std::move(bi));
-    REQUIRE( bi.was_moved_from() );
+  unique_everseen(std::move(bi));
+  REQUIRE(bi.was_moved_from());
 }
 
 TEST_CASE("unique_everseen: iterator meets requirements", "[unique_everseen]") {
-    std::string s{};
-    auto c = unique_everseen(s);
-    REQUIRE( itertest::IsIterator<decltype(std::begin(c))>::value );
+  std::string s{};
+  auto c = unique_everseen(s);
+  REQUIRE(itertest::IsIterator<decltype(std::begin(c))>::value);
+}
+
+template <typename T>
+using ImpT = decltype(unique_everseen(std::declval<T>()));
+TEST_CASE(
+    "unique_everseen: has correct ctor and assign ops", "[unique_everseen]") {
+  REQUIRE(itertest::IsMoveConstructibleOnly<ImpT<std::string&>>::value);
+  REQUIRE(itertest::IsMoveConstructibleOnly<ImpT<std::string>>::value);
 }

From cb0363a2bf72788a00a68ae596d5ae27a37cdc29 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 6 Sep 2015 23:26:32 -0700
Subject: [PATCH 1340/1866] tests zip has move ctor only

---
 test/test_zip.cpp | 123 ++++++++++++++++++++++++----------------------
 1 file changed, 65 insertions(+), 58 deletions(-)

diff --git a/test/test_zip.cpp b/test/test_zip.cpp
index f099c8eb..d8cb80e5 100644
--- a/test/test_zip.cpp
+++ b/test/test_zip.cpp
@@ -17,93 +17,100 @@ using itertest::BasicIterable;
 using itertest::SolidInt;
 
 TEST_CASE("zip: Simple case, same length", "[zip]") {
-    using Tu = std::tuple<int, char, double>;
-    using ResVec = const std::vector<Tu>;
-    std::vector<int> iv {10, 20, 30};
-    std::string s{"hey"};
-    double arr[] = {1.0, 2.0, 4.0};
-
-    auto z = zip(iv, s, arr);
-    ResVec v(std::begin(z), std::end(z));
-    ResVec vc {Tu{10, 'h', 1.0}, Tu{20, 'e', 2.0}, Tu{30, 'y', 4.0}};
-    REQUIRE( v == vc );
+  using Tu = std::tuple<int, char, double>;
+  using ResVec = const std::vector<Tu>;
+  std::vector<int> iv{10, 20, 30};
+  std::string s{"hey"};
+  double arr[] = {1.0, 2.0, 4.0};
+
+  auto z = zip(iv, s, arr);
+  ResVec v(std::begin(z), std::end(z));
+  ResVec vc{Tu{10, 'h', 1.0}, Tu{20, 'e', 2.0}, Tu{30, 'y', 4.0}};
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("zip: One empty, all empty", "[zip]") {
-    std::vector<int> iv = {1,2,3};
-    std::string s{};
-    auto z = zip(iv, s);
-    REQUIRE_FALSE( std::begin(z) != std::end(z) );
-    auto z2 = zip(s, iv);
-    REQUIRE_FALSE( std::begin(z2) != std::end(z2) );
+  std::vector<int> iv = {1, 2, 3};
+  std::string s{};
+  auto z = zip(iv, s);
+  REQUIRE_FALSE(std::begin(z) != std::end(z));
+  auto z2 = zip(s, iv);
+  REQUIRE_FALSE(std::begin(z2) != std::end(z2));
 }
 
 TEST_CASE("zip: terminates on shortest sequence", "[zip]") {
-    std::vector<int> iv{1,2,3,4,5};
-    std::string s{"hi"};
-    auto z = zip(iv, s);
+  std::vector<int> iv{1, 2, 3, 4, 5};
+  std::string s{"hi"};
+  auto z = zip(iv, s);
 
-    REQUIRE( std::distance(std::begin(z), std::end(z)) == 2 );
+  REQUIRE(std::distance(std::begin(z), std::end(z)) == 2);
 }
 
 TEST_CASE("zip: Empty", "[zip]") {
-    auto z = zip();
-    REQUIRE_FALSE( std::begin(z) != std::end(z) );
+  auto z = zip();
+  REQUIRE_FALSE(std::begin(z) != std::end(z));
 }
 
 TEST_CASE("zip: Modify sequence through zip", "[zip]") {
-    std::vector<int> iv{1,2,3};
-    std::vector<int> iv2{1,2,3,4};
-    for (auto&& t : zip(iv, iv2)) {
-        std::get<0>(t) = -1;
-        std::get<1>(t) = -1;
-    }
-
-    const std::vector<int> vc{-1, -1, -1};
-    const std::vector<int> vc2{-1, -1, -1, 4};
-    REQUIRE( iv == vc);
-    REQUIRE( iv2 == vc2);
+  std::vector<int> iv{1, 2, 3};
+  std::vector<int> iv2{1, 2, 3, 4};
+  for (auto&& t : zip(iv, iv2)) {
+    std::get<0>(t) = -1;
+    std::get<1>(t) = -1;
+  }
+
+  const std::vector<int> vc{-1, -1, -1};
+  const std::vector<int> vc2{-1, -1, -1, 4};
+  REQUIRE(iv == vc);
+  REQUIRE(iv2 == vc2);
 }
 
 TEST_CASE("zip: binds reference when it should", "[zip]") {
-    BasicIterable<char> bi{'x', 'y', 'z'};
-    zip(bi);
-    REQUIRE_FALSE( bi.was_moved_from() );
+  BasicIterable<char> bi{'x', 'y', 'z'};
+  zip(bi);
+  REQUIRE_FALSE(bi.was_moved_from());
 }
 
 TEST_CASE("zip: moves rvalues", "[zip]") {
-    BasicIterable<char> bi{'x', 'y', 'z'};
-    zip(std::move(bi));
-    REQUIRE( bi.was_moved_from() );
+  BasicIterable<char> bi{'x', 'y', 'z'};
+  zip(std::move(bi));
+  REQUIRE(bi.was_moved_from());
 }
 
 TEST_CASE("zip: Can bind ref and move in single zip", "[zip]") {
-    BasicIterable<char> b1{'x', 'y', 'z'};
-    BasicIterable<char> b2{'a', 'b'};
-    zip(b1, std::move(b2));
-    REQUIRE_FALSE( b1.was_moved_from() );
-    REQUIRE( b2.was_moved_from() );
+  BasicIterable<char> b1{'x', 'y', 'z'};
+  BasicIterable<char> b2{'a', 'b'};
+  zip(b1, std::move(b2));
+  REQUIRE_FALSE(b1.was_moved_from());
+  REQUIRE(b2.was_moved_from());
 }
 
 TEST_CASE("zip: doesn't move or copy elements of iterable", "[zip]") {
-    constexpr SolidInt arr[] = {{6}, {7}, {8}};
-    for (auto&& t : zip(arr)) {
-        (void)std::get<0>(t);
-    }
+  constexpr SolidInt arr[] = {{6}, {7}, {8}};
+  for (auto&& t : zip(arr)) {
+    (void)std::get<0>(t);
+  }
 }
 
 TEST_CASE("zip: postfix ++", "[zip]") {
-    const std::vector<int> v = {1};
-    auto z = zip(v);
-    auto it = std::begin(z);
-    it++;
-    REQUIRE( it == std::end(z) );
+  const std::vector<int> v = {1};
+  auto z = zip(v);
+  auto it = std::begin(z);
+  it++;
+  REQUIRE(it == std::end(z));
 }
 
 TEST_CASE("zip: iterator meets requirements", "[zip]") {
-    std::string s{};
-    auto c = zip(s);
-    REQUIRE( itertest::IsIterator<decltype(std::begin(c))>::value );
-    auto c2 = zip(s, s);
-    REQUIRE( itertest::IsIterator<decltype(std::begin(c2))>::value );
+  std::string s{};
+  auto c = zip(s);
+  REQUIRE(itertest::IsIterator<decltype(std::begin(c))>::value);
+  auto c2 = zip(s, s);
+  REQUIRE(itertest::IsIterator<decltype(std::begin(c2))>::value);
+}
+
+template <typename... Ts>
+using ImpT = decltype(zip(std::declval<Ts>()...));
+TEST_CASE("zip: has correct ctor and assign ops", "[zip]") {
+  using T = ImpT<std::string&, std::vector<double>, std::vector<std::string>>;
+  REQUIRE(itertest::IsMoveConstructibleOnly<T>::value);
 }

From 7a7dc8b9ba0dbb0a43b34c08e5ae20ee372d507e Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 6 Sep 2015 23:26:40 -0700
Subject: [PATCH 1341/1866] tests zip_longest has move ctor only

---
 test/test_zip_longest.cpp | 198 ++++++++++++++++++--------------------
 1 file changed, 96 insertions(+), 102 deletions(-)

diff --git a/test/test_zip_longest.cpp b/test/test_zip_longest.cpp
index 6fe8cf5a..c8694e9e 100644
--- a/test/test_zip_longest.cpp
+++ b/test/test_zip_longest.cpp
@@ -17,135 +17,129 @@ using iter::zip_longest;
 
 // reopening boost is the only way I can find that gets this to print
 namespace boost {
-template <typename T>
-std::ostream& operator<<(std::ostream& out, const optional<T>& opt) {
+  template <typename T>
+  std::ostream& operator<<(std::ostream& out, const optional<T>& opt) {
     if (opt) {
-        out << "Just " << *opt;
+      out << "Just " << *opt;
     } else {
-        out << "Nothing";
+      out << "Nothing";
     }
     return out;
-}
+  }
 }
 
 template <typename... Ts>
 using const_opt_tuple = std::tuple<boost::optional<const Ts&>...>;
 
-TEST_CASE("zip longest: correctly detects longest at any position",
-        "[zip_longest]") {
-
-    const std::vector<int> ivec{2, 4, 6, 8, 10, 12};
-    const std::vector<std::string> svec{"abc", "def", "xyz"};
-    const std::string str{"hello"};
-
-    SECTION("longest first") {
-        using TP = const_opt_tuple<int, std::string, char>;
-        using ResVec = std::vector<TP>;
-
-        auto zl = zip_longest(ivec, svec, str);
-        ResVec results(std::begin(zl), std::end(zl));
-        ResVec rc = {
-            TP{{ivec[0]},  {svec[0]},   {str[0]}},
-            TP{{ivec[1]},  {svec[1]},   {str[1]}},
-            TP{{ivec[2]},  {svec[2]},   {str[2]}},
-            TP{{ivec[3]},  {},          {str[3]}},
-            TP{{ivec[4]},  {},          {str[4]}},
-            TP{{ivec[5]},  {},          {}    }
-        };
-
-        REQUIRE( results == rc );
-    }
+TEST_CASE(
+    "zip longest: correctly detects longest at any position", "[zip_longest]") {
+  const std::vector<int> ivec{2, 4, 6, 8, 10, 12};
+  const std::vector<std::string> svec{"abc", "def", "xyz"};
+  const std::string str{"hello"};
 
-    SECTION("longest in middle") {
-        using TP = const_opt_tuple<std::string, int, char>;
-        using ResVec = std::vector<TP>;
-
-        auto zl = zip_longest(svec, ivec, str);
-        ResVec results(std::begin(zl), std::end(zl));
-        ResVec rc = {
-            TP{{svec[0]},   {ivec[0]},  {str[0]}},
-            TP{{svec[1]},   {ivec[1]},  {str[1]}},
-            TP{{svec[2]},   {ivec[2]},  {str[2]}},
-            TP{{},          {ivec[3]},  {str[3]}},
-            TP{{},          {ivec[4]},  {str[4]}},
-            TP{{},          {ivec[5]},  {}    }
-        };
-
-        REQUIRE( results == rc );
-    }
+  SECTION("longest first") {
+    using TP = const_opt_tuple<int, std::string, char>;
+    using ResVec = std::vector<TP>;
 
-    SECTION("longest at end") {
-        using TP = const_opt_tuple<std::string, char, int>;
-        using ResVec = std::vector<TP>;
-
-        auto zl = zip_longest(svec, str, ivec);
-        ResVec results(std::begin(zl), std::end(zl));
-        ResVec rc = {
-            TP{{svec[0]},   {str[0]},   {ivec[0]}},
-            TP{{svec[1]},   {str[1]},   {ivec[1]}},
-            TP{{svec[2]},   {str[2]},   {ivec[2]}},
-            TP{{},          {str[3]},   {ivec[3]}},
-            TP{{},          {str[4]},   {ivec[4]}},
-            TP{{},          {},         {ivec[5]}}
-        };
-
-        REQUIRE( results == rc );
-    }
+    auto zl = zip_longest(ivec, svec, str);
+    ResVec results(std::begin(zl), std::end(zl));
+    ResVec rc = {TP{{ivec[0]}, {svec[0]}, {str[0]}},
+        TP{{ivec[1]}, {svec[1]}, {str[1]}}, TP{{ivec[2]}, {svec[2]}, {str[2]}},
+        TP{{ivec[3]}, {}, {str[3]}}, TP{{ivec[4]}, {}, {str[4]}},
+        TP{{ivec[5]}, {}, {}}};
+
+    REQUIRE(results == rc);
+  }
+
+  SECTION("longest in middle") {
+    using TP = const_opt_tuple<std::string, int, char>;
+    using ResVec = std::vector<TP>;
+
+    auto zl = zip_longest(svec, ivec, str);
+    ResVec results(std::begin(zl), std::end(zl));
+    ResVec rc = {TP{{svec[0]}, {ivec[0]}, {str[0]}},
+        TP{{svec[1]}, {ivec[1]}, {str[1]}}, TP{{svec[2]}, {ivec[2]}, {str[2]}},
+        TP{{}, {ivec[3]}, {str[3]}}, TP{{}, {ivec[4]}, {str[4]}},
+        TP{{}, {ivec[5]}, {}}};
+
+    REQUIRE(results == rc);
+  }
+
+  SECTION("longest at end") {
+    using TP = const_opt_tuple<std::string, char, int>;
+    using ResVec = std::vector<TP>;
+
+    auto zl = zip_longest(svec, str, ivec);
+    ResVec results(std::begin(zl), std::end(zl));
+    ResVec rc = {TP{{svec[0]}, {str[0]}, {ivec[0]}},
+        TP{{svec[1]}, {str[1]}, {ivec[1]}}, TP{{svec[2]}, {str[2]}, {ivec[2]}},
+        TP{{}, {str[3]}, {ivec[3]}}, TP{{}, {str[4]}, {ivec[4]}},
+        TP{{}, {}, {ivec[5]}}};
+
+    REQUIRE(results == rc);
+  }
 }
 
-TEST_CASE("zip longest: when all are empty, terminates right away",
-        "[zip_longest]") {
-    const std::vector<int> ivec{};
-    const std::vector<std::string> svec{};
-    const std::string str{};
+TEST_CASE(
+    "zip longest: when all are empty, terminates right away", "[zip_longest]") {
+  const std::vector<int> ivec{};
+  const std::vector<std::string> svec{};
+  const std::string str{};
 
-    auto zl = zip_longest(ivec, svec, str);
-    REQUIRE( std::begin(zl) == std::end(zl) );
+  auto zl = zip_longest(ivec, svec, str);
+  REQUIRE(std::begin(zl) == std::end(zl));
 }
 
 TEST_CASE("zip longest: can modify zipped sequences", "[zip_longest]") {
-    std::vector<int> ns1 = {1, 2, 3};
-    std::vector<int> ns2 = {10, 11, 12};
-    for (auto&& t : zip_longest(ns1, ns2)) {
-        *std::get<0>(t) = -1;
-        *std::get<1>(t) = -1;
-    }
-
-    std::vector<int> vc = {-1, -1, -1};
-    REQUIRE( ns1 == vc );
-    REQUIRE( ns2 == vc );
+  std::vector<int> ns1 = {1, 2, 3};
+  std::vector<int> ns2 = {10, 11, 12};
+  for (auto&& t : zip_longest(ns1, ns2)) {
+    *std::get<0>(t) = -1;
+    *std::get<1>(t) = -1;
+  }
+
+  std::vector<int> vc = {-1, -1, -1};
+  REQUIRE(ns1 == vc);
+  REQUIRE(ns2 == vc);
 }
 
 TEST_CASE("zip longest: empty zip_longest() is empty", "[zip_longest]") {
-    auto zl = zip_longest();
-    REQUIRE( std::begin(zl) == std::end(zl) );
-    REQUIRE_FALSE( std::begin(zl) != std::end(zl) );
+  auto zl = zip_longest();
+  REQUIRE(std::begin(zl) == std::end(zl));
+  REQUIRE_FALSE(std::begin(zl) != std::end(zl));
 }
 
 TEST_CASE("zip_longest: binds to lvalues, moves rvalues", "[zip_longest]") {
-    itertest::BasicIterable<char> b1{'x', 'y', 'z'};
-    itertest::BasicIterable<char> b2{'a', 'b'};
-    SECTION("bind to first, moves second") {
-        zip_longest(b1, std::move(b2));
-    }
-    SECTION("move first, bind to second") {
-        zip_longest(std::move(b2), b1);
-    }
-    REQUIRE_FALSE( b1.was_moved_from() );
-    REQUIRE( b2.was_moved_from() );
+  itertest::BasicIterable<char> b1{'x', 'y', 'z'};
+  itertest::BasicIterable<char> b2{'a', 'b'};
+  SECTION("bind to first, moves second") {
+    zip_longest(b1, std::move(b2));
+  }
+  SECTION("move first, bind to second") {
+    zip_longest(std::move(b2), b1);
+  }
+  REQUIRE_FALSE(b1.was_moved_from());
+  REQUIRE(b2.was_moved_from());
 }
 
 TEST_CASE("zip_longest: doesn't move or copy elements", "[zip_longest]") {
-    constexpr itertest::SolidInt arr[] = {{6}, {7}, {8}};
-    for (auto&& t : zip_longest(arr, arr)) {
-        (void)std::get<0>(t);
-    }
+  constexpr itertest::SolidInt arr[] = {{6}, {7}, {8}};
+  for (auto&& t : zip_longest(arr, arr)) {
+    (void)std::get<0>(t);
+  }
 }
 
 TEST_CASE("zip_longest: iterator meets requirements", "[zip_longest]") {
-    std::string s{};
-    auto c = zip_longest(s);
-    REQUIRE( itertest::IsIterator<decltype(std::begin(c))>::value );
-    auto c2 = zip_longest(s, s);
-    REQUIRE( itertest::IsIterator<decltype(std::begin(c2))>::value );
+  std::string s{};
+  auto c = zip_longest(s);
+  REQUIRE(itertest::IsIterator<decltype(std::begin(c))>::value);
+  auto c2 = zip_longest(s, s);
+  REQUIRE(itertest::IsIterator<decltype(std::begin(c2))>::value);
+}
+
+template <typename... Ts>
+using ImpT = decltype(zip_longest(std::declval<Ts>()...));
+TEST_CASE("zip_longest: has correct ctor and assign ops", "[zip_longest]") {
+  using T = ImpT<std::string&, std::vector<double>, std::vector<std::string>>;
+  REQUIRE(itertest::IsMoveConstructibleOnly<T>::value);
 }

From b5d12cd2881724d11176857cfbfc348908981d91 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 6 Sep 2015 23:27:07 -0700
Subject: [PATCH 1342/1866] formats tests

---
 test/test_count.cpp            |  74 +++++----
 test/test_helpers.cpp          |  94 +++++------
 test/test_iteratoriterator.cpp |  82 ++++-----
 test/test_mixed.cpp            | 179 ++++++++++----------
 test/test_range.cpp            | 296 ++++++++++++++++-----------------
 5 files changed, 360 insertions(+), 365 deletions(-)

diff --git a/test/test_count.cpp b/test/test_count.cpp
index 0b861bbf..643819ea 100644
--- a/test/test_count.cpp
+++ b/test/test_count.cpp
@@ -10,60 +10,62 @@
 using iter::count;
 
 TEST_CASE("count: watch for 10 elements", "[count]") {
-    std::vector<int> v{};
-    for (auto i : count()) {
-        v.push_back(i);
-        if (i == 9) break;
-    }
+  std::vector<int> v{};
+  for (auto i : count()) {
+    v.push_back(i);
+    if (i == 9) break;
+  }
 
-    const std::vector<int> vc{0,1,2,3,4,5,6,7,8,9};
-    REQUIRE( v == vc );
+  const std::vector<int> vc{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("count: start at 10", "[count]") {
-    std::vector<int> v{};
-    for (auto i : count(10)) {
-        v.push_back(i);
-        if (i == 14) break;
-    }
+  std::vector<int> v{};
+  for (auto i : count(10)) {
+    v.push_back(i);
+    if (i == 14) break;
+  }
 
-    const std::vector<int> vc{10,11,12,13,14};
-    REQUIRE( v == vc );
+  const std::vector<int> vc{10, 11, 12, 13, 14};
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("count: with step", "[count]") {
-    std::vector<int> v{};
-    for (auto i : count(2, -1)) {
-        v.push_back(i);
-        if (i == -3) break;
-    }
+  std::vector<int> v{};
+  for (auto i : count(2, -1)) {
+    v.push_back(i);
+    if (i == -3) break;
+  }
 
-    const std::vector<int> vc{2,1,0,-1,-2,-3};
-    REQUIRE( v == vc);
+  const std::vector<int> vc{2, 1, 0, -1, -2, -3};
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("count: with step > 1", "[count]") {
-    std::vector<int> v{};
-    for (auto i : count(10, 2)) {
-        v.push_back(i);
-        if (i == 16) break;
-    }
+  std::vector<int> v{};
+  for (auto i : count(10, 2)) {
+    v.push_back(i);
+    if (i == 16) break;
+  }
 
-    const std::vector<int> vc{10, 12, 14, 16};
-    REQUIRE( v == vc );
+  const std::vector<int> vc{10, 12, 14, 16};
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("count: can bo constexpr", "[count]") {
-    constexpr auto c = count();
-    constexpr auto c2 = count(5); (void)c2;
-    constexpr auto c3 = count(5, 2); (void)c3;
+  constexpr auto c = count();
+  constexpr auto c2 = count(5);
+  (void)c2;
+  constexpr auto c3 = count(5, 2);
+  (void)c3;
 
-    constexpr auto it = c.begin();
-    constexpr auto i = *it;
-    static_assert(i == 0, "count begin not correct value");
+  constexpr auto it = c.begin();
+  constexpr auto i = *it;
+  static_assert(i == 0, "count begin not correct value");
 }
 
 TEST_CASE("count: iterator meets requirements", "[count]") {
-    auto c = count();
-    REQUIRE( itertest::IsIterator<decltype(std::begin(c))>::value );
+  auto c = count();
+  REQUIRE(itertest::IsIterator<decltype(std::begin(c))>::value);
 }
diff --git a/test/test_helpers.cpp b/test/test_helpers.cpp
index ad456f6c..f0e36990 100644
--- a/test/test_helpers.cpp
+++ b/test/test_helpers.cpp
@@ -9,78 +9,78 @@ using itertest::IsMoveConstructibleOnly;
 
 namespace {
 
-class ValidIter {
-    private:
-        int i;
-    public:
-        ValidIter& operator++(); // prefix
-        ValidIter operator++(int); // postfix
-        bool operator==(const ValidIter&) const;
-        bool operator!=(const ValidIter&) const;
-        int operator*();
-        void* operator->();
-};
-
+  class ValidIter {
+   private:
+    int i;
+
+   public:
+    ValidIter& operator++();    // prefix
+    ValidIter operator++(int);  // postfix
+    bool operator==(const ValidIter&) const;
+    bool operator!=(const ValidIter&) const;
+    int operator*();
+    void* operator->();
+  };
 }
 
 TEST_CASE("IsIterator fails when missing prefix ++", "[helpers]") {
-    struct InvalidIter : ValidIter {
-        InvalidIter& operator++() = delete;
-    };
+  struct InvalidIter : ValidIter {
+    InvalidIter& operator++() = delete;
+  };
 
-    REQUIRE( !IsIterator<InvalidIter>::value );
+  REQUIRE(!IsIterator<InvalidIter>::value);
 }
 
 TEST_CASE("IsIterator fails when missing postfix ++", "[helpers]") {
-    struct InvalidIter : ValidIter {
-        InvalidIter operator++(int) = delete;
-    };
+  struct InvalidIter : ValidIter {
+    InvalidIter operator++(int) = delete;
+  };
 
-    REQUIRE( !IsIterator<InvalidIter>::value );
+  REQUIRE(!IsIterator<InvalidIter>::value);
 }
 
 TEST_CASE("IsIterator fails when missing ==", "[helpers]") {
-    struct InvalidIter : ValidIter {
-        bool operator==(const InvalidIter&) const = delete;
-    };
+  struct InvalidIter : ValidIter {
+    bool operator==(const InvalidIter&) const = delete;
+  };
 
-    REQUIRE( !IsIterator<InvalidIter>::value );
+  REQUIRE(!IsIterator<InvalidIter>::value);
 }
 
 TEST_CASE("IsIterator fails when missing !=", "[helpers]") {
-    struct InvalidIter : ValidIter {
-        bool operator!=(const InvalidIter&) const = delete;
-    };
+  struct InvalidIter : ValidIter {
+    bool operator!=(const InvalidIter&) const = delete;
+  };
 
-    REQUIRE( !IsIterator<InvalidIter>::value );
+  REQUIRE(!IsIterator<InvalidIter>::value);
 }
 
 TEST_CASE("IsIterator fails when missing *", "[helpers]") {
-    struct InvalidIter : ValidIter {
-        int operator*() = delete;
-    };
+  struct InvalidIter : ValidIter {
+    int operator*() = delete;
+  };
 
-    REQUIRE( !IsIterator<InvalidIter>::value );
+  REQUIRE(!IsIterator<InvalidIter>::value);
 }
 
 TEST_CASE("IsIterator fails when missing copy-ctor", "[helpers]") {
-    struct InvalidIter : ValidIter {
-        InvalidIter(const InvalidIter&) = delete;
-    };
+  struct InvalidIter : ValidIter {
+    InvalidIter(const InvalidIter&) = delete;
+  };
 
-    REQUIRE( !IsIterator<InvalidIter>::value );
+  REQUIRE(!IsIterator<InvalidIter>::value);
 }
 
 TEST_CASE("IsIterator fails when missing copy assignment", "[helpers]") {
-    struct InvalidIter : ValidIter {
-        InvalidIter& operator=(const InvalidIter&) = delete;
-    };
+  struct InvalidIter : ValidIter {
+    InvalidIter& operator=(const InvalidIter&) = delete;
+  };
 
-    REQUIRE( !IsIterator<InvalidIter>::value );
+  REQUIRE(!IsIterator<InvalidIter>::value);
 }
 
 TEST_CASE("IsIterator passes a valid iterator", "[helpers]") {
-    REQUIRE( IsIterator<ValidIter>::value );
+  REQUIRE(IsIterator<ValidIter>::value);
 }
 
 struct HasNothing {
@@ -100,7 +100,7 @@ struct HasMoveCtorAndAssign {
 
 struct HasMoveCtorAndCopyAssign {
   HasMoveCtorAndCopyAssign(HasMoveCtorAndCopyAssign&&);
-  HasMoveCtorAndCopyAssign&  operator=(const HasMoveCtorAndCopyAssign&);
+  HasMoveCtorAndCopyAssign& operator=(const HasMoveCtorAndCopyAssign&);
 };
 
 struct HasMoveCtorOnly {
@@ -108,20 +108,20 @@ struct HasMoveCtorOnly {
 };
 
 TEST_CASE("IsMoveConstructibleOnly false without move ctor", "[helpers]") {
-  REQUIRE_FALSE( IsMoveConstructibleOnly<HasNothing>::value );
+  REQUIRE_FALSE(IsMoveConstructibleOnly<HasNothing>::value);
 }
 
 TEST_CASE("IsMoveConstructibleOnly false with copy ctor", "[helpers]") {
-  REQUIRE_FALSE( IsMoveConstructibleOnly<HasMoveAndCopyCtor>::value );
+  REQUIRE_FALSE(IsMoveConstructibleOnly<HasMoveAndCopyCtor>::value);
 }
 
 TEST_CASE("IsMoveConstructibleOnly false with move assign", "[helpers]") {
-  REQUIRE_FALSE( IsMoveConstructibleOnly<HasMoveCtorAndAssign>::value );
+  REQUIRE_FALSE(IsMoveConstructibleOnly<HasMoveCtorAndAssign>::value);
 }
 TEST_CASE("IsMoveConstructibleOnly false with copy assign", "[helpers]") {
-  REQUIRE_FALSE( IsMoveConstructibleOnly<HasMoveCtorAndCopyAssign>::value );
+  REQUIRE_FALSE(IsMoveConstructibleOnly<HasMoveCtorAndCopyAssign>::value);
 }
 
 TEST_CASE("IsMoveConstructibleOnly true when met", "[helpers]") {
-  REQUIRE( IsMoveConstructibleOnly<HasMoveCtorOnly>::value );
+  REQUIRE(IsMoveConstructibleOnly<HasMoveCtorOnly>::value);
 }
diff --git a/test/test_iteratoriterator.cpp b/test/test_iteratoriterator.cpp
index 129ebd15..c3abd95a 100644
--- a/test/test_iteratoriterator.cpp
+++ b/test/test_iteratoriterator.cpp
@@ -8,49 +8,49 @@
 using iter::impl::IterIterWrapper;
 
 TEST_CASE("Iterator over a vector of vector iterators", "[iteratoriterator]") {
-    using std::vector;
-    vector<int> v = {2, 4, 6, 8};
-
-    IterIterWrapper<vector<vector<int>::iterator>> itr;
-    itr.get().push_back(std::begin(v) + 1);
-    itr.get().push_back(std::end(v) - 1);
-    itr.get().push_back(std::begin(v));
-
-    auto it = std::begin(itr);
-    REQUIRE( *it == 4 );
-    REQUIRE( it != std::end(itr) );
-    ++it;
-    REQUIRE( *it == 8 );
-    it++;
-    REQUIRE( *it == 2 );
-    ++it;
-    REQUIRE( it == std::end(itr) );
-
-    REQUIRE( itr[0] == 4 );
-    REQUIRE( itr[1] == 8 );
-    REQUIRE( itr[2] == 2 );
-
-    auto rit = itr.rbegin();
-
-    REQUIRE( *rit == 2 );
-    REQUIRE( rit != itr.rend() );
-    ++rit;
-    REQUIRE( *rit == 8 );
-    ++rit;
-    REQUIRE( *rit == 4 );
-    ++rit;
-    REQUIRE( rit == itr.rend() );
+  using std::vector;
+  vector<int> v = {2, 4, 6, 8};
+
+  IterIterWrapper<vector<vector<int>::iterator>> itr;
+  itr.get().push_back(std::begin(v) + 1);
+  itr.get().push_back(std::end(v) - 1);
+  itr.get().push_back(std::begin(v));
+
+  auto it = std::begin(itr);
+  REQUIRE(*it == 4);
+  REQUIRE(it != std::end(itr));
+  ++it;
+  REQUIRE(*it == 8);
+  it++;
+  REQUIRE(*it == 2);
+  ++it;
+  REQUIRE(it == std::end(itr));
+
+  REQUIRE(itr[0] == 4);
+  REQUIRE(itr[1] == 8);
+  REQUIRE(itr[2] == 2);
+
+  auto rit = itr.rbegin();
+
+  REQUIRE(*rit == 2);
+  REQUIRE(rit != itr.rend());
+  ++rit;
+  REQUIRE(*rit == 8);
+  ++rit;
+  REQUIRE(*rit == 4);
+  ++rit;
+  REQUIRE(rit == itr.rend());
 }
 
 TEST_CASE("IteratorIterator operator->", "[iteratoriterator]") {
-    using std::vector;
-    using std::string;
-    vector<string> v = {"hello", "everyone"};
-    IterIterWrapper<vector<vector<string>::iterator>> itritr;
-    itritr.get().push_back(std::end(v) - 1);
-    itritr.get().push_back(std::begin(v));
-    auto it = std::begin(itritr);
-    REQUIRE( it->size() == 8 );
+  using std::vector;
+  using std::string;
+  vector<string> v = {"hello", "everyone"};
+  IterIterWrapper<vector<vector<string>::iterator>> itritr;
+  itritr.get().push_back(std::end(v) - 1);
+  itritr.get().push_back(std::begin(v));
+  auto it = std::begin(itritr);
+  REQUIRE(it->size() == 8);
 }
 
 TEST_CASE("Iterate over a vector of string iterators", "[iteratoriterator]") {
@@ -58,6 +58,6 @@ TEST_CASE("Iterate over a vector of string iterators", "[iteratoriterator]") {
   IterIterWrapper<std::vector<std::string::iterator>> itritr;
   auto it = std::begin(itritr);
   static_assert(std::is_same<decltype(*it),
-      std::iterator_traits<decltype(it)>::reference>::value,
+                    std::iterator_traits<decltype(it)>::reference>::value,
       "iterator is mis marked");
 }
diff --git a/test/test_mixed.cpp b/test/test_mixed.cpp
index f0ed106e..b9be62ff 100644
--- a/test/test_mixed.cpp
+++ b/test/test_mixed.cpp
@@ -1,6 +1,5 @@
 // mixing different itertools, there is nothing called iter::mixed()
 
-
 #include "itertools.hpp"
 
 #include "catch.hpp"
@@ -9,122 +8,116 @@
 #include <vector>
 
 class MyUnMovable {
-    int val;
-public:
-    constexpr MyUnMovable(int val)
-        : val{val}
-    { }
-
-    MyUnMovable(const MyUnMovable&) = delete;
-    MyUnMovable& operator=(const MyUnMovable&) = delete;
-
-    MyUnMovable(MyUnMovable&& other)
-        : val{other.val}
-    { }
-
-    constexpr int get_val() const {
-        return val;
-    }
-    void set_val(int val) {
-        this->val = val;        
-    }
-
-    bool operator==(const MyUnMovable& other) const {
-        return this->val == other.val;
-    }
-
-    bool operator!=(const MyUnMovable& other) const {
-        return !(*this == other);
-    }
+  int val;
+
+ public:
+  constexpr MyUnMovable(int val) : val{val} {}
+
+  MyUnMovable(const MyUnMovable&) = delete;
+  MyUnMovable& operator=(const MyUnMovable&) = delete;
+
+  MyUnMovable(MyUnMovable&& other) : val{other.val} {}
+
+  constexpr int get_val() const {
+    return val;
+  }
+  void set_val(int val) {
+    this->val = val;
+  }
+
+  bool operator==(const MyUnMovable& other) const {
+    return this->val == other.val;
+  }
+
+  bool operator!=(const MyUnMovable& other) const {
+    return !(*this == other);
+  }
 };
 
 namespace {
-    auto inc_ten = [](MyUnMovable& el) -> MyUnMovable& {
-        int va = el.get_val();
-        el.set_val(va + 10);
-        return el;
-    };
-    auto dec_ten = [](MyUnMovable& el) -> MyUnMovable& {
-        int va = el.get_val();
-        el.set_val(va - 10);
-        return el;
-    };
+  auto inc_ten = [](MyUnMovable& el) -> MyUnMovable& {
+    int va = el.get_val();
+    el.set_val(va + 10);
+    return el;
+  };
+  auto dec_ten = [](MyUnMovable& el) -> MyUnMovable& {
+    int va = el.get_val();
+    el.set_val(va - 10);
+    return el;
+  };
 }
 
 TEST_CASE("filtering doesn't dereference multiple times", "[imap][filter]") {
-    using iter::filter;
-    using iter::imap;
+  using iter::filter;
+  using iter::imap;
 
-    // source data
-    std::array<MyUnMovable, 3> arr = {{{41}, {42}, {43}}};
+  // source data
+  std::array<MyUnMovable, 3> arr = {{{41}, {42}, {43}}};
 
-    auto transformed1 = imap(inc_ten, arr);
-    auto filtered = filter([](const MyUnMovable& el) {
-        return 52 != el.get_val();
-    }, transformed1);
-    auto transformed2 = imap(dec_ten, filtered);
+  auto transformed1 = imap(inc_ten, arr);
+  auto filtered = filter(
+      [](const MyUnMovable& el) { return 52 != el.get_val(); }, transformed1);
+  auto transformed2 = imap(dec_ten, filtered);
 
-    std::vector<int> v;
-    for (auto&& el : transformed2) {
-        // I would use imap again instead of the loop if this wasn't an imap
-        // test
-        v.push_back(el.get_val());
-    }
+  std::vector<int> v;
+  for (auto&& el : transformed2) {
+    // I would use imap again instead of the loop if this wasn't an imap
+    // test
+    v.push_back(el.get_val());
+  }
 
-    std::vector<int> vc = {41, 43};
+  std::vector<int> vc = {41, 43};
 
-    REQUIRE( v == vc);
+  REQUIRE(v == vc);
 
-    constexpr std::array<MyUnMovable, 3> arrc = {{{41}, {52}, {43}}};
-    REQUIRE( arr == arrc );
+  constexpr std::array<MyUnMovable, 3> arrc = {{{41}, {52}, {43}}};
+  REQUIRE(arr == arrc);
 }
 
-TEST_CASE("dropwhile doesn't dereference multiple times", "[imap][dropwhile]"){
-    using iter::imap;
-    using iter::dropwhile;
+TEST_CASE("dropwhile doesn't dereference multiple times", "[imap][dropwhile]") {
+  using iter::imap;
+  using iter::dropwhile;
 
-    std::array<MyUnMovable, 3> arr = {{{41}, {42}, {43}}};
+  std::array<MyUnMovable, 3> arr = {{{41}, {42}, {43}}};
 
-    auto transformed1 = imap(inc_ten, arr);
-    auto filtered = dropwhile([](const MyUnMovable& el) {
-        return 52 != el.get_val();
-    }, transformed1);
-    auto transformed2 = imap(dec_ten, filtered);
+  auto transformed1 = imap(inc_ten, arr);
+  auto filtered = dropwhile(
+      [](const MyUnMovable& el) { return 52 != el.get_val(); }, transformed1);
+  auto transformed2 = imap(dec_ten, filtered);
 
-    std::vector<int> v;
-    for (auto&& el : transformed2) {
-        v.push_back(el.get_val());
-    }
+  std::vector<int> v;
+  for (auto&& el : transformed2) {
+    v.push_back(el.get_val());
+  }
 
-    std::vector<int> vc = {42, 43};
+  std::vector<int> vc = {42, 43};
 
-    std::vector<int> vsc = {51, 42, 43};
-    auto get_vals = imap([](const MyUnMovable& mv){return mv.get_val();}, arr);
-    std::vector<int> vs(std::begin(get_vals), std::end(get_vals));
-    REQUIRE( vs == vsc );
+  std::vector<int> vsc = {51, 42, 43};
+  auto get_vals = imap([](const MyUnMovable& mv) { return mv.get_val(); }, arr);
+  std::vector<int> vs(std::begin(get_vals), std::end(get_vals));
+  REQUIRE(vs == vsc);
 }
 
-TEST_CASE("takewhile doesn't dereference multiple times", "[imap][takewhile]"){
-    using iter::imap;
-    using iter::takewhile;
+TEST_CASE("takewhile doesn't dereference multiple times", "[imap][takewhile]") {
+  using iter::imap;
+  using iter::takewhile;
 
-    std::array<MyUnMovable, 3> arr = {{{41}, {42}, {43}}};
+  std::array<MyUnMovable, 3> arr = {{{41}, {42}, {43}}};
 
-    auto transformed1 = imap(inc_ten, arr);
-    auto filtered = takewhile([](const MyUnMovable& el) {
-        return 53 != el.get_val();
-    }, transformed1);
-    auto transformed2 = imap(dec_ten, filtered);
+  auto transformed1 = imap(inc_ten, arr);
+  auto filtered = takewhile(
+      [](const MyUnMovable& el) { return 53 != el.get_val(); }, transformed1);
+  auto transformed2 = imap(dec_ten, filtered);
 
-    std::vector<int> v;
-    for (auto&& el : transformed2) {
-        v.push_back(el.get_val());
-    }
+  std::vector<int> v;
+  for (auto&& el : transformed2) {
+    v.push_back(el.get_val());
+  }
 
-    std::vector<int> vc = {41, 42};
+  std::vector<int> vc = {41, 42};
 
-    std::vector<int> vsc = {41, 42, 53};
-    auto get_vals = imap([](const MyUnMovable& mv){return mv.get_val();}, arr);
-    std::vector<int> vs(std::begin(get_vals), std::end(get_vals));
-    REQUIRE( vs == vsc );
+  std::vector<int> vsc = {41, 42, 53};
+  auto get_vals = imap([](const MyUnMovable& mv) { return mv.get_val(); }, arr);
+  std::vector<int> vs(std::begin(get_vals), std::end(get_vals));
+  REQUIRE(vs == vsc);
 }
diff --git a/test/test_range.cpp b/test/test_range.cpp
index 887cee8b..52482df0 100644
--- a/test/test_range.cpp
+++ b/test/test_range.cpp
@@ -10,247 +10,247 @@
 using Vec = const std::vector<int>;
 using iter::range;
 
-
 TEST_CASE("range: works with only stop", "[range]") {
-    auto r = range(5);
-    Vec v(std::begin(r), std::end(r));
-    Vec vc{0, 1, 2, 3, 4};
+  auto r = range(5);
+  Vec v(std::begin(r), std::end(r));
+  Vec vc{0, 1, 2, 3, 4};
 
-    REQUIRE( v == vc );
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("range: works with start and stop", "[range]") {
-    auto r = range(1, 5);
-    Vec v(std::begin(r), std::end(r));
-    Vec vc {1, 2, 3, 4};
+  auto r = range(1, 5);
+  Vec v(std::begin(r), std::end(r));
+  Vec vc{1, 2, 3, 4};
 
-    REQUIRE( v == vc );
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("range: works with positive step > 1", "[range]") {
-    auto r = range(1, 10, 3);
-    Vec v(std::begin(r), std::end(r));
-    Vec vc{1, 4, 7};
+  auto r = range(1, 10, 3);
+  Vec v(std::begin(r), std::end(r));
+  Vec vc{1, 4, 7};
 
-    REQUIRE( v == vc );
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("range(0) is empty", "[range]") {
-    auto r = iter::range(0);
-    REQUIRE( std::begin(r) == std::end(r) );
+  auto r = iter::range(0);
+  REQUIRE(std::begin(r) == std::end(r));
 }
 
 TEST_CASE("range: postfix++", "[range]") {
-    auto r = iter::range(3);
-    auto it = std::begin(r);
-    it++;
-    REQUIRE( *it == 1 );
+  auto r = iter::range(3);
+  auto it = std::begin(r);
+  it++;
+  REQUIRE(*it == 1);
 }
 
 TEST_CASE("start > stop produces empty range", "[range]") {
-    auto r = range(5, 0);
-    Vec v(std::begin(r), std::end(r));
-    REQUIRE( v.empty() );
+  auto r = range(5, 0);
+  Vec v(std::begin(r), std::end(r));
+  REQUIRE(v.empty());
 }
 
 TEST_CASE("start < stop and step < 0 produces empty range", "[range]") {
-    auto r = range(0, 5, -1);
-    Vec v(std::begin(r), std::end(r));
-    REQUIRE( v.empty() );
+  auto r = range(0, 5, -1);
+  Vec v(std::begin(r), std::end(r));
+  REQUIRE(v.empty());
 }
 
 TEST_CASE("range: with only a negative stop is empty", "[range]") {
-    auto r = range(-3);
-    Vec v(std::begin(r), std::end(r));
+  auto r = range(-3);
+  Vec v(std::begin(r), std::end(r));
 
-    REQUIRE( v.empty() );
+  REQUIRE(v.empty());
 }
 
 TEST_CASE("range: works with negative step", "[range]") {
-    auto r = range(5, -5, -3);
-    Vec v(std::begin(r), std::end(r));
-    Vec vc{5, 2, -1, -4};
+  auto r = range(5, -5, -3);
+  Vec v(std::begin(r), std::end(r));
+  Vec vc{5, 2, -1, -4};
 
-    REQUIRE( v == vc );
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("range: stops short when step doesn't divide stop-start", "[range]") {
-    auto r = range(0, 5, 2);
-    Vec v(std::begin(r), std::end(r));
-    Vec vc{0, 2, 4};
-
-    REQUIRE( v == vc );
+  auto r = range(0, 5, 2);
+  Vec v(std::begin(r), std::end(r));
+  Vec vc{0, 2, 4};
 
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("range: stops short when step > stop-start", "[range]") {
-    auto r = range(0, 10, 20);
-    Vec v(std::begin(r), std::end(r));
-    REQUIRE( v.size() == 1 );
+  auto r = range(0, 10, 20);
+  Vec v(std::begin(r), std::end(r));
+  REQUIRE(v.size() == 1);
 }
 
 TEST_CASE("range: step size of 0 gives an empty range", "[range]") {
-    auto r = range(0, 10, 0);
-    REQUIRE( std::begin(r) == std::end(r) );
-    auto r2 = range(0, -10, 0);
-    REQUIRE( std::begin(r2) == std::end(r2) );
+  auto r = range(0, 10, 0);
+  REQUIRE(std::begin(r) == std::end(r));
+  auto r2 = range(0, -10, 0);
+  REQUIRE(std::begin(r2) == std::end(r2));
 }
 
 TEST_CASE("range: can create constexpr ranges", "[range]") {
-    constexpr auto r = range(10); (void)r;
-    constexpr auto r2 = range(4, 10); (void)r2;
-    constexpr auto r3 = range(4, 10, 2); (void)r3;
-
-    constexpr auto it = r2.begin(); // std::begin isn't constexpr
-    constexpr auto i = *it;
-    static_assert(i == 4, "range's begin has the wrong value");
-
-    constexpr auto rf = range(10.0);
-    constexpr auto itf = rf.begin();
-    constexpr auto f = *itf;
-    static_assert(f == 0.0, "range's begin has tho wrong value (float)");
+  constexpr auto r = range(10);
+  (void)r;
+  constexpr auto r2 = range(4, 10);
+  (void)r2;
+  constexpr auto r3 = range(4, 10, 2);
+  (void)r3;
+
+  constexpr auto it = r2.begin();  // std::begin isn't constexpr
+  constexpr auto i = *it;
+  static_assert(i == 4, "range's begin has the wrong value");
+
+  constexpr auto rf = range(10.0);
+  constexpr auto itf = rf.begin();
+  constexpr auto f = *itf;
+  static_assert(f == 0.0, "range's begin has tho wrong value (float)");
 }
 
 TEST_CASE("range: works with a variable start, stop, and step", "[range]") {
-    constexpr int a = 10;
-    constexpr int b = 100;
-    constexpr int c = 50;
-    SECTION("Going up works") {
-        auto r = range(a, a+2);
-        Vec v(std::begin(r), std::end(r));
-        Vec vc{a, a+1};
-        REQUIRE( v == vc );
-    }
-
-    SECTION("Going down works") {
-        auto r = range(a+2, a, -1);
-        Vec v(std::begin(r), std::end(r));
-        Vec vc{a+2, a+1};
-        REQUIRE( v == vc );
-    }
-
-    SECTION("Going down with -2 stop works") {
-        auto r = range(a+4, a, -2);
-        Vec v(std::begin(r), std::end(r));
-        Vec vc{a+4, a+2};
-        REQUIRE( v == vc );
-    }
-
-    SECTION("Using three variable") {
-        auto r = range(a, b, c);
-        Vec v(std::begin(r), std::end(r));
-        REQUIRE( std::find(std::begin(v), std::end(v), a) != std::end(v) );
-        REQUIRE( std::find(std::begin(v), std::end(v), b) == std::end(v) );
-        REQUIRE( v.size() == 2 );
-    }
-
-    SECTION("Using three with a unary negate on step") {
-        auto r = range(b, a, -c);
-        Vec v(std::begin(r), std::end(r));
-
-        REQUIRE( std::find(std::begin(v), std::end(v), b) != std::end(v) );
-        REQUIRE( std::find(std::begin(v), std::end(v), a) == std::end(v) );
-        REQUIRE( v.size() == 2 );
-    }
-
-    SECTION("Using all three negated") {
-        auto r = range(-a, -b, -c);
-        Vec v(std::begin(r), std::end(r));
-
-        REQUIRE( std::find(std::begin(v), std::end(v), -a) != std::end(v) );
-        REQUIRE( std::find(std::begin(v), std::end(v), -b) == std::end(v) );
-        REQUIRE( v.size() == 2 );
-    }
+  constexpr int a = 10;
+  constexpr int b = 100;
+  constexpr int c = 50;
+  SECTION("Going up works") {
+    auto r = range(a, a + 2);
+    Vec v(std::begin(r), std::end(r));
+    Vec vc{a, a + 1};
+    REQUIRE(v == vc);
+  }
+
+  SECTION("Going down works") {
+    auto r = range(a + 2, a, -1);
+    Vec v(std::begin(r), std::end(r));
+    Vec vc{a + 2, a + 1};
+    REQUIRE(v == vc);
+  }
+
+  SECTION("Going down with -2 stop works") {
+    auto r = range(a + 4, a, -2);
+    Vec v(std::begin(r), std::end(r));
+    Vec vc{a + 4, a + 2};
+    REQUIRE(v == vc);
+  }
+
+  SECTION("Using three variable") {
+    auto r = range(a, b, c);
+    Vec v(std::begin(r), std::end(r));
+    REQUIRE(std::find(std::begin(v), std::end(v), a) != std::end(v));
+    REQUIRE(std::find(std::begin(v), std::end(v), b) == std::end(v));
+    REQUIRE(v.size() == 2);
+  }
+
+  SECTION("Using three with a unary negate on step") {
+    auto r = range(b, a, -c);
+    Vec v(std::begin(r), std::end(r));
+
+    REQUIRE(std::find(std::begin(v), std::end(v), b) != std::end(v));
+    REQUIRE(std::find(std::begin(v), std::end(v), a) == std::end(v));
+    REQUIRE(v.size() == 2);
+  }
+
+  SECTION("Using all three negated") {
+    auto r = range(-a, -b, -c);
+    Vec v(std::begin(r), std::end(r));
 
+    REQUIRE(std::find(std::begin(v), std::end(v), -a) != std::end(v));
+    REQUIRE(std::find(std::begin(v), std::end(v), -b) == std::end(v));
+    REQUIRE(v.size() == 2);
+  }
 }
 
 TEST_CASE("range: forward iterator checks", "[range]") {
   auto r = range(10);
-  REQUIRE( std::end(r) == std::end(r) );
+  REQUIRE(std::end(r) == std::end(r));
   auto it1 = std::begin(r);
   auto it2 = std::begin(r);
-  REQUIRE_FALSE( it1 != it2 );
-  REQUIRE( it1 == it2 );
+  REQUIRE_FALSE(it1 != it2);
+  REQUIRE(it1 == it2);
   ++it1;
-  REQUIRE( it1 != it2 );
+  REQUIRE(it1 != it2);
   ++it2;
-  REQUIRE( it1 == it2 );
+  REQUIRE(it1 == it2);
   auto it3 = it1++;
-  REQUIRE( it3 == it2 );
+  REQUIRE(it3 == it2);
   auto it4 = ++it3;
-  REQUIRE( it4 == it3 );
+  REQUIRE(it4 == it3);
 
   auto it5 = std::begin(r);
   const auto& v = *it5;
   ++it5;
-  REQUIRE( v != *it5 );
+  REQUIRE(v != *it5);
 }
 
 TEST_CASE("range: forward iterator with double, checks", "[range]") {
   auto r = range(10.0);
-  REQUIRE( std::end(r) == std::end(r) );
+  REQUIRE(std::end(r) == std::end(r));
   auto it1 = std::begin(r);
   auto it2 = std::begin(r);
-  REQUIRE_FALSE( it1 != it2 );
-  REQUIRE( it1 == it2 );
+  REQUIRE_FALSE(it1 != it2);
+  REQUIRE(it1 == it2);
   ++it1;
-  REQUIRE( it1 != it2 );
+  REQUIRE(it1 != it2);
   ++it2;
-  REQUIRE( it1 == it2 );
+  REQUIRE(it1 == it2);
   auto it3 = it1++;
-  REQUIRE( it3 == it2 );
+  REQUIRE(it3 == it2);
   auto it4 = ++it3;
-  REQUIRE( it4 == it3 );
+  REQUIRE(it4 == it3);
 }
 
 using FVec = const std::vector<double>;
 
 TEST_CASE("range: using doubles", "[range]") {
-    auto r = range(5.0);
-    FVec fv(std::begin(r), std::end(r));
-    FVec fvc = {0.0, 1.0, 2.0, 3.0, 4.0};
-    REQUIRE( fv == fvc );
+  auto r = range(5.0);
+  FVec fv(std::begin(r), std::end(r));
+  FVec fvc = {0.0, 1.0, 2.0, 3.0, 4.0};
+  REQUIRE(fv == fvc);
 }
 
 TEST_CASE("range: using doubles with start and stop", "[range]") {
-    auto r = range(5.0, 10.0);
-    FVec fv(std::begin(r), std::end(r));
-    FVec fvc = {5.0, 6.0, 7.0, 8.0, 9.0};
-    REQUIRE( fv == fvc );
+  auto r = range(5.0, 10.0);
+  FVec fv(std::begin(r), std::end(r));
+  FVec fvc = {5.0, 6.0, 7.0, 8.0, 9.0};
+  REQUIRE(fv == fvc);
 }
 
 TEST_CASE("range: using doubles with start, stop and step", "[range]") {
-    auto r = range(1.0, 4.0, 0.5);
-    FVec fv(std::begin(r), std::end(r));
-    FVec fvc = {1.0, 1.5, 2.0, 2.5, 3.0, 3.5};
-    REQUIRE( fv == fvc );
+  auto r = range(1.0, 4.0, 0.5);
+  FVec fv(std::begin(r), std::end(r));
+  FVec fvc = {1.0, 1.5, 2.0, 2.5, 3.0, 3.5};
+  REQUIRE(fv == fvc);
 }
 
 TEST_CASE("range: using doubles with negative", "[range]") {
-    auto r = range(0.5, -2.0, -0.5);
-    FVec fv(std::begin(r), std::end(r));
-    FVec fvc = {0.5, 0.0, -0.5, -1.0, -1.5};
-    REQUIRE( fv == fvc );
+  auto r = range(0.5, -2.0, -0.5);
+  FVec fv(std::begin(r), std::end(r));
+  FVec fvc = {0.5, 0.0, -0.5, -1.0, -1.5};
+  REQUIRE(fv == fvc);
 }
 
 TEST_CASE("range: using doubles with uneven step", "[range]") {
-    auto r = range(0.0, 1.75, 0.5);
-    FVec fv(std::begin(r), std::end(r));
-    FVec fvc = {0.0, 0.5, 1.0, 1.5};
-    REQUIRE( fv == fvc );
+  auto r = range(0.0, 1.75, 0.5);
+  FVec fv(std::begin(r), std::end(r));
+  FVec fvc = {0.0, 0.5, 1.0, 1.5};
+  REQUIRE(fv == fvc);
 }
 
 TEST_CASE("range: using doubles detects empty ranges", "[range]") {
-    auto r1 = range(0.0, -1.0);
-    REQUIRE(std::begin(r1) == std::end(r1));
+  auto r1 = range(0.0, -1.0);
+  REQUIRE(std::begin(r1) == std::end(r1));
 
-    auto r2 = range(0.0, 1.0, -1.0);
-    REQUIRE(std::begin(r2) == std::end(r2));
+  auto r2 = range(0.0, 1.0, -1.0);
+  REQUIRE(std::begin(r2) == std::end(r2));
 }
 
 TEST_CASE("range: iterator meets forward iterator requirements", "[range]") {
-    auto r = range(5);
-    auto r2 = range(5.0);
-    REQUIRE( itertest::IsForwardIterator<decltype(std::begin(r))>::value );
-    REQUIRE( itertest::IsForwardIterator<decltype(std::begin(r2))>::value );
+  auto r = range(5);
+  auto r2 = range(5.0);
+  REQUIRE(itertest::IsForwardIterator<decltype(std::begin(r))>::value);
+  REQUIRE(itertest::IsForwardIterator<decltype(std::begin(r2))>::value);
 }

From e58ae12670ead4152fd2299d6d12857c561b6c4c Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 6 Sep 2015 23:55:20 -0700
Subject: [PATCH 1343/1866] uses array ref instead of array

---
 test/test_chain.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/test_chain.cpp b/test/test_chain.cpp
index 85844900..c0d319d4 100644
--- a/test/test_chain.cpp
+++ b/test/test_chain.cpp
@@ -152,7 +152,7 @@ TEST_CASE("chain: iterator meets requirements", "[chain]") {
 template <typename... Ts>
 using ImpT = decltype(chain(std::declval<Ts>()...));
 TEST_CASE("chain: has correct ctor and assign ops", "[chain]") {
-  using T = ImpT<std::string&, std::vector<char>, char[10]>;
+  using T = ImpT<std::string&, std::vector<char>, char (&)[10]>;
   REQUIRE(itertest::IsMoveConstructibleOnly<T>::value);
 }
 

From 93c032eeaeda416d43e5b5b396200e9ff7c014a3 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 7 Sep 2015 12:01:48 -0700
Subject: [PATCH 1344/1866] adds dummy operator()() to ArrowHelper

---
 internal/iterbase.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/internal/iterbase.hpp b/internal/iterbase.hpp
index f9295170..c215d003 100644
--- a/internal/iterbase.hpp
+++ b/internal/iterbase.hpp
@@ -54,6 +54,7 @@ namespace iter {
       template <typename T, typename = void>
       struct ArrowHelper {
         using type = void;
+        void operator()(T&) const noexcept { }
       };
 
       template <typename T>

From a09a2ddd0dc295e81a2406efed99a7565d850a0a Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 7 Sep 2015 12:07:26 -0700
Subject: [PATCH 1345/1866] adds dummy operator()() to ArrowHelper

---
 internal/iterbase.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/internal/iterbase.hpp b/internal/iterbase.hpp
index 44b779cc..a3451bf4 100644
--- a/internal/iterbase.hpp
+++ b/internal/iterbase.hpp
@@ -63,6 +63,7 @@ namespace iter {
       template <typename T, typename = void>
       struct ArrowHelper {
         using type = void;
+        void operator()(T&) const noexcept { }
       };
 
       template <typename T>

From 021676994ff6bed9bcb8dcf3340fc584d34dd0e9 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 7 Sep 2015 13:11:28 -0700
Subject: [PATCH 1346/1866] marks group move ctor noexcept

---
 groupby.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/groupby.hpp b/groupby.hpp
index d794d70d..78340416 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -192,7 +192,7 @@ class iter::impl::GroupProducer {
     }
 
     // move-constructible, non-copy-constructible, non-assignable
-    Group(Group&& other)
+    Group(Group&& other) noexcept
         : owner(other.owner), key{other.key}, completed{other.completed} {
       other.completed = true;
     }

From ed047ea929668c1eee53aee3c71d3de3beb676b6 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 7 Sep 2015 22:00:23 -0700
Subject: [PATCH 1347/1866] fixes clang tidy warnings

---
 accumulate.hpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/accumulate.hpp b/accumulate.hpp
index eca67cb1..e82eb117 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -48,7 +48,7 @@ class iter::impl::Accumulator {
         accumulate_func(in_accumulate_func) {}
 
  public:
-  Accumulator(Accumulator&&) = default;
+  Accumulator(Accumulator&&) noexcept = default;
 
   class Iterator : public std::iterator<std::input_iterator_tag, AccumVal> {
    private:
@@ -73,7 +73,7 @@ class iter::impl::Accumulator {
           acc_val{other.acc_val ? new AccumVal(*other.acc_val) : nullptr} {}
 
     Iterator& operator=(const Iterator& other) {
-      if (this == &other) return *this;
+      if (this == &other) { return *this; }
       this->sub_iter = other.sub_iter;
       this->sub_end = other.sub_end;
       this->accumulate_func = other.accumulate_func;
@@ -82,8 +82,8 @@ class iter::impl::Accumulator {
       return *this;
     }
 
-    Iterator(Iterator&&) = default;
-    Iterator& operator=(Iterator&&) = default;
+    Iterator(Iterator&&) noexcept = default;
+    Iterator& operator=(Iterator&&) noexcept = default;
 
     const AccumVal& operator*() const {
       return *this->acc_val;

From ecb00003325bd528d5e0c7d675f654d7a08376d8 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 7 Sep 2015 22:00:28 -0700
Subject: [PATCH 1348/1866] fixes clang tidy warnings

---
 chain.hpp | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/chain.hpp b/chain.hpp
index 5ee3bcfa..b61bfe68 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -46,7 +46,7 @@ class iter::impl::Chained {
         rest_chained{std::forward<RestContainers>(rest)...} {}
 
  public:
-  Chained(Chained&&) = default;
+  Chained(Chained&&) noexcept = default;
   class Iterator : public std::iterator<std::input_iterator_tag,
                        iterator_traits_deref<Container>> {
    private:
@@ -123,7 +123,7 @@ class iter::impl::Chained<Container> {
       : container(std::forward<Container>(in_container)) {}
 
  public:
-  Chained(Chained&&) = default;
+  Chained(Chained&&) noexcept = default;
   class Iterator : public std::iterator<std::input_iterator_tag,
                        iterator_traits_deref<Container>> {
    private:
@@ -181,7 +181,7 @@ class iter::impl::ChainedFromIterable {
       : container(std::forward<Container>(in_container)) {}
 
  public:
-  ChainedFromIterable(ChainedFromIterable&&) = default;
+  ChainedFromIterable(ChainedFromIterable&&) noexcept = default;
   class Iterator : public std::iterator<std::input_iterator_tag,
                        iterator_traits_deref<iterator_deref<Container>>> {
    private:
@@ -231,7 +231,7 @@ class iter::impl::ChainedFromIterable {
           sub_end_p{clone_sub_pointer(other.sub_end_p.get())} {}
 
     Iterator& operator=(const Iterator& other) {
-      if (this == &other) return *this;
+      if (this == &other) { return *this; }
 
       this->top_level_iter = other.top_level_iter;
       this->top_level_end = other.top_level_end;
@@ -241,8 +241,8 @@ class iter::impl::ChainedFromIterable {
       return *this;
     }
 
-    Iterator(Iterator&&) = default;
-    Iterator& operator=(Iterator&&) = default;
+    Iterator(Iterator&&) noexcept = default;
+    Iterator& operator=(Iterator&&) noexcept = default;
     ~Iterator() = default;
 
     Iterator& operator++() {

From d9bbbe07ba05e33479c7ddee3048057e42373679 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 7 Sep 2015 22:14:41 -0700
Subject: [PATCH 1349/1866] undoes clang-tidy noexcept fixes

they're actually just inferred noexcept, which is better
---
 accumulate.hpp |  2 +-
 chain.hpp      | 10 +++++-----
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/accumulate.hpp b/accumulate.hpp
index e82eb117..fdde9a64 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -48,7 +48,7 @@ class iter::impl::Accumulator {
         accumulate_func(in_accumulate_func) {}
 
  public:
-  Accumulator(Accumulator&&) noexcept = default;
+  Accumulator(Accumulator&&) = default;
 
   class Iterator : public std::iterator<std::input_iterator_tag, AccumVal> {
    private:
diff --git a/chain.hpp b/chain.hpp
index b61bfe68..fe30255d 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -46,7 +46,7 @@ class iter::impl::Chained {
         rest_chained{std::forward<RestContainers>(rest)...} {}
 
  public:
-  Chained(Chained&&) noexcept = default;
+  Chained(Chained&&) = default;
   class Iterator : public std::iterator<std::input_iterator_tag,
                        iterator_traits_deref<Container>> {
    private:
@@ -123,7 +123,7 @@ class iter::impl::Chained<Container> {
       : container(std::forward<Container>(in_container)) {}
 
  public:
-  Chained(Chained&&) noexcept = default;
+  Chained(Chained&&) = default;
   class Iterator : public std::iterator<std::input_iterator_tag,
                        iterator_traits_deref<Container>> {
    private:
@@ -181,7 +181,7 @@ class iter::impl::ChainedFromIterable {
       : container(std::forward<Container>(in_container)) {}
 
  public:
-  ChainedFromIterable(ChainedFromIterable&&) noexcept = default;
+  ChainedFromIterable(ChainedFromIterable&&) = default;
   class Iterator : public std::iterator<std::input_iterator_tag,
                        iterator_traits_deref<iterator_deref<Container>>> {
    private:
@@ -241,8 +241,8 @@ class iter::impl::ChainedFromIterable {
       return *this;
     }
 
-    Iterator(Iterator&&) noexcept = default;
-    Iterator& operator=(Iterator&&) noexcept = default;
+    Iterator(Iterator&&) = default;
+    Iterator& operator=(Iterator&&) = default;
     ~Iterator() = default;
 
     Iterator& operator++() {

From 5f50142941b982f4c6fcf18b3f7ab65d00193395 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 7 Sep 2015 22:17:46 -0700
Subject: [PATCH 1350/1866] adds braces around if body

---
 groupby.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/groupby.hpp b/groupby.hpp
index 78340416..d8e79d0b 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -81,7 +81,7 @@ class iter::impl::GroupProducer {
           key_func{other.key_func} {}
 
     Iterator& operator=(const Iterator& other) {
-      if (this == &other) return *this;
+      if (this == &other) { return *this; }
       this->sub_iter = other.sub_iter;
       this->sub_end = other.sub_end;
       this->item = other.item;

From 445d734a5da094bde0caaab22509ae6956b814c3 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 7 Sep 2015 22:19:43 -0700
Subject: [PATCH 1351/1866] fixes clang-tidy warnings

---
 range.hpp | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/range.hpp b/range.hpp
index 74d6bc5d..67a0c267 100644
--- a/range.hpp
+++ b/range.hpp
@@ -68,7 +68,7 @@ namespace iter {
       T start_{};
       T value_{};
       T step_{};
-      unsigned long steps_taken{};
+      std::size_t steps_taken{};
 
      public:
       constexpr RangeIterData() noexcept = default;
@@ -162,9 +162,8 @@ class iter::impl::Range {
         const Iterator& lhs, const Iterator& rhs) noexcept {
       if (rhs.is_end) {
         return not_equal_to_impl(lhs, rhs, std::is_unsigned<T>{});
-      } else {
-        return not_equal_to_impl(rhs, lhs, std::is_unsigned<T>{});
       }
+      return not_equal_to_impl(rhs, lhs, std::is_unsigned<T>{});
     }
 
    public:

From 7bd394a3228e3a0fbdf826c46f5c85dd6d8f62a4 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 7 Sep 2015 22:21:31 -0700
Subject: [PATCH 1352/1866] adds braces around if body

---
 sliding_window.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sliding_window.hpp b/sliding_window.hpp
index cffc0e0f..11b633d1 100644
--- a/sliding_window.hpp
+++ b/sliding_window.hpp
@@ -55,7 +55,7 @@ class iter::impl::WindowSlider {
       while (i < window_sz && this->sub_iter != in_end) {
         this->window.get().push_back(this->sub_iter);
         ++i;
-        if (i != window_sz) ++this->sub_iter;
+        if (i != window_sz) { ++this->sub_iter; }
       }
     }
 

From eb3b7042000ad2e4e9944cb83f78e1b0b2bd88f2 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 7 Sep 2015 22:22:11 -0700
Subject: [PATCH 1353/1866] removes else after return

---
 unique_everseen.hpp | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/unique_everseen.hpp b/unique_everseen.hpp
index 5a993304..8be77d85 100644
--- a/unique_everseen.hpp
+++ b/unique_everseen.hpp
@@ -27,9 +27,8 @@ namespace iter {
           if (elem_seen.find(e) == std::end(elem_seen)) {
             elem_seen.insert(e);
             return true;
-          } else {
-            return false;
           }
+          return false;
         };
     return filter(func, std::forward<Container>(container));
   }
@@ -42,9 +41,8 @@ namespace iter {
       if (elem_seen.find(e) == std::end(elem_seen)) {
         elem_seen.insert(e);
         return true;
-      } else {
-        return false;
       }
+      return false;
     };
     return filter(func, il);
   }

From 16f5868e4a77660ae3b3317fb50fefaed206f53f Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 7 Sep 2015 22:25:44 -0700
Subject: [PATCH 1354/1866] removes else after return

---
 zip_longest.hpp | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/zip_longest.hpp b/zip_longest.hpp
index dcd9ec59..e0566ea4 100644
--- a/zip_longest.hpp
+++ b/zip_longest.hpp
@@ -88,9 +88,8 @@ class iter::impl::ZippedLongest<Container, RestContainers...> {
       if (this->iter != this->end) {
         return std::tuple_cat(
             std::tuple<OptType>{{*this->iter}}, *this->rest_iter);
-      } else {
-        return std::tuple_cat(std::tuple<OptType>{{}}, *this->rest_iter);
       }
+      return std::tuple_cat(std::tuple<OptType>{{}}, *this->rest_iter);
     }
 
     ArrowProxy<ZipIterDeref> operator->() {

From 0cbab1df0403c154e04e520639fc4dd559d4ca85 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 8 Sep 2015 20:49:03 -0700
Subject: [PATCH 1355/1866] uses make_shared in powerset

---
 powerset.hpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/powerset.hpp b/powerset.hpp
index 83e7ebe4..b79c2c96 100644
--- a/powerset.hpp
+++ b/powerset.hpp
@@ -54,7 +54,8 @@ class iter::impl::Powersetter {
     Iterator(Container& in_container, std::size_t sz)
         : container_p{&in_container},
           set_size{sz},
-          comb{new CombinatorType(combinations(in_container, sz))},
+          comb{
+              std::make_shared<CombinatorType>(combinations(in_container, sz))},
           comb_iter{std::begin(*comb)},
           comb_end{std::end(*comb)} {}
 
@@ -62,8 +63,8 @@ class iter::impl::Powersetter {
       ++this->comb_iter;
       if (this->comb_iter == this->comb_end) {
         ++this->set_size;
-        this->comb.reset(new CombinatorType(
-            combinations(*this->container_p, this->set_size)));
+        this->comb = std::make_shared<CombinatorType>(
+            combinations(*this->container_p, this->set_size));
         this->comb_iter = std::begin(*this->comb);
         this->comb_end = std::end(*this->comb);
       }

From b4160e48ddf29a998a7c8ceea0dd15140828953b Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 8 Sep 2015 22:17:10 -0700
Subject: [PATCH 1356/1866] tests iterbase implementation functionality

---
 test/test_iterbase.cpp | 97 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 97 insertions(+)
 create mode 100644 test/test_iterbase.cpp

diff --git a/test/test_iterbase.cpp b/test/test_iterbase.cpp
new file mode 100644
index 00000000..95122697
--- /dev/null
+++ b/test/test_iterbase.cpp
@@ -0,0 +1,97 @@
+// AGAIN the contents of iterbase are completely subject to change, do not rely
+// on any of this.  Users of the library must consider all of this undocumented
+//
+
+#include <internal/iterbase.hpp>
+#include <type_traits>
+#include <vector>
+#include <iterator>
+#include <string>
+#include <list>
+#include <enumerate.hpp>
+
+#include "catch.hpp"
+#include "helpers.hpp"
+
+namespace it = iter::impl;
+
+using IVec = std::vector<int>;
+
+template <typename T>
+using hrai = it::has_random_access_iter<T>;
+TEST_CASE("Detects random access iterators correctly", "[iterbase]") {
+  REQUIRE(hrai<std::vector<int>>::value);
+  REQUIRE(hrai<std::string>::value);
+  REQUIRE(hrai<int[10]>::value);
+
+  REQUIRE_FALSE(hrai<std::list<int>>::value);
+  REQUIRE_FALSE(hrai<decltype(iter::enumerate(std::list<int>{}))>::value);
+  REQUIRE_FALSE(hrai<itertest::BasicIterable<int>>::value);
+}
+
+TEST_CASE("Detects correct iterator types", "[iterbase]") {
+  REQUIRE((std::is_same<it::iterator_type<IVec>, IVec::iterator>::value));
+  REQUIRE((std::is_same<it::iterator_type<IVec>, IVec::iterator>::value));
+  REQUIRE((std::is_same<it::iterator_deref<IVec>,
+      IVec::iterator::reference>::value));
+  REQUIRE((std::is_same<it::const_iterator_deref<IVec>,
+      IVec::iterator::reference>::value));
+  REQUIRE((std::is_same<it::iterator_traits_deref<IVec>,
+      IVec::iterator::value_type>::value));
+
+  REQUIRE((std::is_same<it::reverse_iterator_type<IVec>,
+      IVec::reverse_iterator>::value));
+  REQUIRE((std::is_same<it::reverse_iterator_deref<IVec>,
+      IVec::reverse_iterator::reference>::value));
+  REQUIRE(
+      (std::is_same<it::iterator_arrow<IVec>, IVec::iterator::pointer>::value));
+  REQUIRE((std::is_same<it::iterator_arrow<int[10]>, int*>::value));
+  REQUIRE((std::is_same<it::reverse_iterator_arrow<IVec>,
+      IVec::reverse_iterator::pointer>::value));
+}
+
+TEST_CASE("advance, next, size", "[iterbase]") {
+  IVec v = {2, 4, 6, 8, 10, 12, 14, 16, 18};
+  auto itr = std::begin(v);
+  REQUIRE(it::apply_arrow(itr) == &v[0]);
+
+  it::dumb_advance(itr, 3);
+  REQUIRE(itr == (std::begin(v) + 3));
+  REQUIRE(it::dumb_next(std::begin(v), 3) == std::begin(v) + 3);
+  REQUIRE(it::dumb_size(v) == v.size());
+}
+
+TEST_CASE("are_same", "[iterbase]") {
+  REQUIRE((it::are_same<int, int, int, int>::value));
+  REQUIRE_FALSE((it::are_same<double, int, int, int>::value));
+  REQUIRE_FALSE((it::are_same<int, int, int, double>::value));
+  REQUIRE_FALSE((it::are_same<int, double, int, int>::value));
+}
+
+TEST_CASE("DerefHolder lvalue reference", "[iterbase]") {
+  it::DerefHolder<int&> dh;
+  int a = 2;
+  int b = 5;
+  REQUIRE_FALSE(dh);
+  dh.reset(a);
+  REQUIRE(dh);
+
+  REQUIRE(dh.get_ptr() == &a);
+  REQUIRE(&dh.get() == &a);
+  dh.reset(b);
+  REQUIRE(dh.get_ptr() == &b);
+  REQUIRE(&dh.get() == &b);
+}
+
+TEST_CASE("DerefHolder non-reference", "[iterbase]") {
+  it::DerefHolder<int> dh;
+  int a = 2;
+  int b = 5;
+  REQUIRE_FALSE(dh);
+  dh.reset(std::move(a));
+  REQUIRE(dh.get() == 2);
+  REQUIRE(&dh.get() != &a);
+
+  dh.reset(std::move(b));
+  REQUIRE(dh.get() == 5);
+}

From 90f30dbc528d1dce3926aa2e1ac145b7c1fb1267 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 8 Sep 2015 22:19:04 -0700
Subject: [PATCH 1357/1866] adds iterbase test, removes explicit CXX in scons

---
 test/SConstruct | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/SConstruct b/test/SConstruct
index 129c2dbf..d9513f5f 100644
--- a/test/SConstruct
+++ b/test/SConstruct
@@ -2,12 +2,11 @@ import os
 
 env = Environment(
     ENV = os.environ,
-    CXX='c++',
     CXXFLAGS= ['-g', '-Wall', '-Wextra',
                '-pedantic', '-std=c++11',
                '-I/usr/local/include', '-I.'],
     CPPPATH='..',
-    LINKFLAGS='-L/usr/local/lib')
+    LINKFLAGS=['-L/usr/local/lib'])
 
 # allows highighting to print to terminal from compiler output
 env['ENV']['TERM'] = os.environ['TERM']
@@ -43,6 +42,7 @@ progs = Split(
     zip
 
     iteratoriterator
+    iterbase
     mixed
     helpers
     '''

From b285ed2d4aff37009fb3c05bd3de2f3c50308f38 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 8 Sep 2015 22:20:25 -0700
Subject: [PATCH 1358/1866] simplifies derefholder, fixes operator bool

I needed to static_cast the unique_ptr..
---
 internal/iterbase.hpp | 19 ++++++++-----------
 1 file changed, 8 insertions(+), 11 deletions(-)

diff --git a/internal/iterbase.hpp b/internal/iterbase.hpp
index a3451bf4..fc344137 100644
--- a/internal/iterbase.hpp
+++ b/internal/iterbase.hpp
@@ -63,7 +63,7 @@ namespace iter {
       template <typename T, typename = void>
       struct ArrowHelper {
         using type = void;
-        void operator()(T&) const noexcept { }
+        void operator()(T&) const noexcept {}
       };
 
       template <typename T>
@@ -202,8 +202,7 @@ namespace iter {
     // get() returns a reference to the held item
     // get_ptr() returns a pointer to the held item
     // reset() replaces the currently held item
-
-    template <typename T, typename = void>
+    template <typename T>
     class DerefHolder {
      private:
       static_assert(!std::is_lvalue_reference<T>::value,
@@ -244,18 +243,16 @@ namespace iter {
       }
 
       explicit operator bool() const {
-        return this->item_p;
+        return static_cast<bool>(this->item_p);
       }
     };
 
-    // Specialization for when T is an lvalue ref.  Keep this in mind
-    // wherever a T appears.
+    // Specialization for when T is an lvalue ref
     template <typename T>
-    class DerefHolder<T,
-        typename std::enable_if<std::is_lvalue_reference<T>::value>::type> {
+    class DerefHolder<T&> {
      public:
-      using reference = T;
-      using pointer = typename std::remove_reference<T>::type*;
+      using reference = T&;
+      using pointer = T*;
 
      private:
       pointer item_p{};
@@ -271,7 +268,7 @@ namespace iter {
         return this->item_p;
       }
 
-      void reset(T item) {
+      void reset(reference item) {
         this->item_p = &item;
       }
 

From a9c719a7fa8e65a076aaa9b0c6c17194810156c0 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 8 Sep 2015 22:31:53 -0700
Subject: [PATCH 1359/1866] removes noexcept from accum iterator move

---
 accumulate.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/accumulate.hpp b/accumulate.hpp
index fdde9a64..6d336e2c 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -82,8 +82,8 @@ class iter::impl::Accumulator {
       return *this;
     }
 
-    Iterator(Iterator&&) noexcept = default;
-    Iterator& operator=(Iterator&&) noexcept = default;
+    Iterator(Iterator&&) = default;
+    Iterator& operator=(Iterator&&) = default;
 
     const AccumVal& operator*() const {
       return *this->acc_val;

From cea0bf753f59a7fbd938bb8cc7c628d01c2712bb Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Fri, 18 Sep 2015 18:02:28 -0700
Subject: [PATCH 1360/1866] tests that filter drops nullptrs by identity

---
 test/test_filter.cpp | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/test/test_filter.cpp b/test/test_filter.cpp
index 28ac6938..c6dc58ec 100644
--- a/test/test_filter.cpp
+++ b/test/test_filter.cpp
@@ -70,6 +70,17 @@ TEST_CASE("filter: using identity", "[filter]") {
   REQUIRE(v == vc);
 }
 
+TEST_CASE("filter: skips null pointers", "[filter]") {
+  int a = 1;
+  int b = 2;
+  const std::vector<int *> ns = {0, &a, nullptr, nullptr, &b, nullptr};
+
+  auto f = filter(ns);
+  const std::vector<int *> v(std::begin(f), std::end(f));
+  const std::vector<int *> vc = {&a, &b};
+  REQUIRE( v == vc );
+}
+
 TEST_CASE("filter: binds to lvalues, moves rvales", "[filter]") {
   itertest::BasicIterable<int> bi{1, 2, 3, 4};
 

From ec84a613c4d08e5214fbcad8b9c24fe92f22c2f0 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 27 Mar 2016 20:16:07 -0700
Subject: [PATCH 1361/1866] Removes development status notes from README

---
 README.md | 9 +--------
 1 file changed, 1 insertion(+), 8 deletions(-)

diff --git a/README.md b/README.md
index 7cadd713..dd55604e 100644
--- a/README.md
+++ b/README.md
@@ -1,12 +1,5 @@
-CPPItertools C++14 development Branch
+CPPItertools
 ============
-
-**NOTE**: this branch is for refining and moving forward with the C++14
-standard.  It will be merged into master when compiler and library
-support for the standard approaches completion in common compilers.
-Specifically I'm considering clang and gcc, along with libstdc++
-and libc++
-
 Range-based for loop add-ons inspired by the Python builtins and itertools
 library.  Like itertools and the Python3 builtins, this library uses lazy
 evaluation wherever possible.

From 7a872f9e3c37401bb98c0b44a56934381914770e Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 27 Mar 2016 20:38:54 -0700
Subject: [PATCH 1362/1866] uses callable struct instead of functions

---
 enumerate.hpp | 39 +++++++++++++++++----------------------
 1 file changed, 17 insertions(+), 22 deletions(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index 715eb7b0..f104b6eb 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -13,14 +13,8 @@ namespace iter {
   namespace impl {
     template <typename Container>
     class Enumerable;
+    struct EnumerateFn;
   }
-
-  template <typename Container>
-  impl::Enumerable<Container> enumerate(Container&&, std::size_t = 0);
-
-  template <typename T>
-  impl::Enumerable<std::initializer_list<T>> enumerate(
-      std::initializer_list<T>, std::size_t = 0);
 }
 
 template <typename Container>
@@ -29,12 +23,7 @@ class iter::impl::Enumerable {
   Container container;
   const std::size_t start;
 
-  // The only thing allowed to directly instantiate an Enumerable is
-  // the enumerate function
-  friend Enumerable iter::enumerate<Container>(Container&&, std::size_t);
-  template <typename T>
-  friend Enumerable<std::initializer_list<T>> iter::enumerate(
-      std::initializer_list<T>, std::size_t);
+  friend struct EnumerateFn;
 
   // for IterYield
   using BasePair = std::pair<std::size_t, iterator_deref<Container>>;
@@ -105,16 +94,22 @@ class iter::impl::Enumerable {
   }
 };
 
-template <typename Container>
-iter::impl::Enumerable<Container> iter::enumerate(
-    Container&& container, std::size_t start) {
-  return {std::forward<Container>(container), start};
-}
+struct iter::impl::EnumerateFn {
+  template <typename Container>
+  Enumerable<Container> operator()(
+      Container&& container, std::size_t start=0) const {
+    return {std::forward<Container>(container), start};
+  }
 
-template <typename T>
-iter::impl::Enumerable<std::initializer_list<T>> iter::enumerate(
-    std::initializer_list<T> il, std::size_t start) {
-  return {std::move(il), start};
+  template <typename T>
+  Enumerable<std::initializer_list<T>> operator()(
+      std::initializer_list<T> il, std::size_t start=0) const {
+    return {std::move(il), start};
+  }
+};
+
+namespace iter {
+constexpr impl::EnumerateFn enumerate;
 }
 
 #endif

From fa2eb57bf8142b9a94c86d70a3597e6b6b42aec7 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 1 Apr 2016 19:53:20 -0700
Subject: [PATCH 1363/1866] Replaces filter() functions with FilterFn class

---
 filter.hpp | 82 ++++++++++++++++++++++++------------------------------
 1 file changed, 37 insertions(+), 45 deletions(-)

diff --git a/filter.hpp b/filter.hpp
index e899b80b..041b73c5 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -11,14 +11,9 @@ namespace iter {
   namespace impl {
     template <typename FilterFunc, typename Container>
     class Filtered;
-  }
-
-  template <typename FilterFunc, typename Container>
-  impl::Filtered<FilterFunc, Container> filter(FilterFunc, Container&&);
 
-  template <typename FilterFunc, typename T>
-  impl::Filtered<FilterFunc, std::initializer_list<T>> filter(
-      FilterFunc, std::initializer_list<T>);
+    class FilterFn;
+  }
 }
 
 template <typename FilterFunc, typename Container>
@@ -27,12 +22,7 @@ class iter::impl::Filtered {
   Container container;
   FilterFunc filter_func;
 
-  // The filter function is the only thing allowed to create a Filtered
-  friend Filtered iter::filter<FilterFunc, Container>(FilterFunc, Container&&);
-
-  template <typename FF, typename T>
-  friend Filtered<FF, std::initializer_list<T>> iter::filter(
-      FF, std::initializer_list<T>);
+  friend class FilterFn;
 
   // Value constructor for use only in the filter function
   Filtered(FilterFunc in_filter_func, Container&& in_container)
@@ -117,46 +107,48 @@ class iter::impl::Filtered {
   }
 };
 
-template <typename FilterFunc, typename Container>
-iter::impl::Filtered<FilterFunc, Container> iter::filter(
-    FilterFunc filter_func, Container&& container) {
-  return {filter_func, std::forward<Container>(container)};
-}
-
-template <typename FilterFunc, typename T>
-iter::impl::Filtered<FilterFunc, std::initializer_list<T>> iter::filter(
-    FilterFunc filter_func, std::initializer_list<T> il) {
-  return {filter_func, std::move(il)};
-}
-
-namespace iter {
-  namespace detail {
+class iter::impl::FilterFn {
+ public:
+  template <typename FilterFunc, typename Container>
+  iter::impl::Filtered<FilterFunc, Container> operator()(
+      FilterFunc filter_func, Container&& container) const {
+    return {std::move(filter_func), std::forward<Container>(container)};
+  }
 
-    template <typename T>
-    bool boolean_cast(const T& t) {
-      return bool(t);
-    }
+  template <typename FilterFunc, typename T>
+  iter::impl::Filtered<FilterFunc, std::initializer_list<T>> operator()(
+      FilterFunc filter_func, std::initializer_list<T> il) const {
+    return {std::move(filter_func), std::move(il)};
+  }
 
-    template <typename Container>
-    class BoolTester {
-     public:
-      bool operator()(const impl::iterator_deref<Container> item) const {
-        return bool(item);
-      }
-    };
+  template <typename Container,
+      typename = std::enable_if_t<is_iterable<Container>>>
+  auto operator()(Container&& container) const {
+    return (*this)(BoolTester<Container>{}, std::forward<Container>(container));
   }
 
-  template <typename Container>
-  auto filter(Container&& container) {
-    return filter(
-        detail::BoolTester<Container>(), std::forward<Container>(container));
+  template <typename T>
+  auto operator()(std::initializer_list<T> il) const {
+    return (*this)(BoolTester<std::initializer_list<T>>{}, std::move(il));
   }
 
+ private:
   template <typename T>
-  auto filter(std::initializer_list<T> il) {
-    return filter(
-        detail::BoolTester<std::initializer_list<T>>(), std::move(il));
+  bool boolean_cast(const T& t) {
+    return bool(t);
   }
+
+  template <typename Container>
+  class BoolTester {
+   public:
+    bool operator()(const impl::iterator_deref<Container> item) const {
+      return bool(item);
+    }
+  };
+};
+
+namespace iter {
+  constexpr impl::FilterFn filter{};
 }
 
 #endif

From 6bde3578abc84a071bcca85156fe1b7d48d4e5a4 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 1 Apr 2016 19:56:21 -0700
Subject: [PATCH 1364/1866] tests filter with predicate and pipe

---
 test/test_filter.cpp | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/test/test_filter.cpp b/test/test_filter.cpp
index c6dc58ec..6e391245 100644
--- a/test/test_filter.cpp
+++ b/test/test_filter.cpp
@@ -127,6 +127,15 @@ TEST_CASE("filter: doesn't move or copy elements of iterable", "[filter]") {
   }
 }
 
+TEST_CASE("filter: works with pipe", "[filter]") {
+  Vec ns = {1, 2, 5, 6, 3, 1, 7, -1, 5};
+  Vec vc = {1, 2, 3, 1, -1};
+
+  auto f = ns | filter(LessThanValue{5});
+  Vec v(std::begin(f), std::end(f));
+  REQUIRE(v == vc);
+}
+
 TEST_CASE("filter: iterator meets requirements", "[filter]") {
   std::string s{};
   auto c = filter([] { return true; }, s);

From 6f53bda39893a29942f2fecbb7612c38fb8cbff6 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 1 Apr 2016 19:56:36 -0700
Subject: [PATCH 1365/1866] supports seq | filter(predicate)

---
 filter.hpp | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/filter.hpp b/filter.hpp
index 041b73c5..fa943bf4 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -132,6 +132,22 @@ class iter::impl::FilterFn {
     return (*this)(BoolTester<std::initializer_list<T>>{}, std::move(il));
   }
 
+  template <typename FilterFunc>
+  struct FilterFnPartial : Pipeable<FilterFnPartial<FilterFunc>> {
+    FilterFnPartial(FilterFunc f) : fun(std::move(f)) {}
+    template <typename Container>
+    auto operator()(Container&& container) const {
+      return FilterFn{}(fun, std::forward<Container>(container));
+    }
+   private:
+    FilterFunc fun;
+  };
+
+  template <typename FilterFunc, typename=std::enable_if_t<!is_iterable<FilterFunc>>>
+  FilterFnPartial<FilterFunc> operator()(FilterFunc filter_func) const {
+    return {filter_func};
+  }
+
  private:
   template <typename T>
   bool boolean_cast(const T& t) {

From b33570172d49fe896baecc20b76ac14a9a75683f Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 1 Apr 2016 19:58:39 -0700
Subject: [PATCH 1366/1866] supports seq | filter without predicate

---
 filter.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/filter.hpp b/filter.hpp
index fa943bf4..6ea9c0f8 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -107,7 +107,7 @@ class iter::impl::Filtered {
   }
 };
 
-class iter::impl::FilterFn {
+class iter::impl::FilterFn : public iter::impl::Pipeable<FilterFn> {
  public:
   template <typename FilterFunc, typename Container>
   iter::impl::Filtered<FilterFunc, Container> operator()(

From 06c528d1e941e3c70b61327f405b191ae7a86cc8 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 1 Apr 2016 19:59:03 -0700
Subject: [PATCH 1367/1866] tests filter with pipe and no predicate

---
 test/test_filter.cpp | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/test/test_filter.cpp b/test/test_filter.cpp
index 6e391245..cc68f616 100644
--- a/test/test_filter.cpp
+++ b/test/test_filter.cpp
@@ -136,6 +136,16 @@ TEST_CASE("filter: works with pipe", "[filter]") {
   REQUIRE(v == vc);
 }
 
+TEST_CASE("filter: using identity and pipe", "[filter]") {
+  Vec ns{0, 1, 2, 0, 3, 0, 0, 0, 4, 5, 0};
+  auto f = ns | filter;
+  Vec v(std::begin(f), std::end(f));
+
+  Vec vc = {1, 2, 3, 4, 5};
+  REQUIRE(v == vc);
+}
+
+
 TEST_CASE("filter: iterator meets requirements", "[filter]") {
   std::string s{};
   auto c = filter([] { return true; }, s);

From 55d272ffdee8a8af84884d63b87f72c3534fd792 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 3 Apr 2016 18:30:10 -0700
Subject: [PATCH 1368/1866] supports seq | enumerate

---
 enumerate.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index f104b6eb..1c4fb666 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -94,7 +94,7 @@ class iter::impl::Enumerable {
   }
 };
 
-struct iter::impl::EnumerateFn {
+struct iter::impl::EnumerateFn : iter::impl::Pipeable<EnumerateFn> {
   template <typename Container>
   Enumerable<Container> operator()(
       Container&& container, std::size_t start=0) const {

From 2be398391594b47ea5868ed713dba88f1e5e12fd Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 3 Apr 2016 18:31:22 -0700
Subject: [PATCH 1369/1866] adds IsIterable trait and Pipeable helper

I should've done these last few commits in a different order.
IsIterable<T> is true if T is an iterable (it can be passed to
std::begin()). Pipeable is a helper to allow the sequence to be passed
after the pipe. seq | iter::fun vs iter::fun(seq)
---
 internal/iterbase.hpp | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/internal/iterbase.hpp b/internal/iterbase.hpp
index 20d0fc39..afa9d0fd 100644
--- a/internal/iterbase.hpp
+++ b/internal/iterbase.hpp
@@ -50,6 +50,16 @@ namespace iter {
     using iterator_traits_deref =
         std::remove_reference_t<iterator_deref<Container>>;
 
+    template <typename T, typename=void>
+    struct IsIterable : std::false_type {};
+
+    // Assuming that if a type works with std::begin, it is an iterable.
+    template <typename T>
+    struct IsIterable<T, void_t<iterator_type<T>>> : std::true_type{};
+
+    template <typename T>
+    constexpr bool is_iterable = IsIterable<T>::value;
+
     namespace detail {
       template <typename T, typename = void>
       struct ArrowHelper {
@@ -315,6 +325,18 @@ namespace iter {
         return this->item_p != nullptr;
       }
     };
+
+    // allows f(x) to be 'called' as x | f
+    // let the record show I dislike adding yet another syntactical mess to
+    // this clown car of a language.
+    template<typename F>
+    struct Pipeable {
+      template<typename T>
+        friend decltype(auto) operator|(T&& x, const Pipeable& p) {
+          return static_cast<const F&>(p)(std::forward<T>(x));
+      }
+    };
+
   }
 }
 

From 60d201da11bdd86b87628613b5a780215be13365 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 3 Apr 2016 18:35:00 -0700
Subject: [PATCH 1370/1866] tests that enumerate works with pipe

---
 test/test_enumerate.cpp | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/test/test_enumerate.cpp b/test/test_enumerate.cpp
index 778cce39..38b3a90a 100644
--- a/test/test_enumerate.cpp
+++ b/test/test_enumerate.cpp
@@ -137,6 +137,15 @@ TEST_CASE("enumerate: iterator meets requirements", "[enumerate]") {
   REQUIRE(itertest::IsIterator<decltype(std::begin(c))>::value);
 }
 
+TEST_CASE("enumerate: works with pipe", "[enumerate]") {
+  constexpr char str[] = {'a', 'b', 'c'};
+  auto e = str | enumerate;
+  Vec v(std::begin(e), std::end(e));
+  Vec vc{{0, 'a'}, {1, 'b'}, {2, 'c'}};
+
+  REQUIRE(v == vc);
+}
+
 template <typename T>
 using ImpT = decltype(enumerate(std::declval<T>()));
 TEST_CASE("enumerate: has correct ctor and assign ops", "[enumerate]") {

From a4e454f9229955c640585aa8f4117fc6a6c5cefa Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 3 Apr 2016 18:59:06 -0700
Subject: [PATCH 1371/1866] formatting

---
 test/test_chain.cpp   |  10 ++--
 test/test_imap.cpp    |   8 +--
 test/test_sorted.cpp  |   6 +-
 test/test_starmap.cpp | 132 +++++++++++++++++++++---------------------
 4 files changed, 77 insertions(+), 79 deletions(-)

diff --git a/test/test_chain.cpp b/test/test_chain.cpp
index 8594e73a..7630270b 100644
--- a/test/test_chain.cpp
+++ b/test/test_chain.cpp
@@ -194,11 +194,11 @@ TEST_CASE("chain.from_iterable: postfix ++", "[chain.from_iterable]") {
   REQUIRE(*it == 'n');
 }
 
-TEST_CASE("chain.from_iterable: operator->","[chain.from_iterable]") {
-    std::vector<std::vector<std::string>> sv{{"a", "ab"}, {"abc"}};
-    auto ch = chain.from_iterable(sv);
-    auto it = std::begin(ch);
-    REQUIRE( it->size() == 1 );
+TEST_CASE("chain.from_iterable: operator->", "[chain.from_iterable]") {
+  std::vector<std::vector<std::string>> sv{{"a", "ab"}, {"abc"}};
+  auto ch = chain.from_iterable(sv);
+  auto it = std::begin(ch);
+  REQUIRE(it->size() == 1);
 }
 
 TEST_CASE("chain.from_iterable: moves rvalues and binds ref to lvalues",
diff --git a/test/test_imap.cpp b/test/test_imap.cpp
index 9a19cd87..f150d3aa 100644
--- a/test/test_imap.cpp
+++ b/test/test_imap.cpp
@@ -42,10 +42,10 @@ TEST_CASE("imap: works with lambda, callable, and function", "[imap]") {
   }
 
   SECTION("with callable") {
-      auto im = imap(PlusOner{}, ns);
-      Vec v(std::begin(im), std::end(im));
-      Vec vc = {11, 21, 31};
-      REQUIRE( v == vc );
+    auto im = imap(PlusOner{}, ns);
+    Vec v(std::begin(im), std::end(im));
+    Vec vc = {11, 21, 31};
+    REQUIRE(v == vc);
   }
 
   SECTION("with function") {
diff --git a/test/test_sorted.cpp b/test/test_sorted.cpp
index cc477f84..f6c902ba 100644
--- a/test/test_sorted.cpp
+++ b/test/test_sorted.cpp
@@ -181,7 +181,7 @@ TEST_CASE("sorted: has correct ctor and assign ops", "[sorted]") {
 }
 
 TEST_CASE("sorted: iterator meets requirements", "[sorted]") {
-    Vec v;
-    auto r = sorted(v);
-    REQUIRE( itertest::IsIterator<decltype(std::begin(r))>::value );
+  Vec v;
+  auto r = sorted(v);
+  REQUIRE(itertest::IsIterator<decltype(std::begin(r))>::value);
 }
diff --git a/test/test_starmap.cpp b/test/test_starmap.cpp
index 994f96b7..751d3d4e 100644
--- a/test/test_starmap.cpp
+++ b/test/test_starmap.cpp
@@ -12,100 +12,98 @@
 using iter::starmap;
 
 namespace {
-    long f(long d, int i) {
-        return d * i;
+  long f(long d, int i) {
+    return d * i;
+  }
+
+  std::string g(const std::string& s, int i, char c) {
+    std::stringstream ss;
+    ss << s << ' ' << i << ' ' << c;
+    return ss.str();
+  }
+
+  struct Callable {
+    int operator()(int a, int b, int c) {
+      return a + b + c;
     }
 
-    std::string g(const std::string& s, int i, char c) {
-        std::stringstream ss;
-        ss << s << ' ' << i << ' ' << c;
-        return ss.str();
+    int operator()(int a) {
+      return a;
     }
-
-    struct Callable {
-        int operator()(int a, int b, int c) {
-            return a + b + c;
-        }
-
-        int operator()(int a) {
-            return a;
-        }
-    };
+  };
 }
 
 TEST_CASE("starmap: works with function pointer and lambda", "[starmap]") {
-    using Vec = const std::vector<int>;
-    const std::vector<std::pair<double, int>> v1 =
-        {{1l, 2}, {3l, 11}, {6l, 7}};
-    Vec vc = {2l, 33l, 42l};
-
-    SECTION("with function") {
-        auto sm = starmap(f, v1);
-        Vec v(std::begin(sm), std::end(sm));
-        REQUIRE( v == vc );
-    }
+  using Vec = const std::vector<int>;
+  const std::vector<std::pair<double, int>> v1 = {{1l, 2}, {3l, 11}, {6l, 7}};
+  Vec vc = {2l, 33l, 42l};
 
-    SECTION("with lambda") {
-        auto sm = starmap([](long a, int b) { return a * b; }, v1);
-        Vec v(std::begin(sm), std::end(sm));
-        REQUIRE( v == vc );
-    }
+  SECTION("with function") {
+    auto sm = starmap(f, v1);
+    Vec v(std::begin(sm), std::end(sm));
+    REQUIRE(v == vc);
+  }
+
+  SECTION("with lambda") {
+    auto sm = starmap([](long a, int b) { return a * b; }, v1);
+    Vec v(std::begin(sm), std::end(sm));
+    REQUIRE(v == vc);
+  }
 }
 
 TEST_CASE("starmap: list of tuples", "[starmap]") {
-    using Vec = const std::vector<std::string>;
-    using T = std::tuple<std::string, int, double>;
-    std::list<T> li =
-        {T{"hey", 42, 'a'}, T{"there", 3, 'b'}, T{"yall", 5, 'c'}};
+  using Vec = const std::vector<std::string>;
+  using T = std::tuple<std::string, int, double>;
+  std::list<T> li = {T{"hey", 42, 'a'}, T{"there", 3, 'b'}, T{"yall", 5, 'c'}};
 
-    auto sm = starmap(g, li);
-    Vec v(std::begin(sm), std::end(sm));
-    Vec vc = {"hey 42 a", "there 3 b", "yall 5 c"};
+  auto sm = starmap(g, li);
+  Vec v(std::begin(sm), std::end(sm));
+  Vec vc = {"hey 42 a", "there 3 b", "yall 5 c"};
 
-    REQUIRE( v == vc );
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("starmap: tuple of tuples", "[starmap]") {
-    using Vec = const std::vector<int>;
-    auto tup = std::make_tuple(std::make_tuple(10, 19, 60),std::make_tuple(7));
-    auto sm = starmap(Callable{}, tup);
-    Vec v(std::begin(sm), std::end(sm));
-    Vec vc = {89, 7};
+  using Vec = const std::vector<int>;
+  auto tup = std::make_tuple(std::make_tuple(10, 19, 60), std::make_tuple(7));
+  auto sm = starmap(Callable{}, tup);
+  Vec v(std::begin(sm), std::end(sm));
+  Vec vc = {89, 7};
 
-    REQUIRE( v == vc );
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("starmap: tuple of pairs", "[starmap]") {
-    using Vec = const std::vector<int>;
-    auto p = std::make_pair(std::array<int, 3>{{15, 100, 2000}},
-                            std::make_tuple(16));
-    Callable c;
-    auto sm = starmap(c, p);
+  using Vec = const std::vector<int>;
+  auto p =
+      std::make_pair(std::array<int, 3>{{15, 100, 2000}}, std::make_tuple(16));
+  Callable c;
+  auto sm = starmap(c, p);
 
-    Vec v(std::begin(sm), std::end(sm));
-    Vec vc = {2115, 16};
+  Vec v(std::begin(sm), std::end(sm));
+  Vec vc = {2115, 16};
 
-    REQUIRE( v == vc );
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("starmap: moves rvalues, binds to lvalues", "[starmap]") {
-    itertest::BasicIterable<std::tuple<int>> bi{};
-    starmap(Callable{}, bi);
-    REQUIRE_FALSE( bi.was_moved_from() );
-    starmap(Callable{}, std::move(bi));
-    REQUIRE( bi.was_moved_from() );
+  itertest::BasicIterable<std::tuple<int>> bi{};
+  starmap(Callable{}, bi);
+  REQUIRE_FALSE(bi.was_moved_from());
+  starmap(Callable{}, std::move(bi));
+  REQUIRE(bi.was_moved_from());
 }
 
 TEST_CASE("starmap: iterator meets requirements", "[starmap]") {
-    std::string s{};
-    const std::vector<std::pair<double, int>> v1;
-    auto sm = starmap([](long a, int b) { return a * b; }, v1);
-    REQUIRE( itertest::IsIterator<decltype(std::begin(sm))>::value );
+  std::string s{};
+  const std::vector<std::pair<double, int>> v1;
+  auto sm = starmap([](long a, int b) { return a * b; }, v1);
+  REQUIRE(itertest::IsIterator<decltype(std::begin(sm))>::value);
 }
 
-TEST_CASE("starmap:  tuple of tuples iterator meets requirements",
-        "[starmap]") {
-    auto tup = std::make_tuple(std::make_tuple(10, 19, 60),std::make_tuple(7));
-    auto sm = starmap(Callable{}, tup);
-    REQUIRE( itertest::IsIterator<decltype(std::begin(sm))>::value );
+TEST_CASE(
+    "starmap:  tuple of tuples iterator meets requirements", "[starmap]") {
+  auto tup = std::make_tuple(std::make_tuple(10, 19, 60), std::make_tuple(7));
+  auto sm = starmap(Callable{}, tup);
+  REQUIRE(itertest::IsIterator<decltype(std::begin(sm))>::value);
 }

From 060632ec27056960b0866f533514efaf40fcf521 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 3 Apr 2016 18:59:23 -0700
Subject: [PATCH 1372/1866] Make general use currier for passing first arg

---
 internal/iterbase.hpp | 34 ++++++++++++++++++++++++++--------
 1 file changed, 26 insertions(+), 8 deletions(-)

diff --git a/internal/iterbase.hpp b/internal/iterbase.hpp
index afa9d0fd..c109c477 100644
--- a/internal/iterbase.hpp
+++ b/internal/iterbase.hpp
@@ -50,12 +50,12 @@ namespace iter {
     using iterator_traits_deref =
         std::remove_reference_t<iterator_deref<Container>>;
 
-    template <typename T, typename=void>
+    template <typename T, typename = void>
     struct IsIterable : std::false_type {};
 
     // Assuming that if a type works with std::begin, it is an iterable.
     template <typename T>
-    struct IsIterable<T, void_t<iterator_type<T>>> : std::true_type{};
+    struct IsIterable<T, void_t<iterator_type<T>>> : std::true_type {};
 
     template <typename T>
     constexpr bool is_iterable = IsIterable<T>::value;
@@ -209,7 +209,6 @@ namespace iter {
     using iterator_tuple_type =
         decltype(detail::iterator_tuple_type_helper(std::declval<TupleType>()));
 
-
     // Given a tuple template argument, evaluates to a tuple of
     // what the iterators for the template argument's contained types
     // dereference to
@@ -230,7 +229,7 @@ namespace iter {
       decltype(auto) call_with_tuple_impl(
           Func&& mf, TupleType&& tup, std::index_sequence<Is...>) {
         return mf(std::forward<std::tuple_element_t<Is,
-            std::remove_reference_t<TupleType>>>(std::get<Is>(tup))...);
+                std::remove_reference_t<TupleType>>>(std::get<Is>(tup))...);
       }
     }
 
@@ -329,14 +328,33 @@ namespace iter {
     // allows f(x) to be 'called' as x | f
     // let the record show I dislike adding yet another syntactical mess to
     // this clown car of a language.
-    template<typename F>
+    template <typename ItTool>
     struct Pipeable {
-      template<typename T>
-        friend decltype(auto) operator|(T&& x, const Pipeable& p) {
-          return static_cast<const F&>(p)(std::forward<T>(x));
+      template <typename T>
+      friend decltype(auto) operator|(T&& x, const Pipeable& p) {
+        return static_cast<const ItTool&>(p)(std::forward<T>(x));
+      }
+    };
+
+    // T is whatever is being held for later use
+    template <typename ItTool, typename T>
+    struct FnPartial : Pipeable<FnPartial<ItTool, T>> {
+      ItTool tool_fun;
+      mutable T t;
+      FnPartial(ItTool in_tool, T in_t)
+          : tool_fun(std::move(in_tool)), t(std::move(in_t)) {}
+      template <typename Container>
+      auto operator()(Container&& container) const {
+        return tool_fun(t, std::forward<Container>(container));
       }
     };
 
+#if 0
+    template <typename ItTool>
+    struct PipeableAndBindFirst : Pipeable<ItTool> {
+
+    };
+#endif
   }
 }
 

From d5b68aa5a76818bf007f100beace81602dc375b9 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 3 Apr 2016 19:00:04 -0700
Subject: [PATCH 1373/1866] formatting

---
 test/test_filter.cpp | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/test/test_filter.cpp b/test/test_filter.cpp
index cc68f616..63b8e068 100644
--- a/test/test_filter.cpp
+++ b/test/test_filter.cpp
@@ -73,12 +73,12 @@ TEST_CASE("filter: using identity", "[filter]") {
 TEST_CASE("filter: skips null pointers", "[filter]") {
   int a = 1;
   int b = 2;
-  const std::vector<int *> ns = {0, &a, nullptr, nullptr, &b, nullptr};
+  const std::vector<int*> ns = {0, &a, nullptr, nullptr, &b, nullptr};
 
   auto f = filter(ns);
-  const std::vector<int *> v(std::begin(f), std::end(f));
-  const std::vector<int *> vc = {&a, &b};
-  REQUIRE( v == vc );
+  const std::vector<int*> v(std::begin(f), std::end(f));
+  const std::vector<int*> vc = {&a, &b};
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("filter: binds to lvalues, moves rvales", "[filter]") {
@@ -145,7 +145,6 @@ TEST_CASE("filter: using identity and pipe", "[filter]") {
   REQUIRE(v == vc);
 }
 
-
 TEST_CASE("filter: iterator meets requirements", "[filter]") {
   std::string s{};
   auto c = filter([] { return true; }, s);

From 1c1843e247119ffcc8a09436fa0257dc7a0cd45f Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 3 Apr 2016 19:00:09 -0700
Subject: [PATCH 1374/1866] uses general FnPartial

---
 filter.hpp | 18 ++++--------------
 1 file changed, 4 insertions(+), 14 deletions(-)

diff --git a/filter.hpp b/filter.hpp
index 6ea9c0f8..31da8842 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -132,20 +132,10 @@ class iter::impl::FilterFn : public iter::impl::Pipeable<FilterFn> {
     return (*this)(BoolTester<std::initializer_list<T>>{}, std::move(il));
   }
 
-  template <typename FilterFunc>
-  struct FilterFnPartial : Pipeable<FilterFnPartial<FilterFunc>> {
-    FilterFnPartial(FilterFunc f) : fun(std::move(f)) {}
-    template <typename Container>
-    auto operator()(Container&& container) const {
-      return FilterFn{}(fun, std::forward<Container>(container));
-    }
-   private:
-    FilterFunc fun;
-  };
-
-  template <typename FilterFunc, typename=std::enable_if_t<!is_iterable<FilterFunc>>>
-  FilterFnPartial<FilterFunc> operator()(FilterFunc filter_func) const {
-    return {filter_func};
+  template <typename FilterFunc,
+      typename = std::enable_if_t<!is_iterable<FilterFunc>>>
+  FnPartial<FilterFn, FilterFunc> operator()(FilterFunc filter_func) const {
+    return {*this, std::move(filter_func)};
   }
 
  private:

From 632d45131ac78b62357eb05cc0d996626de9e25b Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 3 Apr 2016 19:55:47 -0700
Subject: [PATCH 1375/1866] minor FnPartial improvements

---
 internal/iterbase.hpp | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/internal/iterbase.hpp b/internal/iterbase.hpp
index c109c477..64eae3e4 100644
--- a/internal/iterbase.hpp
+++ b/internal/iterbase.hpp
@@ -340,21 +340,23 @@ namespace iter {
     template <typename ItTool, typename T>
     struct FnPartial : Pipeable<FnPartial<ItTool, T>> {
       ItTool tool_fun;
-      mutable T t;
-      FnPartial(ItTool in_tool, T in_t)
-          : tool_fun(std::move(in_tool)), t(std::move(in_t)) {}
+      mutable T stored_arg;
+      constexpr FnPartial(ItTool in_tool, T in_t)
+          : tool_fun(in_tool), stored_arg(in_t) {}
+
       template <typename Container>
       auto operator()(Container&& container) const {
-        return tool_fun(t, std::forward<Container>(container));
+        return tool_fun(stored_arg, std::forward<Container>(container));
       }
     };
 
-#if 0
     template <typename ItTool>
     struct PipeableAndBindFirst : Pipeable<ItTool> {
-
+      template <typename Func, typename = std::enable_if_t<!is_iterable<Func>>>
+      FnPartial<ItTool, Func> operator()(Func func) const {
+        return {static_cast<const ItTool&>(*this), std::move(func)};
+      }
     };
-#endif
   }
 }
 

From e83e6a68e2b0c22ab03f8de6e1a7763720662691 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 3 Apr 2016 19:56:08 -0700
Subject: [PATCH 1376/1866] uses base class partial overload

---
 filter.hpp | 9 ++-------
 1 file changed, 2 insertions(+), 7 deletions(-)

diff --git a/filter.hpp b/filter.hpp
index 31da8842..79e8d810 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -107,7 +107,7 @@ class iter::impl::Filtered {
   }
 };
 
-class iter::impl::FilterFn : public iter::impl::Pipeable<FilterFn> {
+class iter::impl::FilterFn : public PipeableAndBindFirst<FilterFn> {
  public:
   template <typename FilterFunc, typename Container>
   iter::impl::Filtered<FilterFunc, Container> operator()(
@@ -131,12 +131,7 @@ class iter::impl::FilterFn : public iter::impl::Pipeable<FilterFn> {
   auto operator()(std::initializer_list<T> il) const {
     return (*this)(BoolTester<std::initializer_list<T>>{}, std::move(il));
   }
-
-  template <typename FilterFunc,
-      typename = std::enable_if_t<!is_iterable<FilterFunc>>>
-  FnPartial<FilterFn, FilterFunc> operator()(FilterFunc filter_func) const {
-    return {*this, std::move(filter_func)};
-  }
+  using PipeableAndBindFirst<FilterFn>::operator();
 
  private:
   template <typename T>

From c708b40579b49bdf05b1c3921af79463e1f3d442 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 4 Apr 2016 22:36:07 -0700
Subject: [PATCH 1377/1866] Removes extra "class" in friend declarations.

---
 chain.hpp     | 4 ++--
 enumerate.hpp | 2 +-
 filter.hpp    | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/chain.hpp b/chain.hpp
index 66fd0f91..470ca4e3 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -28,7 +28,7 @@ namespace iter {
 template <typename TupType, std::size_t... Is>
 class iter::impl::Chained {
  private:
-  friend class ChainMaker;
+  friend ChainMaker;
 
   static_assert(std::tuple_size<std::decay_t<TupType>>::value == sizeof...(Is),
       "tuple size != sizeof Is");
@@ -171,7 +171,7 @@ template <typename Container>
 class iter::impl::ChainedFromIterable {
  private:
   Container container;
-  friend class ChainMaker;
+  friend ChainMaker;
   ChainedFromIterable(Container&& in_container)
       : container(std::forward<Container>(in_container)) {}
 
diff --git a/enumerate.hpp b/enumerate.hpp
index 1c4fb666..f85c8e21 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -23,7 +23,7 @@ class iter::impl::Enumerable {
   Container container;
   const std::size_t start;
 
-  friend struct EnumerateFn;
+  friend EnumerateFn;
 
   // for IterYield
   using BasePair = std::pair<std::size_t, iterator_deref<Container>>;
diff --git a/filter.hpp b/filter.hpp
index 79e8d810..b2da5994 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -22,7 +22,7 @@ class iter::impl::Filtered {
   Container container;
   FilterFunc filter_func;
 
-  friend class FilterFn;
+  friend FilterFn;
 
   // Value constructor for use only in the filter function
   Filtered(FilterFunc in_filter_func, Container&& in_container)

From efe0c77b24988ad76eb1c359bb32ff478b731538 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 7 Apr 2016 00:30:23 -0700
Subject: [PATCH 1378/1866] adds explicit "u" to enumerate start val

---
 test/test_enumerate.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/test_enumerate.cpp b/test/test_enumerate.cpp
index 38b3a90a..5d0e67e6 100644
--- a/test/test_enumerate.cpp
+++ b/test/test_enumerate.cpp
@@ -50,7 +50,7 @@ TEST_CASE("Postfix ++ enumerate", "[enumerate]") {
 
 TEST_CASE("enumerate: with starting value", "[enumerate]") {
   std::string str = "hey";
-  auto e = enumerate(str, 5);
+  auto e = enumerate(str, 5u);
   Vec v(std::begin(e), std::end(e));
   Vec vc{{5, 'h'}, {6, 'e'}, {7, 'y'}};
 

From 3a8f11d6f1103b4a2bf4dca6f650a18bc7124f6e Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 7 Apr 2016 00:34:35 -0700
Subject: [PATCH 1379/1866] Adds IterToolFn to generalize the callables

---
 internal/iterbase.hpp | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/internal/iterbase.hpp b/internal/iterbase.hpp
index 64eae3e4..7d8acb0d 100644
--- a/internal/iterbase.hpp
+++ b/internal/iterbase.hpp
@@ -357,6 +357,22 @@ namespace iter {
         return {static_cast<const ItTool&>(*this), std::move(func)};
       }
     };
+
+    // Pipeable Callable generator, where ItImpl is templated on the first
+    // argument to the call.
+    template <template <typename> class ItImpl>
+    struct IterToolFn : Pipeable<IterToolFn<ItImpl>> {
+      template <typename T, typename... Ts>
+      ItImpl<T> operator()(T&& t, Ts... ts) const {
+        return {std::forward<T>(t), std::move(ts)...};
+      }
+
+      template <typename T, typename... Ts>
+      ItImpl<std::initializer_list<T>> operator()(
+          std::initializer_list<T> il, Ts... ts) const {
+        return {std::move(il), std::move(ts)...};
+      }
+    };
   }
 }
 

From 87cda7c3778aed1cdca4fef7e4e72f60d78aec2c Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 7 Apr 2016 00:35:37 -0700
Subject: [PATCH 1380/1866] uses IterToolFn in enumerate

---
 enumerate.hpp | 24 ++++--------------------
 1 file changed, 4 insertions(+), 20 deletions(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index f85c8e21..b8f58d37 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -13,8 +13,10 @@ namespace iter {
   namespace impl {
     template <typename Container>
     class Enumerable;
-    struct EnumerateFn;
+
+    using EnumerateFn = IterToolFn<Enumerable>;
   }
+  constexpr impl::EnumerateFn enumerate;
 }
 
 template <typename Container>
@@ -29,7 +31,7 @@ class iter::impl::Enumerable {
   using BasePair = std::pair<std::size_t, iterator_deref<Container>>;
 
   // Value constructor for use only in the enumerate function
-  Enumerable(Container&& in_container, std::size_t in_start)
+  Enumerable(Container&& in_container, std::size_t in_start = 0)
       : container(std::forward<Container>(in_container)), start{in_start} {}
 
  public:
@@ -94,22 +96,4 @@ class iter::impl::Enumerable {
   }
 };
 
-struct iter::impl::EnumerateFn : iter::impl::Pipeable<EnumerateFn> {
-  template <typename Container>
-  Enumerable<Container> operator()(
-      Container&& container, std::size_t start=0) const {
-    return {std::forward<Container>(container), start};
-  }
-
-  template <typename T>
-  Enumerable<std::initializer_list<T>> operator()(
-      std::initializer_list<T> il, std::size_t start=0) const {
-    return {std::move(il), start};
-  }
-};
-
-namespace iter {
-constexpr impl::EnumerateFn enumerate;
-}
-
 #endif

From eab2146d52e3af478dad2ab267e1ef1b7a2170e2 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 7 Apr 2016 00:42:28 -0700
Subject: [PATCH 1381/1866] switches cycle function to CycleFn

---
 cycle.hpp | 34 +++++++++++++++++-----------------
 1 file changed, 17 insertions(+), 17 deletions(-)

diff --git a/cycle.hpp b/cycle.hpp
index ac4f5401..209b1522 100644
--- a/cycle.hpp
+++ b/cycle.hpp
@@ -11,21 +11,15 @@ namespace iter {
   namespace impl {
     template <typename Container>
     class Cycler;
-  }
-
-  template <typename Container>
-  impl::Cycler<Container> cycle(Container&&);
 
-  template <typename T>
-  impl::Cycler<std::initializer_list<T>> cycle(std::initializer_list<T>);
+    struct CycleFn;
+  }
 }
 
 template <typename Container>
 class iter::impl::Cycler {
  private:
-  friend Cycler iter::cycle<Container>(Container&&);
-  template <typename T>
-  friend Cycler<std::initializer_list<T>> iter::cycle(std::initializer_list<T>);
+  friend CycleFn;
 
   Container container;
 
@@ -87,15 +81,21 @@ class iter::impl::Cycler {
   }
 };
 
-template <typename Container>
-iter::impl::Cycler<Container> iter::cycle(Container&& container) {
-  return {std::forward<Container>(container)};
-}
+struct iter::impl::CycleFn {
+  template <typename Container>
+  iter::impl::Cycler<Container> operator()(Container&& container) const {
+    return {std::forward<Container>(container)};
+  }
 
-template <typename T>
-iter::impl::Cycler<std::initializer_list<T>> iter::cycle(
-    std::initializer_list<T> il) {
-  return {std::move(il)};
+  template <typename T>
+  iter::impl::Cycler<std::initializer_list<T>> operator()(
+      std::initializer_list<T> il) const {
+    return {std::move(il)};
+  }
+};
+
+namespace iter {
+  constexpr impl::CycleFn cycle{};
 }
 
 #endif

From dbd4e3682cb8abc9d638d144bb3dc8ef284a4b6b Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 7 Apr 2016 00:44:13 -0700
Subject: [PATCH 1382/1866] Uses IterToolMaker in cycle

---
 cycle.hpp | 20 ++------------------
 1 file changed, 2 insertions(+), 18 deletions(-)

diff --git a/cycle.hpp b/cycle.hpp
index 209b1522..64b3ee84 100644
--- a/cycle.hpp
+++ b/cycle.hpp
@@ -12,8 +12,9 @@ namespace iter {
     template <typename Container>
     class Cycler;
 
-    struct CycleFn;
+    using CycleFn = IterToolFn<Cycler>;
   }
+  constexpr impl::CycleFn cycle{};
 }
 
 template <typename Container>
@@ -81,21 +82,4 @@ class iter::impl::Cycler {
   }
 };
 
-struct iter::impl::CycleFn {
-  template <typename Container>
-  iter::impl::Cycler<Container> operator()(Container&& container) const {
-    return {std::forward<Container>(container)};
-  }
-
-  template <typename T>
-  iter::impl::Cycler<std::initializer_list<T>> operator()(
-      std::initializer_list<T> il) const {
-    return {std::move(il)};
-  }
-};
-
-namespace iter {
-  constexpr impl::CycleFn cycle{};
-}
-
 #endif

From cb033d62c0be3b207b37af11484e8d1c37913aa8 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 7 Apr 2016 00:47:46 -0700
Subject: [PATCH 1383/1866] tests that cycle supports pipe

---
 test/test_cycle.cpp | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/test/test_cycle.cpp b/test/test_cycle.cpp
index ea5bf3e7..8d4ab37c 100644
--- a/test/test_cycle.cpp
+++ b/test/test_cycle.cpp
@@ -25,6 +25,21 @@ TEST_CASE("cycle: iterate twice", "[cycle]") {
   REQUIRE(v == vc);
 }
 
+TEST_CASE("cycle: with pipe", "[cycle]") {
+  std::vector<int> ns{2, 4, 6};
+  std::vector<int> v;
+  std::size_t count = 0;
+  for (auto i : ns | cycle) {
+    v.push_back(i);
+    ++count;
+    if (count == ns.size() * 2) break;
+  }
+
+  auto vc = ns;
+  vc.insert(std::end(vc), std::begin(ns), std::end(ns));
+  REQUIRE(v == vc);
+}
+
 TEST_CASE("cycle: empty cycle terminates", "[cycle]") {
   std::vector<int> ns;
   auto c = cycle(ns);

From 813a8612ad4e3ddec7312cd6819d3b61fc69f6a2 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 7 Apr 2016 19:30:54 -0700
Subject: [PATCH 1384/1866] Tests permutations with pipe

---
 test/test_permutations.cpp | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/test/test_permutations.cpp b/test/test_permutations.cpp
index 68fa24f9..c184e651 100644
--- a/test/test_permutations.cpp
+++ b/test/test_permutations.cpp
@@ -13,11 +13,17 @@ using IntPermSet = std::multiset<std::vector<int>>;
 
 TEST_CASE("permutations: basic test, 3 element sequence", "[permutations]") {
   const std::vector<int> ns = {1, 7, 9};
-  auto p = permutations(ns);
 
   IntPermSet v;
-  for (auto&& st : p) {
-    v.emplace(std::begin(st), std::end(st));
+  SECTION("Normal call") {
+    for (auto&& st : permutations(ns)) {
+      v.emplace(std::begin(st), std::end(st));
+    }
+  }
+  SECTION("Pipe") {
+    for (auto&& st : ns | permutations) {
+      v.emplace(std::begin(st), std::end(st));
+    }
   }
 
   const IntPermSet vc = {

From ba56e6c561ed0859d035189a301c474fa1f4ec70 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 7 Apr 2016 19:31:06 -0700
Subject: [PATCH 1385/1866] Uses PermutationsFn

---
 permutations.hpp | 25 +++----------------------
 1 file changed, 3 insertions(+), 22 deletions(-)

diff --git a/permutations.hpp b/permutations.hpp
index 81fdb34f..dea9fa8c 100644
--- a/permutations.hpp
+++ b/permutations.hpp
@@ -14,28 +14,20 @@ namespace iter {
   namespace impl {
     template <typename Container>
     class Permuter;
+    using PermutationsFn = IterToolFn<Permuter>;
   }
-  template <typename Container>
-  impl::Permuter<Container> permutations(Container&&);
-
-  template <typename T>
-  impl::Permuter<std::initializer_list<T>> permutations(
-      std::initializer_list<T>);
+  constexpr impl::PermutationsFn permutations{};
 }
 
 template <typename Container>
 class iter::impl::Permuter {
  private:
+  friend PermutationsFn;
   Container container;
 
   using IndexVector = std::vector<iterator_type<Container>>;
   using Permutable = IterIterWrapper<IndexVector>;
 
-  friend Permuter iter::permutations<Container>(Container&&);
-  template <typename T>
-  friend Permuter<std::initializer_list<T>> iter::permutations(
-      std::initializer_list<T>);
-
   Permuter(Container&& in_container)
       : container(std::forward<Container>(in_container)) {}
 
@@ -109,15 +101,4 @@ class iter::impl::Permuter {
   }
 };
 
-template <typename Container>
-iter::impl::Permuter<Container> iter::permutations(Container&& container) {
-  return {std::forward<Container>(container)};
-}
-
-template <typename T>
-iter::impl::Permuter<std::initializer_list<T>> iter::permutations(
-    std::initializer_list<T> il) {
-  return {std::move(il)};
-}
-
 #endif

From 99ce7bdff50a7694250023d91010e7c59b9ac02c Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 7 Apr 2016 19:33:49 -0700
Subject: [PATCH 1386/1866] formatting

---
 accumulate.hpp     | 4 +++-
 chain.hpp          | 6 ++++--
 groupby.hpp        | 9 ++++++---
 sliding_window.hpp | 4 +++-
 starmap.hpp        | 4 ++--
 zip.hpp            | 2 +-
 zip_longest.hpp    | 2 +-
 7 files changed, 20 insertions(+), 11 deletions(-)

diff --git a/accumulate.hpp b/accumulate.hpp
index 4ca8d600..800a51e8 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -71,7 +71,9 @@ class iter::impl::Accumulator {
           acc_val{other.acc_val ? new AccumVal(*other.acc_val) : nullptr} {}
 
     Iterator& operator=(const Iterator& other) {
-      if (this == &other) { return *this; }
+      if (this == &other) {
+        return *this;
+      }
       this->sub_iter = other.sub_iter;
       this->sub_end = other.sub_end;
       this->accumulate_func = other.accumulate_func;
diff --git a/chain.hpp b/chain.hpp
index 470ca4e3..0f67cc44 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -113,7 +113,7 @@ class iter::impl::Chained {
       return derefers[this->index](this->iters);
     }
 
-    decltype(auto) operator -> () {
+    decltype(auto) operator-> () {
       return arrowers[this->index](this->iters);
     }
 
@@ -225,7 +225,9 @@ class iter::impl::ChainedFromIterable {
           sub_end_p{clone_sub_pointer(other.sub_end_p.get())} {}
 
     Iterator& operator=(const Iterator& other) {
-      if (this == &other) { return *this; }
+      if (this == &other) {
+        return *this;
+      }
 
       this->top_level_iter = other.top_level_iter;
       this->top_level_end = other.top_level_end;
diff --git a/groupby.hpp b/groupby.hpp
index c551d7a8..6a924d40 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -80,7 +80,9 @@ class iter::impl::GroupProducer {
           key_func{other.key_func} {}
 
     Iterator& operator=(const Iterator& other) {
-      if (this == &other) { return *this; }
+      if (this == &other) {
+        return *this;
+      }
       this->sub_iter = other.sub_iter;
       this->sub_end = other.sub_end;
       this->item = other.item;
@@ -191,8 +193,9 @@ class iter::impl::GroupProducer {
     }
 
     // move-constructible, non-copy-constructible, non-assignable
-    Group(Group&& other) noexcept
-        : owner(other.owner), key{other.key}, completed{other.completed} {
+    Group(Group&& other) noexcept : owner(other.owner),
+                                    key{other.key},
+                                    completed{other.completed} {
       other.completed = true;
     }
 
diff --git a/sliding_window.hpp b/sliding_window.hpp
index 11b633d1..fba92e35 100644
--- a/sliding_window.hpp
+++ b/sliding_window.hpp
@@ -55,7 +55,9 @@ class iter::impl::WindowSlider {
       while (i < window_sz && this->sub_iter != in_end) {
         this->window.get().push_back(this->sub_iter);
         ++i;
-        if (i != window_sz) { ++this->sub_iter; }
+        if (i != window_sz) {
+          ++this->sub_iter;
+        }
       }
     }
 
diff --git a/starmap.hpp b/starmap.hpp
index a64222e5..d76586a9 100644
--- a/starmap.hpp
+++ b/starmap.hpp
@@ -83,7 +83,7 @@ class iter::impl::StarMapper {
       return call_with_tuple(*this->func, *this->sub_iter);
     }
 
-    auto operator -> () -> ArrowProxy<decltype(**this)> {
+    auto operator-> () -> ArrowProxy<decltype(**this)> {
       return {**this};
     }
   };
@@ -142,7 +142,7 @@ class iter::impl::TupleStarMapper {
       return callers[this->index](*this->func, *this->tup);
     }
 
-    auto operator -> () -> ArrowProxy<decltype(**this)> {
+    auto operator-> () -> ArrowProxy<decltype(**this)> {
       return {**this};
     }
 
diff --git a/zip.hpp b/zip.hpp
index 569ea6ee..ede3514e 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -69,7 +69,7 @@ class iter::impl::Zipped {
       return ZipIterDeref{(*std::get<Is>(this->iters))...};
     }
 
-    auto operator -> () -> ArrowProxy<decltype(**this)> {
+    auto operator-> () -> ArrowProxy<decltype(**this)> {
       return {**this};
     }
   };
diff --git a/zip_longest.hpp b/zip_longest.hpp
index 800261b7..ad4cafab 100644
--- a/zip_longest.hpp
+++ b/zip_longest.hpp
@@ -85,7 +85,7 @@ class iter::impl::ZippedLongest {
                   : OptType<Is>{})...};
     }
 
-    auto operator -> () -> ArrowProxy<decltype(**this)> {
+    auto operator-> () -> ArrowProxy<decltype(**this)> {
       return {**this};
     }
   };

From 3daeef8cc28571da873258ab5eb241c82b44d85e Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 7 Apr 2016 19:34:43 -0700
Subject: [PATCH 1387/1866] explicit {} on enumerate init

---
 enumerate.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index b8f58d37..28d17362 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -16,7 +16,7 @@ namespace iter {
 
     using EnumerateFn = IterToolFn<Enumerable>;
   }
-  constexpr impl::EnumerateFn enumerate;
+  constexpr impl::EnumerateFn enumerate{};
 }
 
 template <typename Container>

From 40f8129e740577f1330b20f9d5b45f657347fd3d Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 7 Apr 2016 19:38:30 -0700
Subject: [PATCH 1388/1866] tests powerset with pipe

---
 test/test_powerset.cpp | 17 +++++++++++------
 1 file changed, 11 insertions(+), 6 deletions(-)

diff --git a/test/test_powerset.cpp b/test/test_powerset.cpp
index fae08df8..923baa13 100644
--- a/test/test_powerset.cpp
+++ b/test/test_powerset.cpp
@@ -14,14 +14,19 @@ using IntPermSet = std::multiset<std::multiset<int>>;
 TEST_CASE("powerset: basic test, [1, 2, 3]", "[powerset]") {
   const std::vector<int> ns = {1, 2, 3};
   IntPermSet v;
-  for (auto&& st : powerset(ns)) {
-    v.emplace(std::begin(st), std::end(st));
+  SECTION("Normal call") {
+    for (auto&& st : powerset(ns)) {
+      v.emplace(std::begin(st), std::end(st));
+    }
+  }
+  SECTION("Pipe") {
+    for (auto&& st : ns | powerset) {
+      v.emplace(std::begin(st), std::end(st));
+    }
   }
 
-  const IntPermSet vc = {std::multiset<int>{}, {1}, {2},
-      {
-          3,
-      },
+  const IntPermSet vc = {
+    std::multiset<int>{}, {1}, {2}, {3},
       {1, 2}, {1, 3}, {2, 3}, {1, 2, 3}};
   REQUIRE(v == vc);
 }

From 31508075256680fce9c1a5d49c372bf62847a91b Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 7 Apr 2016 19:38:43 -0700
Subject: [PATCH 1389/1866] Uses PowersetFn

---
 powerset.hpp | 25 ++++---------------------
 1 file changed, 4 insertions(+), 21 deletions(-)

diff --git a/powerset.hpp b/powerset.hpp
index 46f88aae..c0ea0ade 100644
--- a/powerset.hpp
+++ b/powerset.hpp
@@ -15,13 +15,10 @@ namespace iter {
   namespace impl {
     template <typename Container>
     class Powersetter;
-  }
-  template <typename Container>
-  impl::Powersetter<Container> powerset(Container&&);
 
-  template <typename T>
-  impl::Powersetter<std::initializer_list<T>> powerset(
-      std::initializer_list<T>);
+    using PowersetFn = IterToolFn<Powersetter>;
+  }
+  constexpr impl::PowersetFn powerset{};
 }
 
 template <typename Container>
@@ -30,10 +27,7 @@ class iter::impl::Powersetter {
   Container container;
   using CombinatorType = decltype(combinations(std::declval<Container&>(), 0));
 
-  friend Powersetter iter::powerset<Container>(Container&&);
-  template <typename T>
-  friend Powersetter<std::initializer_list<T>> iter::powerset(
-      std::initializer_list<T>);
+  friend PowersetFn;
 
   Powersetter(Container&& in_container)
       : container(std::forward<Container>(in_container)) {}
@@ -105,15 +99,4 @@ class iter::impl::Powersetter {
   }
 };
 
-template <typename Container>
-iter::impl::Powersetter<Container> iter::powerset(Container&& container) {
-  return {std::forward<Container>(container)};
-}
-
-template <typename T>
-iter::impl::Powersetter<std::initializer_list<T>> iter::powerset(
-    std::initializer_list<T> il) {
-  return {std::move(il)};
-}
-
 #endif

From 0db1e55f8fd37c134cf0ae49ad841f3b52554bb7 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 7 Apr 2016 19:44:01 -0700
Subject: [PATCH 1390/1866] tests reversed with pipe

---
 test/test_reversed.cpp | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/test/test_reversed.cpp b/test/test_reversed.cpp
index 79922185..1cd6fcfa 100644
--- a/test/test_reversed.cpp
+++ b/test/test_reversed.cpp
@@ -16,9 +16,16 @@ using Vec = const std::vector<int>;
 
 TEST_CASE("reversed: can reverse a vector", "[reversed]") {
   Vec ns = {10, 20, 30, 40};
-  auto r = reversed(ns);
+  std::vector<int> v;
+  SECTION("Normal call") {
+    auto r = reversed(ns);
+    v.assign(std::begin(r), std::end(r));
+  }
+  SECTION("Pipe") {
+    auto r = ns | reversed;
+    v.assign(std::begin(r), std::end(r));
+  }
 
-  Vec v(std::begin(r), std::end(r));
   Vec vc = {40, 30, 20, 10};
 
   REQUIRE(v == vc);

From cd60e98fccc8973caf5ced428109b90bfbb1227d Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 7 Apr 2016 19:44:52 -0700
Subject: [PATCH 1391/1866] Uses ReversedFn

---
 reversed.hpp | 13 ++++---------
 1 file changed, 4 insertions(+), 9 deletions(-)

diff --git a/reversed.hpp b/reversed.hpp
index 62aad656..82ae9b46 100644
--- a/reversed.hpp
+++ b/reversed.hpp
@@ -10,17 +10,17 @@ namespace iter {
   namespace impl {
     template <typename Container>
     class Reverser;
-  }
 
-  template <typename Container>
-  impl::Reverser<Container> reversed(Container&&);
+    using ReversedFn = IterToolFn<Reverser>;
+  }
+  constexpr impl::ReversedFn reversed{};
 }
 
 template <typename Container>
 class iter::impl::Reverser {
  private:
   Container container;
-  friend Reverser iter::reversed<Container>(Container&&);
+  friend ReversedFn;
 
   Reverser(Container&& in_container)
       : container(std::forward<Container>(in_container)) {}
@@ -83,9 +83,4 @@ class iter::impl::Reverser {
   }
 };
 
-template <typename Container>
-iter::impl::Reverser<Container> iter::reversed(Container&& container) {
-  return {std::forward<Container>(container)};
-}
-
 #endif

From 0f6a4c651ec8b516813d0ae1624a7dc37aabf211 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 8 Apr 2016 09:33:48 -0700
Subject: [PATCH 1392/1866] Adds base pipeable for filter-like tools

---
 internal/iterbase.hpp | 71 +++++++++++++++++++++++++++++--------------
 1 file changed, 49 insertions(+), 22 deletions(-)

diff --git a/internal/iterbase.hpp b/internal/iterbase.hpp
index 7d8acb0d..ef97e70e 100644
--- a/internal/iterbase.hpp
+++ b/internal/iterbase.hpp
@@ -336,28 +336,6 @@ namespace iter {
       }
     };
 
-    // T is whatever is being held for later use
-    template <typename ItTool, typename T>
-    struct FnPartial : Pipeable<FnPartial<ItTool, T>> {
-      ItTool tool_fun;
-      mutable T stored_arg;
-      constexpr FnPartial(ItTool in_tool, T in_t)
-          : tool_fun(in_tool), stored_arg(in_t) {}
-
-      template <typename Container>
-      auto operator()(Container&& container) const {
-        return tool_fun(stored_arg, std::forward<Container>(container));
-      }
-    };
-
-    template <typename ItTool>
-    struct PipeableAndBindFirst : Pipeable<ItTool> {
-      template <typename Func, typename = std::enable_if_t<!is_iterable<Func>>>
-      FnPartial<ItTool, Func> operator()(Func func) const {
-        return {static_cast<const ItTool&>(*this), std::move(func)};
-      }
-    };
-
     // Pipeable Callable generator, where ItImpl is templated on the first
     // argument to the call.
     template <template <typename> class ItImpl>
@@ -373,6 +351,55 @@ namespace iter {
         return {std::move(il), std::move(ts)...};
       }
     };
+
+    // This is a complicated class to generate a callable that can work:
+    //  (1) with just a single (iterable) passed, and DefaultFunc substituted
+    //  (2) with an iterable and a callable
+    //  (3) with just a callable, to have the iterable passed later via pipe
+    template <template <typename, typename> class ItImpl, typename DefaultFunc>
+    struct IterToolFnOptionalBindFirst
+        : Pipeable<IterToolFnOptionalBindFirst<ItImpl, DefaultFunc>> {
+      // T is whatever is being held for later use
+      template <typename T>
+      struct FnPartial : Pipeable<FnPartial<T>> {
+        mutable T stored_arg;
+        constexpr FnPartial(T in_t) : stored_arg(in_t) {}
+
+        template <typename Container>
+        auto operator()(Container&& container) const {
+          return IterToolFnOptionalBindFirst{}(
+              stored_arg, std::forward<Container>(container));
+        }
+      };
+
+      template <typename Func, typename Container>
+      ItImpl<Func, Container> operator()(
+          Func func, Container&& container) const {
+        return {std::move(func), std::forward<Container>(container)};
+      }
+
+      template <typename Func, typename = std::enable_if_t<!is_iterable<Func>>>
+      FnPartial<Func> operator()(Func func) const {
+        return {std::move(func)};
+      }
+
+      template <typename Container,
+          typename = std::enable_if_t<is_iterable<Container>>>
+      auto operator()(Container&& container) const {
+        return (*this)(DefaultFunc{}, std::forward<Container>(container));
+      }
+
+      template <typename Func, typename T>
+      ItImpl<Func, std::initializer_list<T>> operator()(
+          Func func, std::initializer_list<T> il) const {
+        return {std::move(func), std::move(il)};
+      }
+
+      template <typename T>
+      auto operator()(std::initializer_list<T> il) const {
+        return (*this)(DefaultFunc{}, std::move(il));
+      }
+    };
   }
 }
 

From 0c5524925f9cc1b39cbf21a395d215c084ad3e67 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 8 Apr 2016 09:35:07 -0700
Subject: [PATCH 1393/1866] Uses fancy IterToolFn(special) instead of own type

---
 filter.hpp | 56 ++++++++++--------------------------------------------
 1 file changed, 10 insertions(+), 46 deletions(-)

diff --git a/filter.hpp b/filter.hpp
index b2da5994..b62dc7ba 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -12,8 +12,17 @@ namespace iter {
     template <typename FilterFunc, typename Container>
     class Filtered;
 
-    class FilterFn;
+    struct BoolTester {
+      template <typename T>
+      constexpr bool operator()(const T& item) const {
+        return bool(item);
+      }
+    };
+
+    using FilterFn = IterToolFnOptionalBindFirst<Filtered, BoolTester>;
   }
+
+  constexpr impl::FilterFn filter{};
 }
 
 template <typename FilterFunc, typename Container>
@@ -107,49 +116,4 @@ class iter::impl::Filtered {
   }
 };
 
-class iter::impl::FilterFn : public PipeableAndBindFirst<FilterFn> {
- public:
-  template <typename FilterFunc, typename Container>
-  iter::impl::Filtered<FilterFunc, Container> operator()(
-      FilterFunc filter_func, Container&& container) const {
-    return {std::move(filter_func), std::forward<Container>(container)};
-  }
-
-  template <typename FilterFunc, typename T>
-  iter::impl::Filtered<FilterFunc, std::initializer_list<T>> operator()(
-      FilterFunc filter_func, std::initializer_list<T> il) const {
-    return {std::move(filter_func), std::move(il)};
-  }
-
-  template <typename Container,
-      typename = std::enable_if_t<is_iterable<Container>>>
-  auto operator()(Container&& container) const {
-    return (*this)(BoolTester<Container>{}, std::forward<Container>(container));
-  }
-
-  template <typename T>
-  auto operator()(std::initializer_list<T> il) const {
-    return (*this)(BoolTester<std::initializer_list<T>>{}, std::move(il));
-  }
-  using PipeableAndBindFirst<FilterFn>::operator();
-
- private:
-  template <typename T>
-  bool boolean_cast(const T& t) {
-    return bool(t);
-  }
-
-  template <typename Container>
-  class BoolTester {
-   public:
-    bool operator()(const impl::iterator_deref<Container> item) const {
-      return bool(item);
-    }
-  };
-};
-
-namespace iter {
-  constexpr impl::FilterFn filter{};
-}
-
 #endif

From 32a294eab101118c5d698b9ac04621ea64496768 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 8 Apr 2016 09:36:14 -0700
Subject: [PATCH 1394/1866] tests filter with init lists

---
 test/test_filter.cpp | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/test/test_filter.cpp b/test/test_filter.cpp
index 63b8e068..0f887438 100644
--- a/test/test_filter.cpp
+++ b/test/test_filter.cpp
@@ -136,6 +136,15 @@ TEST_CASE("filter: works with pipe", "[filter]") {
   REQUIRE(v == vc);
 }
 
+TEST_CASE("filter: works with initializer_list", "[filter]") {
+  auto f = filter(LessThanValue{5}, {1, 2, 5, 6, 3, 1, 7, -1, 5});
+  Vec v(std::begin(f), std::end(f));
+  Vec vc = {1, 2, 3, 1, -1};
+  REQUIRE(v == vc);
+  auto f2 = filter({1, 2, 5, 6, 3, 1, 7, -1, 5});
+  Vec v2(std::begin(f2), std::end(f2));
+}
+
 TEST_CASE("filter: using identity and pipe", "[filter]") {
   Vec ns{0, 1, 2, 0, 3, 0, 0, 0, 4, 5, 0};
   auto f = ns | filter;

From ec5fc24b32ed680e2057bd285be793dcaaf3327f Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 8 Apr 2016 09:39:02 -0700
Subject: [PATCH 1395/1866] tests sorted(chain.from_iterable(..));

---
 test/test_mixed.cpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/test/test_mixed.cpp b/test/test_mixed.cpp
index b9be62ff..fae47b27 100644
--- a/test/test_mixed.cpp
+++ b/test/test_mixed.cpp
@@ -121,3 +121,8 @@ TEST_CASE("takewhile doesn't dereference multiple times", "[imap][takewhile]") {
   std::vector<int> vs(std::begin(get_vals), std::end(get_vals));
   REQUIRE(vs == vsc);
 }
+
+TEST_CASE("sorted(chain.from_iterable)", "[sorted][chain.from_iterable]") {
+  std::vector<std::vector<int>> v = {{2,4,6}};
+  auto s = iter::sorted(iter::chain.from_iterable(v));
+}

From 8bf40045e4272387a8aac15b9765e47fc113ef6b Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 8 Apr 2016 09:39:23 -0700
Subject: [PATCH 1396/1866] removes consts from sorted, for compatibility

---
 sorted.hpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/sorted.hpp b/sorted.hpp
index 6c1ba2fe..b9a03560 100644
--- a/sorted.hpp
+++ b/sorted.hpp
@@ -42,8 +42,8 @@ class iter::impl::SortedView {
 
     // sort by comparing the elements that the iterators point to
     std::sort(std::begin(sorted_iters.get()), std::end(sorted_iters.get()),
-        [compare_func](const iterator_type<Container>& it1,
-                  const iterator_type<Container>& it2) {
+        [compare_func](iterator_type<Container>& it1,
+                  iterator_type<Container>& it2) {
           return compare_func(*it1, *it2);
         });
   }
@@ -70,7 +70,7 @@ namespace iter {
   template <typename Container>
   auto sorted(Container&& container) {
     return sorted(std::forward<Container>(container),
-        std::less<impl::const_iterator_deref<Container>>());
+        std::less<impl::iterator_deref<Container>>());
   }
 }
 

From 386c2b31016568a33b32559e80082bb07d2a37cc Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 8 Apr 2016 10:16:50 -0700
Subject: [PATCH 1397/1866] Takes iterators by value, uses less<>

---
 sorted.hpp | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/sorted.hpp b/sorted.hpp
index b9a03560..3fc4767d 100644
--- a/sorted.hpp
+++ b/sorted.hpp
@@ -42,8 +42,8 @@ class iter::impl::SortedView {
 
     // sort by comparing the elements that the iterators point to
     std::sort(std::begin(sorted_iters.get()), std::end(sorted_iters.get()),
-        [compare_func](iterator_type<Container>& it1,
-                  iterator_type<Container>& it2) {
+        [compare_func](iterator_type<Container> it1,
+                  iterator_type<Container> it2) {
           return compare_func(*it1, *it2);
         });
   }
@@ -69,8 +69,7 @@ iter::impl::SortedView<Container> iter::sorted(
 namespace iter {
   template <typename Container>
   auto sorted(Container&& container) {
-    return sorted(std::forward<Container>(container),
-        std::less<impl::iterator_deref<Container>>());
+    return sorted(std::forward<Container>(container), std::less<>{});
   }
 }
 

From 4f332bed8cc4cf677e3835976a792b32b72cbc37 Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Fri, 8 Apr 2016 10:43:09 -0700
Subject: [PATCH 1398/1866] Removes this-> in starmap::iterator functions.

clang was getting confused by them, I don't know why.
---
 starmap.hpp | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/starmap.hpp b/starmap.hpp
index a64222e5..58902b3c 100644
--- a/starmap.hpp
+++ b/starmap.hpp
@@ -10,6 +10,8 @@
 #include <cassert>
 #include <memory>
 
+//NOTE I don't know why, but clang gets very confused by having this-> in the
+//Iterators' member functions
 namespace iter {
   namespace impl {
     template <typename Func, typename Container>
@@ -80,7 +82,7 @@ class iter::impl::StarMapper {
     }
 
     decltype(auto) operator*() {
-      return call_with_tuple(*this->func, *this->sub_iter);
+      return call_with_tuple(*func, *sub_iter);
     }
 
     auto operator -> () -> ArrowProxy<decltype(**this)> {
@@ -139,7 +141,7 @@ class iter::impl::TupleStarMapper {
         : func{&f}, tup{&t}, index{i} {}
 
     decltype(auto) operator*() {
-      return callers[this->index](*this->func, *this->tup);
+      return callers[index](*func, *tup);
     }
 
     auto operator -> () -> ArrowProxy<decltype(**this)> {
@@ -147,7 +149,7 @@ class iter::impl::TupleStarMapper {
     }
 
     Iterator& operator++() {
-      ++this->index;
+      ++index;
       return *this;
     }
 
@@ -158,7 +160,7 @@ class iter::impl::TupleStarMapper {
     }
 
     bool operator!=(const Iterator& other) const {
-      return this->index != other.index;
+      return index != other.index;
     }
 
     bool operator==(const Iterator& other) const {

From 9007a26cc3c8ac99de26800d05937dfc5d004cf3 Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Fri, 8 Apr 2016 14:43:53 -0700
Subject: [PATCH 1399/1866] Removes initializer_list tests

---
 test/test_accumulate.cpp | 8 --------
 test/test_enumerate.cpp  | 7 -------
 2 files changed, 15 deletions(-)

diff --git a/test/test_accumulate.cpp b/test/test_accumulate.cpp
index 0d60f927..769717d8 100644
--- a/test/test_accumulate.cpp
+++ b/test/test_accumulate.cpp
@@ -29,14 +29,6 @@ TEST_CASE("accumulate: With subtraction lambda", "[accumulate]") {
   REQUIRE(v == vc);
 }
 
-TEST_CASE("accumulate: with initializer_list works", "[accumulate]") {
-  auto a = accumulate({1, 2, 3});
-  Vec v(std::begin(a), std::end(a));
-  Vec vc{1, 3, 6};
-
-  REQUIRE(v == vc);
-}
-
 struct Integer {
   const int value;
   constexpr Integer(int i) : value{i} {}
diff --git a/test/test_enumerate.cpp b/test/test_enumerate.cpp
index 778cce39..660ac935 100644
--- a/test/test_enumerate.cpp
+++ b/test/test_enumerate.cpp
@@ -87,13 +87,6 @@ TEST_CASE("enumerate with static array works", "[enumerate]") {
   }
 }
 
-TEST_CASE("initializer_list works", "[enumerate]") {
-  auto e = enumerate({'a', 'b', 'c'});
-  Vec v(std::begin(e), std::end(e));
-  Vec vc{{0, 'a'}, {1, 'b'}, {2, 'c'}};
-  REQUIRE(v == vc);
-}
-
 TEST_CASE("binds reference when it should", "[enumerate]") {
   BasicIterable<char> bi{'x', 'y', 'z'};
   auto e = enumerate(bi);

From 251c78ba8d4891b6b68b948dcbfd0a311fb091f4 Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Fri, 8 Apr 2016 14:45:31 -0700
Subject: [PATCH 1400/1866] drops init list support from accumulate

---
 accumulate.hpp | 20 --------------------
 1 file changed, 20 deletions(-)

diff --git a/accumulate.hpp b/accumulate.hpp
index 4ca8d600..116b2e3f 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -5,7 +5,6 @@
 
 #include <utility>
 #include <iterator>
-#include <initializer_list>
 #include <functional>
 #include <type_traits>
 #include <memory>
@@ -20,9 +19,6 @@ namespace iter {
   impl::Accumulator<Container, AccumulateFunc> accumulate(
       Container&&, AccumulateFunc);
 
-  template <typename T, typename AccumulateFunc>
-  impl::Accumulator<std::initializer_list<T>, AccumulateFunc> accumulate(
-      std::initializer_list<T>, AccumulateFunc);
 }
 
 template <typename Container, typename AccumulateFunc>
@@ -34,10 +30,6 @@ class iter::impl::Accumulator {
   friend Accumulator iter::accumulate<Container, AccumulateFunc>(
       Container&&, AccumulateFunc);
 
-  template <typename T, typename AF>
-  friend Accumulator<std::initializer_list<T>, AF> iter::accumulate(
-      std::initializer_list<T>, AF);
-
   using AccumVal = std::remove_reference_t<std::result_of_t<AccumulateFunc(
       iterator_deref<Container>, iterator_deref<Container>)>>;
 
@@ -131,12 +123,6 @@ iter::impl::Accumulator<Container, AccumulateFunc> iter::accumulate(
   return {std::forward<Container>(container), accumulate_func};
 }
 
-template <typename T, typename AccumulateFunc>
-iter::impl::Accumulator<std::initializer_list<T>, AccumulateFunc>
-iter::accumulate(std::initializer_list<T> il, AccumulateFunc accumulate_func) {
-  return {std::move(il), accumulate_func};
-}
-
 namespace iter {
   template <typename Container>
   auto accumulate(Container&& container) -> decltype(accumulate(
@@ -145,12 +131,6 @@ namespace iter {
     return accumulate(std::forward<Container>(container),
         std::plus<std::remove_reference_t<impl::iterator_deref<Container>>>{});
   }
-
-  template <typename T>
-  auto accumulate(std::initializer_list<T> il)
-      -> decltype(accumulate(std::move(il), std::plus<T>{})) {
-    return accumulate(std::move(il), std::plus<T>{});
-  }
 }
 
 #endif

From fff872d50432d5efa3b0a8c32efad7635164de69 Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Fri, 8 Apr 2016 14:45:43 -0700
Subject: [PATCH 1401/1866] removes unused include

---
 chain.hpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/chain.hpp b/chain.hpp
index 66fd0f91..738c2e7e 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -4,7 +4,6 @@
 #include "internal/iterbase.hpp"
 
 #include <array>
-#include <initializer_list>
 #include <iterator>
 #include <memory>
 #include <tuple>

From 082948ffbd62691cf73e8fc89fb802a142a83eba Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Fri, 8 Apr 2016 14:45:52 -0700
Subject: [PATCH 1402/1866] drops init list support from chunked

---
 chunked.hpp | 13 -------------
 1 file changed, 13 deletions(-)

diff --git a/chunked.hpp b/chunked.hpp
index 3ce976f4..f642770b 100644
--- a/chunked.hpp
+++ b/chunked.hpp
@@ -10,7 +10,6 @@
 #include <functional>
 #include <utility>
 #include <iterator>
-#include <initializer_list>
 
 namespace iter {
   namespace impl {
@@ -21,9 +20,6 @@ namespace iter {
   template <typename Container>
   impl::Chunker<Container> chunked(Container&&, std::size_t);
 
-  template <typename T>
-  impl::Chunker<std::initializer_list<T>> chunked(
-      std::initializer_list<T>, std::size_t);
 }
 
 template <typename Container>
@@ -36,9 +32,6 @@ class iter::impl::Chunker {
       : container(std::forward<Container>(c)), chunk_size{sz} {}
 
   friend Chunker iter::chunked<Container>(Container&&, std::size_t);
-  template <typename T>
-  friend Chunker<std::initializer_list<T>> iter::chunked(
-      std::initializer_list<T>, std::size_t);
 
   using IndexVector = std::vector<iterator_type<Container>>;
   using DerefVec = IterIterWrapper<IndexVector>;
@@ -120,10 +113,4 @@ iter::impl::Chunker<Container> iter::chunked(
   return {std::forward<Container>(container), chunk_size};
 }
 
-template <typename T>
-iter::impl::Chunker<std::initializer_list<T>> iter::chunked(
-    std::initializer_list<T> il, std::size_t chunk_size) {
-  return {std::move(il), chunk_size};
-}
-
 #endif

From 8149c54dc8049df293b27b2d27ac8a71d9a158c4 Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Fri, 8 Apr 2016 14:46:03 -0700
Subject: [PATCH 1403/1866] drops init list support from combinations

---
 combinations.hpp | 13 -------------
 1 file changed, 13 deletions(-)

diff --git a/combinations.hpp b/combinations.hpp
index 1605e4be..49424a24 100644
--- a/combinations.hpp
+++ b/combinations.hpp
@@ -7,7 +7,6 @@
 #include <vector>
 #include <type_traits>
 #include <iterator>
-#include <initializer_list>
 
 namespace iter {
   namespace impl {
@@ -18,9 +17,6 @@ namespace iter {
   template <typename Container>
   impl::Combinator<Container> combinations(Container&&, std::size_t);
 
-  template <typename T>
-  impl::Combinator<std::initializer_list<T>> combinations(
-      std::initializer_list<T>, std::size_t);
 }
 
 template <typename Container>
@@ -30,9 +26,6 @@ class iter::impl::Combinator {
   std::size_t length;
 
   friend Combinator iter::combinations<Container>(Container&&, std::size_t);
-  template <typename T>
-  friend Combinator<std::initializer_list<T>> iter::combinations(
-      std::initializer_list<T>, std::size_t);
 
   Combinator(Container&& in_container, std::size_t in_length)
       : container(std::forward<Container>(in_container)), length{in_length} {}
@@ -142,10 +135,4 @@ iter::impl::Combinator<Container> iter::combinations(
   return {std::forward<Container>(container), length};
 }
 
-template <typename T>
-iter::impl::Combinator<std::initializer_list<T>> iter::combinations(
-    std::initializer_list<T> il, std::size_t length) {
-  return {std::move(il), length};
-}
-
 #endif

From 3cdb590ff8bd575ccafe780e1196c24a37cd0ef6 Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Fri, 8 Apr 2016 14:46:14 -0700
Subject: [PATCH 1404/1866] drops init list support from comb_w_repl

---
 combinations_with_replacement.hpp | 15 ---------------
 1 file changed, 15 deletions(-)

diff --git a/combinations_with_replacement.hpp b/combinations_with_replacement.hpp
index f6e75a02..b417d960 100644
--- a/combinations_with_replacement.hpp
+++ b/combinations_with_replacement.hpp
@@ -7,7 +7,6 @@
 #include <iterator>
 #include <vector>
 #include <type_traits>
-#include <initializer_list>
 
 namespace iter {
   namespace impl {
@@ -19,9 +18,6 @@ namespace iter {
   impl::CombinatorWithReplacement<Container> combinations_with_replacement(
       Container&&, std::size_t);
 
-  template <typename T>
-  impl::CombinatorWithReplacement<std::initializer_list<T>>
-      combinations_with_replacement(std::initializer_list<T>, std::size_t);
 }
 
 template <typename Container>
@@ -32,10 +28,6 @@ class iter::impl::CombinatorWithReplacement {
 
   friend CombinatorWithReplacement
   iter::combinations_with_replacement<Container>(Container&&, std::size_t);
-  template <typename T>
-  friend CombinatorWithReplacement<std::initializer_list<T>>
-      iter::combinations_with_replacement(
-          std::initializer_list<T>, std::size_t);
 
   CombinatorWithReplacement(Container&& in_container, std::size_t n)
       : container(std::forward<Container>(in_container)), length{n} {}
@@ -124,11 +116,4 @@ iter::combinations_with_replacement(Container&& container, std::size_t length) {
   return {std::forward<Container>(container), length};
 }
 
-template <typename T>
-iter::impl::CombinatorWithReplacement<std::initializer_list<T>>
-iter::combinations_with_replacement(
-    std::initializer_list<T> il, std::size_t length) {
-  return {std::move(il), length};
-}
-
 #endif

From c32a918c071da5415d41a84e1e35c0a28742a636 Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Fri, 8 Apr 2016 14:48:14 -0700
Subject: [PATCH 1405/1866] drops init list support from compress

---
 compress.hpp | 43 -------------------------------------------
 1 file changed, 43 deletions(-)

diff --git a/compress.hpp b/compress.hpp
index dd92c203..22d8cded 100644
--- a/compress.hpp
+++ b/compress.hpp
@@ -5,7 +5,6 @@
 
 #include <utility>
 #include <iterator>
-#include <initializer_list>
 
 namespace iter {
   namespace impl {
@@ -16,17 +15,6 @@ namespace iter {
   template <typename Container, typename Selector>
   impl::Compressed<Container, Selector> compress(Container&&, Selector&&);
 
-  template <typename T, typename Selector>
-  impl::Compressed<std::initializer_list<T>, Selector> compress(
-      std::initializer_list<T>, Selector&&);
-
-  template <typename Container, typename T>
-  impl::Compressed<Container, std::initializer_list<T>> compress(
-      Container&&, std::initializer_list<T>);
-
-  template <typename T, typename U>
-  impl::Compressed<std::initializer_list<T>, std::initializer_list<U>> compress(
-      std::initializer_list<T>, std::initializer_list<U>);
 }
 
 template <typename Container, typename Selector>
@@ -38,18 +26,6 @@ class iter::impl::Compressed {
   friend Compressed iter::compress<Container, Selector>(
       Container&&, Selector&&);
 
-  template <typename T, typename Sel>
-  friend Compressed<std::initializer_list<T>, Sel> iter::compress(
-      std::initializer_list<T>, Sel&&);
-
-  template <typename Con, typename T>
-  friend Compressed<Con, std::initializer_list<T>> iter::compress(
-      Con&&, std::initializer_list<T>);
-
-  template <typename T, typename U>
-  friend Compressed<std::initializer_list<T>, std::initializer_list<U>>
-      iter::compress(std::initializer_list<T>, std::initializer_list<U>);
-
   // Selector::Iterator type
   using selector_iter_type = decltype(std::begin(selectors));
 
@@ -140,23 +116,4 @@ iter::impl::Compressed<Container, Selector> iter::compress(
       std::forward<Container>(container), std::forward<Selector>(selectors)};
 }
 
-template <typename T, typename Selector>
-iter::impl::Compressed<std::initializer_list<T>, Selector> iter::compress(
-    std::initializer_list<T> data, Selector&& selectors) {
-  return {std::move(data), std::forward<Selector>(selectors)};
-}
-
-template <typename Container, typename T>
-iter::impl::Compressed<Container, std::initializer_list<T>> iter::compress(
-    Container&& container, std::initializer_list<T> selectors) {
-  return {std::forward<Container>(container), std::move(selectors)};
-}
-
-template <typename T, typename U>
-iter::impl::Compressed<std::initializer_list<T>, std::initializer_list<U>>
-iter::compress(
-    std::initializer_list<T> data, std::initializer_list<U> selectors) {
-  return {std::move(data), std::move(selectors)};
-}
-
 #endif

From d0e53fb05fd1300e0cae21ed73e8e756ba8d1c54 Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Fri, 8 Apr 2016 14:48:23 -0700
Subject: [PATCH 1406/1866] drops init list support from cycle

---
 cycle.hpp | 11 -----------
 1 file changed, 11 deletions(-)

diff --git a/cycle.hpp b/cycle.hpp
index ac4f5401..00165d95 100644
--- a/cycle.hpp
+++ b/cycle.hpp
@@ -5,7 +5,6 @@
 
 #include <utility>
 #include <iterator>
-#include <initializer_list>
 
 namespace iter {
   namespace impl {
@@ -16,16 +15,12 @@ namespace iter {
   template <typename Container>
   impl::Cycler<Container> cycle(Container&&);
 
-  template <typename T>
-  impl::Cycler<std::initializer_list<T>> cycle(std::initializer_list<T>);
 }
 
 template <typename Container>
 class iter::impl::Cycler {
  private:
   friend Cycler iter::cycle<Container>(Container&&);
-  template <typename T>
-  friend Cycler<std::initializer_list<T>> iter::cycle(std::initializer_list<T>);
 
   Container container;
 
@@ -92,10 +87,4 @@ iter::impl::Cycler<Container> iter::cycle(Container&& container) {
   return {std::forward<Container>(container)};
 }
 
-template <typename T>
-iter::impl::Cycler<std::initializer_list<T>> iter::cycle(
-    std::initializer_list<T> il) {
-  return {std::move(il)};
-}
-
 #endif

From 66d106f62c05d3d3d6055d0e216802306889f310 Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Fri, 8 Apr 2016 14:48:29 -0700
Subject: [PATCH 1407/1866] drops init list support from dropwhile

---
 dropwhile.hpp | 13 -------------
 1 file changed, 13 deletions(-)

diff --git a/dropwhile.hpp b/dropwhile.hpp
index f7f39e2a..912f80d4 100644
--- a/dropwhile.hpp
+++ b/dropwhile.hpp
@@ -5,7 +5,6 @@
 
 #include <utility>
 #include <iterator>
-#include <initializer_list>
 
 namespace iter {
   namespace impl {
@@ -16,9 +15,6 @@ namespace iter {
   template <typename FilterFunc, typename Container>
   impl::Dropper<FilterFunc, Container> dropwhile(FilterFunc, Container&&);
 
-  template <typename FilterFunc, typename T>
-  impl::Dropper<FilterFunc, std::initializer_list<T>> dropwhile(
-      FilterFunc, std::initializer_list<T>);
 }
 
 template <typename FilterFunc, typename Container>
@@ -30,9 +26,6 @@ class iter::impl::Dropper {
   friend Dropper iter::dropwhile<FilterFunc, Container>(
       FilterFunc, Container&&);
 
-  template <typename FF, typename T>
-  friend Dropper<FF, std::initializer_list<T>> iter::dropwhile(
-      FF, std::initializer_list<T>);
 
   Dropper(FilterFunc in_filter_func, Container&& in_container)
       : container(std::forward<Container>(in_container)),
@@ -121,10 +114,4 @@ iter::impl::Dropper<FilterFunc, Container> iter::dropwhile(
   return {filter_func, std::forward<Container>(container)};
 }
 
-template <typename FilterFunc, typename T>
-iter::impl::Dropper<FilterFunc, std::initializer_list<T>> iter::dropwhile(
-    FilterFunc filter_func, std::initializer_list<T> il) {
-  return {filter_func, std::move(il)};
-}
-
 #endif

From 8d29587471947d039a73dd88e23e6bcf08b93562 Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Fri, 8 Apr 2016 14:49:34 -0700
Subject: [PATCH 1408/1866] drops init list support from enumerate

---
 enumerate.hpp | 13 -------------
 1 file changed, 13 deletions(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index 715eb7b0..c77a925f 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -6,7 +6,6 @@
 #include <utility>
 #include <iterator>
 #include <functional>
-#include <initializer_list>
 #include <type_traits>
 
 namespace iter {
@@ -18,9 +17,6 @@ namespace iter {
   template <typename Container>
   impl::Enumerable<Container> enumerate(Container&&, std::size_t = 0);
 
-  template <typename T>
-  impl::Enumerable<std::initializer_list<T>> enumerate(
-      std::initializer_list<T>, std::size_t = 0);
 }
 
 template <typename Container>
@@ -32,9 +28,6 @@ class iter::impl::Enumerable {
   // The only thing allowed to directly instantiate an Enumerable is
   // the enumerate function
   friend Enumerable iter::enumerate<Container>(Container&&, std::size_t);
-  template <typename T>
-  friend Enumerable<std::initializer_list<T>> iter::enumerate(
-      std::initializer_list<T>, std::size_t);
 
   // for IterYield
   using BasePair = std::pair<std::size_t, iterator_deref<Container>>;
@@ -111,10 +104,4 @@ iter::impl::Enumerable<Container> iter::enumerate(
   return {std::forward<Container>(container), start};
 }
 
-template <typename T>
-iter::impl::Enumerable<std::initializer_list<T>> iter::enumerate(
-    std::initializer_list<T> il, std::size_t start) {
-  return {std::move(il), start};
-}
-
 #endif

From 2e5e372b09bd573c30c764f4a757d7ae39718485 Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Fri, 8 Apr 2016 14:54:49 -0700
Subject: [PATCH 1409/1866] drops init list support from filter

---
 filter.hpp | 23 -----------------------
 1 file changed, 23 deletions(-)

diff --git a/filter.hpp b/filter.hpp
index e899b80b..19c6b600 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -5,7 +5,6 @@
 
 #include <utility>
 #include <iterator>
-#include <initializer_list>
 
 namespace iter {
   namespace impl {
@@ -16,9 +15,6 @@ namespace iter {
   template <typename FilterFunc, typename Container>
   impl::Filtered<FilterFunc, Container> filter(FilterFunc, Container&&);
 
-  template <typename FilterFunc, typename T>
-  impl::Filtered<FilterFunc, std::initializer_list<T>> filter(
-      FilterFunc, std::initializer_list<T>);
 }
 
 template <typename FilterFunc, typename Container>
@@ -30,10 +26,6 @@ class iter::impl::Filtered {
   // The filter function is the only thing allowed to create a Filtered
   friend Filtered iter::filter<FilterFunc, Container>(FilterFunc, Container&&);
 
-  template <typename FF, typename T>
-  friend Filtered<FF, std::initializer_list<T>> iter::filter(
-      FF, std::initializer_list<T>);
-
   // Value constructor for use only in the filter function
   Filtered(FilterFunc in_filter_func, Container&& in_container)
       : container(std::forward<Container>(in_container)),
@@ -123,20 +115,10 @@ iter::impl::Filtered<FilterFunc, Container> iter::filter(
   return {filter_func, std::forward<Container>(container)};
 }
 
-template <typename FilterFunc, typename T>
-iter::impl::Filtered<FilterFunc, std::initializer_list<T>> iter::filter(
-    FilterFunc filter_func, std::initializer_list<T> il) {
-  return {filter_func, std::move(il)};
-}
 
 namespace iter {
   namespace detail {
 
-    template <typename T>
-    bool boolean_cast(const T& t) {
-      return bool(t);
-    }
-
     template <typename Container>
     class BoolTester {
      public:
@@ -152,11 +134,6 @@ namespace iter {
         detail::BoolTester<Container>(), std::forward<Container>(container));
   }
 
-  template <typename T>
-  auto filter(std::initializer_list<T> il) {
-    return filter(
-        detail::BoolTester<std::initializer_list<T>>(), std::move(il));
-  }
 }
 
 #endif

From b40a9c578d9d268bc34e377c5ae4c98c04aa87a5 Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Fri, 8 Apr 2016 14:55:01 -0700
Subject: [PATCH 1410/1866] drops init list support from filterfalse

---
 filterfalse.hpp | 17 -----------------
 1 file changed, 17 deletions(-)

diff --git a/filterfalse.hpp b/filterfalse.hpp
index d31a15bf..69e8b83e 100644
--- a/filterfalse.hpp
+++ b/filterfalse.hpp
@@ -62,23 +62,6 @@ namespace iter {
     return filter(
         detail::BoolFlipper<Container>(), std::forward<Container>(container));
   }
-
-  // specializations for initializer_lists
-  template <typename FilterFunc, typename T>
-  auto filterfalse(FilterFunc filter_func, std::initializer_list<T> container) {
-    return filter(
-        detail::PredicateFlipper<FilterFunc, std::initializer_list<T>>(
-            filter_func),
-        std::move(container));
-  }
-
-  // Single argument version, uses a BoolFlipper to reverse the truthiness
-  // of an object
-  template <typename T>
-  auto filterfalse(std::initializer_list<T> container) {
-    return filter(
-        detail::BoolFlipper<std::initializer_list<T>>(), std::move(container));
-  }
 }
 
 #endif

From 96283799a74006ee53ad0202dee0d3f3706f5ef7 Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Fri, 8 Apr 2016 14:55:10 -0700
Subject: [PATCH 1411/1866] drops init list support from groupby

---
 groupby.hpp | 19 -------------------
 1 file changed, 19 deletions(-)

diff --git a/groupby.hpp b/groupby.hpp
index c551d7a8..434d38c2 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -9,7 +9,6 @@
 #include <memory>
 #include <utility>
 #include <iterator>
-#include <initializer_list>
 
 namespace iter {
   namespace impl {
@@ -18,10 +17,6 @@ namespace iter {
   }
   template <typename Container, typename KeyFunc>
   impl::GroupProducer<Container, KeyFunc> groupby(Container&&, KeyFunc);
-
-  template <typename T, typename KeyFunc>
-  impl::GroupProducer<std::initializer_list<T>, KeyFunc> groupby(
-      std::initializer_list<T>, KeyFunc);
 }
 
 template <typename Container, typename KeyFunc>
@@ -32,10 +27,6 @@ class iter::impl::GroupProducer {
 
   friend GroupProducer iter::groupby<Container, KeyFunc>(Container&&, KeyFunc);
 
-  template <typename T, typename KF>
-  friend GroupProducer<std::initializer_list<T>, KF> iter::groupby(
-      std::initializer_list<T>, KF);
-
   using key_func_ret = std::result_of_t<KeyFunc(iterator_deref<Container>)>;
 
   GroupProducer(Container&& in_container, KeyFunc in_key_func)
@@ -269,11 +260,6 @@ iter::impl::GroupProducer<Container, KeyFunc> iter::groupby(
   return {std::forward<Container>(container), key_func};
 }
 
-template <typename T, typename KeyFunc>
-iter::impl::GroupProducer<std::initializer_list<T>, KeyFunc> iter::groupby(
-    std::initializer_list<T> il, KeyFunc key_func) {
-  return {std::move(il), key_func};
-}
 
 namespace iter {
   namespace detail {
@@ -295,11 +281,6 @@ namespace iter {
         std::forward<Container>(container), detail::ItemReturner<Container>());
   }
 
-  template <typename T>
-  auto groupby(std::initializer_list<T> il) {
-    return groupby(
-        std::move(il), detail::ItemReturner<std::initializer_list<T>>());
-  }
 }
 
 #endif

From 87735aa4dc9835722d2b676cbec9955bd3a05d06 Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Fri, 8 Apr 2016 14:55:52 -0700
Subject: [PATCH 1412/1866] drops init list support from permutations

---
 permutations.hpp | 14 --------------
 1 file changed, 14 deletions(-)

diff --git a/permutations.hpp b/permutations.hpp
index 81fdb34f..fd20c817 100644
--- a/permutations.hpp
+++ b/permutations.hpp
@@ -5,7 +5,6 @@
 #include "internal/iteratoriterator.hpp"
 
 #include <algorithm>
-#include <initializer_list>
 #include <vector>
 #include <utility>
 #include <iterator>
@@ -17,10 +16,6 @@ namespace iter {
   }
   template <typename Container>
   impl::Permuter<Container> permutations(Container&&);
-
-  template <typename T>
-  impl::Permuter<std::initializer_list<T>> permutations(
-      std::initializer_list<T>);
 }
 
 template <typename Container>
@@ -32,9 +27,6 @@ class iter::impl::Permuter {
   using Permutable = IterIterWrapper<IndexVector>;
 
   friend Permuter iter::permutations<Container>(Container&&);
-  template <typename T>
-  friend Permuter<std::initializer_list<T>> iter::permutations(
-      std::initializer_list<T>);
 
   Permuter(Container&& in_container)
       : container(std::forward<Container>(in_container)) {}
@@ -114,10 +106,4 @@ iter::impl::Permuter<Container> iter::permutations(Container&& container) {
   return {std::forward<Container>(container)};
 }
 
-template <typename T>
-iter::impl::Permuter<std::initializer_list<T>> iter::permutations(
-    std::initializer_list<T> il) {
-  return {std::move(il)};
-}
-
 #endif

From 5f8b44498284a4602184baca20e8f2bc71fb95b4 Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Fri, 8 Apr 2016 14:59:32 -0700
Subject: [PATCH 1413/1866] drops init list support from powerset

---
 powerset.hpp | 13 -------------
 1 file changed, 13 deletions(-)

diff --git a/powerset.hpp b/powerset.hpp
index 46f88aae..13f7dae9 100644
--- a/powerset.hpp
+++ b/powerset.hpp
@@ -6,7 +6,6 @@
 
 #include <cassert>
 #include <memory>
-#include <initializer_list>
 #include <utility>
 #include <iterator>
 #include <type_traits>
@@ -19,9 +18,6 @@ namespace iter {
   template <typename Container>
   impl::Powersetter<Container> powerset(Container&&);
 
-  template <typename T>
-  impl::Powersetter<std::initializer_list<T>> powerset(
-      std::initializer_list<T>);
 }
 
 template <typename Container>
@@ -31,9 +27,6 @@ class iter::impl::Powersetter {
   using CombinatorType = decltype(combinations(std::declval<Container&>(), 0));
 
   friend Powersetter iter::powerset<Container>(Container&&);
-  template <typename T>
-  friend Powersetter<std::initializer_list<T>> iter::powerset(
-      std::initializer_list<T>);
 
   Powersetter(Container&& in_container)
       : container(std::forward<Container>(in_container)) {}
@@ -110,10 +103,4 @@ iter::impl::Powersetter<Container> iter::powerset(Container&& container) {
   return {std::forward<Container>(container)};
 }
 
-template <typename T>
-iter::impl::Powersetter<std::initializer_list<T>> iter::powerset(
-    std::initializer_list<T> il) {
-  return {std::move(il)};
-}
-
 #endif

From 009930d8ced52070b1afedd283ce1b273ff9fe09 Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Fri, 8 Apr 2016 14:59:52 -0700
Subject: [PATCH 1414/1866] drops init list support from slice

---
 slice.hpp | 23 -----------------------
 1 file changed, 23 deletions(-)

diff --git a/slice.hpp b/slice.hpp
index 09cdfb24..53558c67 100644
--- a/slice.hpp
+++ b/slice.hpp
@@ -5,7 +5,6 @@
 
 #include <iterator>
 #include <type_traits>
-#include <initializer_list>
 
 namespace iter {
   namespace impl {
@@ -20,15 +19,6 @@ namespace iter {
   template <typename Container, typename DifferenceType>
   impl::Sliced<Container, DifferenceType> slice(
       Container&& container, DifferenceType stop);
-
-  template <typename T, typename DifferenceType>
-  impl::Sliced<std::initializer_list<T>, DifferenceType> slice(
-      std::initializer_list<T> il, DifferenceType start, DifferenceType stop,
-      DifferenceType step = 1);
-
-  template <typename T, typename DifferenceType>
-  impl::Sliced<std::initializer_list<T>, DifferenceType> slice(
-      std::initializer_list<T> il, DifferenceType stop);
 }
 
 template <typename Container, typename DifferenceType>
@@ -131,17 +121,4 @@ iter::impl::Sliced<Container, DifferenceType> iter::slice(
   return {std::forward<Container>(container), 0, stop, 1};
 }
 
-template <typename T, typename DifferenceType>
-iter::impl::Sliced<std::initializer_list<T>, DifferenceType> iter::slice(
-    std::initializer_list<T> il, DifferenceType start, DifferenceType stop,
-    DifferenceType step) {
-  return {std::move(il), start, stop, step};
-}
-
-template <typename T, typename DifferenceType>
-iter::impl::Sliced<std::initializer_list<T>, DifferenceType> iter::slice(
-    std::initializer_list<T> il, DifferenceType stop) {
-  return {std::move(il), 0, stop, 1};
-}
-
 #endif

From 3c2e6ad52f667645e3b83bffe289a5d2f7371732 Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Fri, 8 Apr 2016 15:01:51 -0700
Subject: [PATCH 1415/1866] drops init list support from takewhile

---
 takewhile.hpp | 14 --------------
 1 file changed, 14 deletions(-)

diff --git a/takewhile.hpp b/takewhile.hpp
index 6defbb17..6b524c79 100644
--- a/takewhile.hpp
+++ b/takewhile.hpp
@@ -5,7 +5,6 @@
 
 #include <utility>
 #include <iterator>
-#include <initializer_list>
 
 namespace iter {
   namespace impl {
@@ -16,9 +15,6 @@ namespace iter {
   template <typename FilterFunc, typename Container>
   impl::Taker<FilterFunc, Container> takewhile(FilterFunc, Container&&);
 
-  template <typename FilterFunc, typename T>
-  impl::Taker<FilterFunc, std::initializer_list<T>> takewhile(
-      FilterFunc, std::initializer_list<T>);
 }
 
 template <typename FilterFunc, typename Container>
@@ -29,10 +25,6 @@ class iter::impl::Taker {
 
   friend Taker iter::takewhile<FilterFunc, Container>(FilterFunc, Container&&);
 
-  template <typename FF, typename T>
-  friend Taker<FF, std::initializer_list<T>> iter::takewhile(
-      FF, std::initializer_list<T>);
-
   Taker(FilterFunc in_filter_func, Container&& in_container)
       : container(std::forward<Container>(in_container)),
         filter_func(in_filter_func) {}
@@ -121,10 +113,4 @@ iter::impl::Taker<FilterFunc, Container> iter::takewhile(
   return {filter_func, std::forward<Container>(container)};
 }
 
-template <typename FilterFunc, typename T>
-iter::impl::Taker<FilterFunc, std::initializer_list<T>> iter::takewhile(
-    FilterFunc filter_func, std::initializer_list<T> il) {
-  return {filter_func, std::move(il)};
-}
-
 #endif

From 1497c4200e6d32a31c7daa6b64be033fca8d4e83 Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Fri, 8 Apr 2016 15:02:03 -0700
Subject: [PATCH 1416/1866] drops init list support from sliding_window

---
 sliding_window.hpp | 12 ------------
 1 file changed, 12 deletions(-)

diff --git a/sliding_window.hpp b/sliding_window.hpp
index 11b633d1..0b3c513a 100644
--- a/sliding_window.hpp
+++ b/sliding_window.hpp
@@ -17,9 +17,6 @@ namespace iter {
   template <typename Container>
   impl::WindowSlider<Container> sliding_window(Container&&, std::size_t);
 
-  template <typename T>
-  impl::WindowSlider<std::initializer_list<T>> sliding_window(
-      std::initializer_list<T>, std::size_t);
 }
 
 template <typename Container>
@@ -30,9 +27,6 @@ class iter::impl::WindowSlider {
 
   friend WindowSlider iter::sliding_window<Container>(Container&&, std::size_t);
 
-  template <typename T>
-  friend WindowSlider<std::initializer_list<T>> iter::sliding_window(
-      std::initializer_list<T>, std::size_t);
 
   WindowSlider(Container&& in_container, std::size_t win_sz)
       : container(std::forward<Container>(in_container)), window_size{win_sz} {}
@@ -107,10 +101,4 @@ iter::impl::WindowSlider<Container> iter::sliding_window(
   return {std::forward<Container>(container), window_size};
 }
 
-template <typename T>
-iter::impl::WindowSlider<std::initializer_list<T>> iter::sliding_window(
-    std::initializer_list<T> il, std::size_t window_size) {
-  return {std::move(il), window_size};
-}
-
 #endif

From 6c033599d82c5d7b42eb4445972fa9a0a6e129fd Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Fri, 8 Apr 2016 15:02:08 -0700
Subject: [PATCH 1417/1866] drops init list support from unique_everseen

---
 unique_everseen.hpp | 8 --------
 1 file changed, 8 deletions(-)

diff --git a/unique_everseen.hpp b/unique_everseen.hpp
index 6fc91f22..043c5e8f 100644
--- a/unique_everseen.hpp
+++ b/unique_everseen.hpp
@@ -20,14 +20,6 @@ namespace iter {
     };
     return filter(func, std::forward<Container>(container));
   }
-
-  template <typename T>
-  auto unique_everseen(std::initializer_list<T> il) {
-    auto func = [elem_seen = std::unordered_set<T>()](const T& e) mutable {
-      return elem_seen.insert(e).second;
-    };
-    return filter(func, il);
-  }
 }
 
 #endif

From 7d6821df04af066eb4d345bef732f2509433f7e2 Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Fri, 8 Apr 2016 15:02:25 -0700
Subject: [PATCH 1418/1866] drops init list support from unique_justseen

---
 unique_justseen.hpp | 10 ----------
 1 file changed, 10 deletions(-)

diff --git a/unique_justseen.hpp b/unique_justseen.hpp
index 4b374e30..6b3963f0 100644
--- a/unique_justseen.hpp
+++ b/unique_justseen.hpp
@@ -6,7 +6,6 @@
 
 #include <utility>
 #include <iterator>
-#include <initializer_list>
 
 namespace iter {
 
@@ -17,15 +16,6 @@ namespace iter {
       return *std::begin(group.second);
     }, groupby(std::forward<Container>(container)));
   }
-
-  template <typename T>
-  auto unique_justseen(std::initializer_list<T> il) {
-    return imap(
-        [](auto&& group) -> impl::iterator_deref<std::initializer_list<T>> {
-          return *std::begin(group.second);
-        },
-        groupby(il));
-  }
 }
 
 #endif

From 820f1bde51dacc63365ac6b1655d28b40f06c416 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 8 Apr 2016 20:57:49 -0700
Subject: [PATCH 1419/1866] drop support for init list

---
 internal/iterbase.hpp | 17 -----------------
 1 file changed, 17 deletions(-)

diff --git a/internal/iterbase.hpp b/internal/iterbase.hpp
index ef97e70e..9875f6bf 100644
--- a/internal/iterbase.hpp
+++ b/internal/iterbase.hpp
@@ -344,12 +344,6 @@ namespace iter {
       ItImpl<T> operator()(T&& t, Ts... ts) const {
         return {std::forward<T>(t), std::move(ts)...};
       }
-
-      template <typename T, typename... Ts>
-      ItImpl<std::initializer_list<T>> operator()(
-          std::initializer_list<T> il, Ts... ts) const {
-        return {std::move(il), std::move(ts)...};
-      }
     };
 
     // This is a complicated class to generate a callable that can work:
@@ -388,17 +382,6 @@ namespace iter {
       auto operator()(Container&& container) const {
         return (*this)(DefaultFunc{}, std::forward<Container>(container));
       }
-
-      template <typename Func, typename T>
-      ItImpl<Func, std::initializer_list<T>> operator()(
-          Func func, std::initializer_list<T> il) const {
-        return {std::move(func), std::move(il)};
-      }
-
-      template <typename T>
-      auto operator()(std::initializer_list<T> il) const {
-        return (*this)(DefaultFunc{}, std::move(il));
-      }
     };
   }
 }

From a54f6f99a8be4d8fb8dffecb2ed56a52dcf6dfaa Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 8 Apr 2016 20:58:35 -0700
Subject: [PATCH 1420/1866] removes filter init list test

---
 test/test_filter.cpp | 9 ---------
 1 file changed, 9 deletions(-)

diff --git a/test/test_filter.cpp b/test/test_filter.cpp
index 0f887438..63b8e068 100644
--- a/test/test_filter.cpp
+++ b/test/test_filter.cpp
@@ -136,15 +136,6 @@ TEST_CASE("filter: works with pipe", "[filter]") {
   REQUIRE(v == vc);
 }
 
-TEST_CASE("filter: works with initializer_list", "[filter]") {
-  auto f = filter(LessThanValue{5}, {1, 2, 5, 6, 3, 1, 7, -1, 5});
-  Vec v(std::begin(f), std::end(f));
-  Vec vc = {1, 2, 3, 1, -1};
-  REQUIRE(v == vc);
-  auto f2 = filter({1, 2, 5, 6, 3, 1, 7, -1, 5});
-  Vec v2(std::begin(f2), std::end(f2));
-}
-
 TEST_CASE("filter: using identity and pipe", "[filter]") {
   Vec ns{0, 1, 2, 0, 3, 0, 0, 0, 4, 5, 0};
   auto f = ns | filter;

From c8d20f1bab033652f12bf7f7b8dab06ba288d40d Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 8 Apr 2016 21:45:45 -0700
Subject: [PATCH 1421/1866] Tests filterfalse with pipe

---
 test/test_filterfalse.cpp | 23 +++++++++++++++++++----
 1 file changed, 19 insertions(+), 4 deletions(-)

diff --git a/test/test_filterfalse.cpp b/test/test_filterfalse.cpp
index 2116b30f..b9de4bd2 100644
--- a/test/test_filterfalse.cpp
+++ b/test/test_filterfalse.cpp
@@ -40,8 +40,15 @@ TEST_CASE("filterfalse: handles different functor types", "[filterfalse]") {
   }
 
   SECTION("with callable object") {
-    auto f = filterfalse(LessThanValue{5}, ns);
-    Vec v(std::begin(f), std::end(f));
+    std::vector<int> v;
+    SECTION("Normal call") {
+      auto f = filterfalse(LessThanValue{5}, ns);
+      v.assign(std::begin(f), std::end(f));
+    }
+    SECTION("Pipe") {
+      auto f = ns | filterfalse(LessThanValue{5});
+      v.assign(std::begin(f), std::end(f));
+    }
     REQUIRE(v == vc);
   }
 
@@ -55,8 +62,16 @@ TEST_CASE("filterfalse: handles different functor types", "[filterfalse]") {
 
 TEST_CASE("filterfalse: using identity", "[filterfalse]") {
   Vec ns{0, 1, 2, 0, 3, 0, 0, 0, 4, 5, 0};
-  auto f = filterfalse(ns);
-  Vec v(std::begin(f), std::end(f));
+  std::vector<int> v;
+  SECTION("Normal call") {
+    auto f = filterfalse(ns);
+    v.assign(std::begin(f), std::end(f));
+  }
+
+  SECTION("Pipe") {
+    auto f = ns | filterfalse;
+    v.assign(std::begin(f), std::end(f));
+  }
 
   Vec vc = {0, 0, 0, 0, 0, 0};
   REQUIRE(v == vc);

From 000b51d45bc74d5d2ba184d44f8e6598de71aaaf Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 8 Apr 2016 21:46:19 -0700
Subject: [PATCH 1422/1866] marks Filter ctor protected

---
 filter.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/filter.hpp b/filter.hpp
index b62dc7ba..f7364f3a 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -33,6 +33,7 @@ class iter::impl::Filtered {
 
   friend FilterFn;
 
+ protected:
   // Value constructor for use only in the filter function
   Filtered(FilterFunc in_filter_func, Container&& in_container)
       : container(std::forward<Container>(in_container)),

From d0f32c42a88ec939b5b51f8e3b532514043cdadd Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 8 Apr 2016 21:46:31 -0700
Subject: [PATCH 1423/1866] Refactors falterfalse to work as piping-IterToolFn

---
 filterfalse.hpp | 56 +++++++++++++++++++------------------------------
 1 file changed, 21 insertions(+), 35 deletions(-)

diff --git a/filterfalse.hpp b/filterfalse.hpp
index 69e8b83e..513962f7 100644
--- a/filterfalse.hpp
+++ b/filterfalse.hpp
@@ -7,61 +7,47 @@
 #include <utility>
 
 namespace iter {
-
-  namespace detail {
-
+  namespace impl {
     // Callable object that reverses the boolean result of another
     // callable, taking the object in a Container's iterator
-    template <typename FilterFunc, typename Container>
+    template <typename FilterFunc>
     class PredicateFlipper {
      private:
       FilterFunc filter_func;
 
      public:
       PredicateFlipper(FilterFunc in_filter_func)
-          : filter_func(in_filter_func) {}
-
-      PredicateFlipper() = delete;
-      PredicateFlipper(const PredicateFlipper&) = default;
+          : filter_func(std::move(in_filter_func)) {}
 
       // Calls the filter_func
-      bool operator()(const iter::impl::iterator_deref<Container> item) const {
+      template <typename T>
+      bool operator()(const T& item) const {
         return !bool(filter_func(item));
       }
 
       // with non-const incase FilterFunc::operator() is non-const
-      bool operator()(const iter::impl::iterator_deref<Container> item) {
+      template <typename T>
+      bool operator()(const T& item) {
         return !bool(filter_func(item));
       }
     };
 
-    // Reverses the bool() conversion result of anything that supports a
-    // bool conversion
-    template <typename Container>
-    class BoolFlipper {
-     public:
-      bool operator()(const iter::impl::iterator_deref<Container> item) const {
-        return !bool(item);
-      }
-    };
-  }
-
-  // Creates a PredicateFlipper for the predicate function, which reverses
-  // the bool result of the function.  The PredicateFlipper is then passed
-  // to the normal filter() function
-  template <typename FilterFunc, typename Container>
-  auto filterfalse(FilterFunc filter_func, Container&& container) {
-    return filter(detail::PredicateFlipper<FilterFunc, Container>(filter_func),
-        std::forward<Container>(container));
-  }
+    template <typename FilterFunc, typename Container>
+    class FilterFalsed;
 
-  // Single argument version, uses a BoolFlipper to reverse the truthiness
-  // of an object
-  template <typename Container>
-  auto filterfalse(Container&& container) {
-    return filter(
-        detail::BoolFlipper<Container>(), std::forward<Container>(container));
+    using FilterFalseFn = IterToolFnOptionalBindFirst<FilterFalsed, BoolTester>;
   }
+  constexpr impl::FilterFalseFn filterfalse{};
 }
 
+// Delegates to Filtered with PredicateFlipper<FilterFunc>
+template <typename FilterFunc, typename Container>
+class iter::impl::FilterFalsed
+    : public Filtered<PredicateFlipper<FilterFunc>, Container> {
+  friend FilterFalseFn;
+  FilterFalsed(FilterFunc in_filter_func, Container&& in_container)
+      : Filtered<PredicateFlipper<FilterFunc>, Container>(
+            {in_filter_func}, std::forward<Container>(in_container)) {}
+};
+
 #endif

From fe5e821c833b1c6c73f4235ac8b511c552d01887 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 8 Apr 2016 22:09:12 -0700
Subject: [PATCH 1424/1866] Adds pipe and identity dropwhile tests.

It seems like a dropwhile with identity (drop all true elements at
front) would be useless, but who am I to judge..?
---
 test/test_dropwhile.cpp | 19 +++++++++++++++++--
 1 file changed, 17 insertions(+), 2 deletions(-)

diff --git a/test/test_dropwhile.cpp b/test/test_dropwhile.cpp
index a05e1048..599ab407 100644
--- a/test/test_dropwhile.cpp
+++ b/test/test_dropwhile.cpp
@@ -14,8 +14,15 @@ using Vec = const std::vector<int>;
 
 TEST_CASE("dropwhile: skips initial elements", "[dropwhile]") {
   Vec ns{1, 2, 3, 4, 5, 6, 7, 8};
-  auto d = dropwhile([](int i) { return i < 5; }, ns);
-  Vec v(std::begin(d), std::end(d));
+  std::vector<int> v;
+  SECTION("Normal call") {
+    auto d = dropwhile([](int i) { return i < 5; }, ns);
+    v.assign(std::begin(d), std::end(d));
+  }
+  SECTION("Pipe") {
+    auto d = ns | dropwhile([](int i) { return i < 5; });
+    v.assign(std::begin(d), std::end(d));
+  }
   Vec vc = {5, 6, 7, 8};
   REQUIRE(v == vc);
 }
@@ -35,6 +42,14 @@ TEST_CASE("dropwhile: skips all elements when all are true under predicate",
   REQUIRE(std::begin(d) == std::end(d));
 }
 
+TEST_CASE("dropwhile: identity", "[dropwhile]") {
+  Vec ns {1, 2, 0, 3, 1, 0};
+  auto d = dropwhile(ns);
+  Vec v(std::begin(d), std::end(d));
+  Vec vc = {0, 3, 1, 0};
+  REQUIRE(v == vc);
+}
+
 TEST_CASE("dropwhile: empty case is empty", "[dropwhile]") {
   Vec ns{};
   auto d = dropwhile([](int i) { return i != 0; }, ns);

From a34b9a1bd03820b4768702d2ae06268058bc9ff8 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 8 Apr 2016 22:09:44 -0700
Subject: [PATCH 1425/1866] Uses DropWhileFn

---
 dropwhile.hpp | 18 +++++-------------
 1 file changed, 5 insertions(+), 13 deletions(-)

diff --git a/dropwhile.hpp b/dropwhile.hpp
index 912f80d4..869e0070 100644
--- a/dropwhile.hpp
+++ b/dropwhile.hpp
@@ -2,6 +2,7 @@
 #define ITER_DROPWHILE_H_
 
 #include "internal/iterbase.hpp"
+#include "filter.hpp"
 
 #include <utility>
 #include <iterator>
@@ -10,11 +11,10 @@ namespace iter {
   namespace impl {
     template <typename FilterFunc, typename Container>
     class Dropper;
-  }
-
-  template <typename FilterFunc, typename Container>
-  impl::Dropper<FilterFunc, Container> dropwhile(FilterFunc, Container&&);
 
+    using DropWhileFn = IterToolFnOptionalBindFirst<Dropper, BoolTester>;
+  }
+  constexpr impl::DropWhileFn dropwhile{};
 }
 
 template <typename FilterFunc, typename Container>
@@ -23,9 +23,7 @@ class iter::impl::Dropper {
   Container container;
   FilterFunc filter_func;
 
-  friend Dropper iter::dropwhile<FilterFunc, Container>(
-      FilterFunc, Container&&);
-
+  friend DropWhileFn;
 
   Dropper(FilterFunc in_filter_func, Container&& in_container)
       : container(std::forward<Container>(in_container)),
@@ -108,10 +106,4 @@ class iter::impl::Dropper {
   }
 };
 
-template <typename FilterFunc, typename Container>
-iter::impl::Dropper<FilterFunc, Container> iter::dropwhile(
-    FilterFunc filter_func, Container&& container) {
-  return {filter_func, std::forward<Container>(container)};
-}
-
 #endif

From e2ffeb84bfeccee0946794730b7ddce62d4da953 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 8 Apr 2016 22:20:56 -0700
Subject: [PATCH 1426/1866] tests takewhile with identity and pipe

---
 test/test_takewhile.cpp | 28 ++++++++++++++++++++++++++--
 1 file changed, 26 insertions(+), 2 deletions(-)

diff --git a/test/test_takewhile.cpp b/test/test_takewhile.cpp
index de3ecb60..af5f6091 100644
--- a/test/test_takewhile.cpp
+++ b/test/test_takewhile.cpp
@@ -34,8 +34,17 @@ TEST_CASE("takewhile: works with lambda, callable, and function pointer",
   }
 
   SECTION("callable object") {
-    auto tw = takewhile(UnderTen{}, ns);
-    Vec v(std::begin(tw), std::end(tw));
+    std::vector<int> v;
+    SECTION("Normal call") {
+      auto tw = takewhile(UnderTen{}, ns);
+      v.assign(std::begin(tw), std::end(tw));
+    }
+
+    SECTION("Pipe") {
+      auto tw = ns | takewhile(UnderTen{});
+      v.assign(std::begin(tw), std::end(tw));
+    }
+
     Vec vc = {1, 3, 5};
     REQUIRE(v == vc);
   }
@@ -48,6 +57,21 @@ TEST_CASE("takewhile: works with lambda, callable, and function pointer",
   }
 }
 
+TEST_CASE("takewhile: identity", "[takewhile]") {
+  Vec ns{1, 2, 3, 0, 4, 5, 0};
+  std::vector<int> v;
+  SECTION("Normal call") {
+    auto tw = takewhile(ns);
+    v.assign(std::begin(tw), std::end(tw));
+  }
+  SECTION("Pipe") {
+    auto tw = ns | takewhile;
+    v.assign(std::begin(tw), std::end(tw));
+  }
+  Vec vc = {1,2,3};
+  REQUIRE(v == vc);
+}
+
 TEST_CASE("takewhile: everything passes predicate", "[takewhile]") {
   Vec ns{1, 2, 3};
   auto tw = takewhile(under_ten, ns);

From a9c9b6bca9401e919837ce0f1a0b866c952f30a6 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 8 Apr 2016 22:21:20 -0700
Subject: [PATCH 1427/1866] Uses TakeWhileFn

---
 takewhile.hpp | 16 +++++-----------
 1 file changed, 5 insertions(+), 11 deletions(-)

diff --git a/takewhile.hpp b/takewhile.hpp
index 6b524c79..003e38a0 100644
--- a/takewhile.hpp
+++ b/takewhile.hpp
@@ -2,6 +2,7 @@
 #define ITER_TAKEWHILE_H_
 
 #include "internal/iterbase.hpp"
+#include "filter.hpp"
 
 #include <utility>
 #include <iterator>
@@ -10,11 +11,10 @@ namespace iter {
   namespace impl {
     template <typename FilterFunc, typename Container>
     class Taker;
-  }
-
-  template <typename FilterFunc, typename Container>
-  impl::Taker<FilterFunc, Container> takewhile(FilterFunc, Container&&);
 
+    using TakeWhileFn = IterToolFnOptionalBindFirst<Taker, BoolTester>;
+  }
+  constexpr impl::TakeWhileFn takewhile{};
 }
 
 template <typename FilterFunc, typename Container>
@@ -23,7 +23,7 @@ class iter::impl::Taker {
   Container container;
   FilterFunc filter_func;
 
-  friend Taker iter::takewhile<FilterFunc, Container>(FilterFunc, Container&&);
+  friend TakeWhileFn;
 
   Taker(FilterFunc in_filter_func, Container&& in_container)
       : container(std::forward<Container>(in_container)),
@@ -107,10 +107,4 @@ class iter::impl::Taker {
   }
 };
 
-template <typename FilterFunc, typename Container>
-iter::impl::Taker<FilterFunc, Container> iter::takewhile(
-    FilterFunc filter_func, Container&& container) {
-  return {filter_func, std::forward<Container>(container)};
-}
-
 #endif

From 2f355b30ffd7eceaf28a0ae81dc317e2f6b92bed Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 9 Apr 2016 15:40:06 -0700
Subject: [PATCH 1428/1866] Adds pipe helper template for opt 2nd callable arg

---
 internal/iterbase.hpp | 38 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/internal/iterbase.hpp b/internal/iterbase.hpp
index 9875f6bf..ac96b2d6 100644
--- a/internal/iterbase.hpp
+++ b/internal/iterbase.hpp
@@ -353,6 +353,7 @@ namespace iter {
     template <template <typename, typename> class ItImpl, typename DefaultFunc>
     struct IterToolFnOptionalBindFirst
         : Pipeable<IterToolFnOptionalBindFirst<ItImpl, DefaultFunc>> {
+     private:
       // T is whatever is being held for later use
       template <typename T>
       struct FnPartial : Pipeable<FnPartial<T>> {
@@ -366,6 +367,7 @@ namespace iter {
         }
       };
 
+     public:
       template <typename Func, typename Container>
       ItImpl<Func, Container> operator()(
           Func func, Container&& container) const {
@@ -383,6 +385,42 @@ namespace iter {
         return (*this)(DefaultFunc{}, std::forward<Container>(container));
       }
     };
+
+    template <template <typename, typename> class ItImpl, typename DefaultFunc>
+    struct IterToolFnOptionalBindSecond
+        : Pipeable<IterToolFnOptionalBindSecond<ItImpl, DefaultFunc>> {
+     private:
+      // T is whatever is being held for later use
+      template <typename T>
+      struct FnPartial : Pipeable<FnPartial<T>> {
+        mutable T stored_arg;
+        constexpr FnPartial(T in_t) : stored_arg(in_t) {}
+
+        template <typename Container>
+        auto operator()(Container&& container) const {
+          return IterToolFnOptionalBindSecond{}(
+              std::forward<Container>(container), stored_arg);
+        }
+      };
+
+     public:
+      template <typename Container, typename Func>
+      ItImpl<Container, Func> operator()(
+          Container&& container, Func func) const {
+        return {std::forward<Container>(container), std::move(func)};
+      }
+
+      template <typename Func, typename = std::enable_if_t<!is_iterable<Func>>>
+      FnPartial<Func> operator()(Func func) const {
+        return {std::move(func)};
+      }
+
+      template <typename Container,
+          typename = std::enable_if_t<is_iterable<Container>>>
+      auto operator()(Container&& container) const {
+        return (*this)(std::forward<Container>(container), DefaultFunc{});
+      }
+    };
   }
 }
 

From b53b9d1510136cc005f82d2d033c91621a86fb8e Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 9 Apr 2016 15:40:29 -0700
Subject: [PATCH 1429/1866] tests accumulate with pipe

---
 test/test_accumulate.cpp | 24 ++++++++++++++++++++----
 1 file changed, 20 insertions(+), 4 deletions(-)

diff --git a/test/test_accumulate.cpp b/test/test_accumulate.cpp
index 769717d8..7df80628 100644
--- a/test/test_accumulate.cpp
+++ b/test/test_accumulate.cpp
@@ -13,18 +13,34 @@ using itertest::BasicIterable;
 using Vec = const std::vector<int>;
 TEST_CASE("Simple sum", "[accumulate]") {
   Vec ns{1, 2, 3, 4, 5};
-  auto a = accumulate(ns);
 
-  Vec v(std::begin(a), std::end(a));
+  std::vector<int> v;
+  SECTION("Normal call") {
+    auto a = accumulate(ns);
+    v.assign(std::begin(a), std::end(a));
+  }
+  SECTION("Pipe") {
+    auto a = ns | accumulate;
+    v.assign(std::begin(a), std::end(a));
+  }
+
   Vec vc{1, 3, 6, 10, 15};
   REQUIRE(v == vc);
 }
 
 TEST_CASE("accumulate: With subtraction lambda", "[accumulate]") {
   Vec ns{5, 4, 3, 2, 1};
-  auto a = accumulate(ns, [](int a, int b) { return a - b; });
+  std::vector<int> v;
+
+  SECTION("Normal call") {
+    auto a = accumulate(ns, [](int a, int b) { return a - b; });
+    v.assign(std::begin(a), std::end(a));
+  }
+  SECTION("Pipe") {
+    auto a = ns | accumulate([](int a, int b) { return a - b; });
+    v.assign(std::begin(a), std::end(a));
+  }
 
-  Vec v(std::begin(a), std::end(a));
   Vec vc{5, 1, -2, -4, -5};
   REQUIRE(v == vc);
 }

From 4eea0c0b666d3a3ecc55abfb14c4eec9bbade82e Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 9 Apr 2016 15:40:44 -0700
Subject: [PATCH 1430/1866] Uses accumulate Fn

---
 accumulate.hpp | 27 ++++-----------------------
 1 file changed, 4 insertions(+), 23 deletions(-)

diff --git a/accumulate.hpp b/accumulate.hpp
index f16c377e..3df0fd29 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -13,12 +13,10 @@ namespace iter {
   namespace impl {
     template <typename Container, typename AccumulateFunc>
     class Accumulator;
-  }
-
-  template <typename Container, typename AccumulateFunc>
-  impl::Accumulator<Container, AccumulateFunc> accumulate(
-      Container&&, AccumulateFunc);
 
+    using AccumulateFn = IterToolFnOptionalBindSecond<Accumulator, std::plus<>>;
+  }
+  constexpr impl::AccumulateFn accumulate{};
 }
 
 template <typename Container, typename AccumulateFunc>
@@ -27,8 +25,7 @@ class iter::impl::Accumulator {
   Container container;
   AccumulateFunc accumulate_func;
 
-  friend Accumulator iter::accumulate<Container, AccumulateFunc>(
-      Container&&, AccumulateFunc);
+  friend AccumulateFn;
 
   using AccumVal = std::remove_reference_t<std::result_of_t<AccumulateFunc(
       iterator_deref<Container>, iterator_deref<Container>)>>;
@@ -119,20 +116,4 @@ class iter::impl::Accumulator {
   }
 };
 
-template <typename Container, typename AccumulateFunc>
-iter::impl::Accumulator<Container, AccumulateFunc> iter::accumulate(
-    Container&& container, AccumulateFunc accumulate_func) {
-  return {std::forward<Container>(container), accumulate_func};
-}
-
-namespace iter {
-  template <typename Container>
-  auto accumulate(Container&& container) -> decltype(accumulate(
-      std::forward<Container>(container),
-      std::plus<std::remove_reference_t<impl::iterator_deref<Container>>>{})) {
-    return accumulate(std::forward<Container>(container),
-        std::plus<std::remove_reference_t<impl::iterator_deref<Container>>>{});
-  }
-}
-
 #endif

From 0cba0d789824be81fe928dae241fd1676f0d46f0 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 9 Apr 2016 16:05:17 -0700
Subject: [PATCH 1431/1866] tests groupby with pipe

---
 test/test_groupby.cpp | 28 ++++++++++++++++++++++------
 1 file changed, 22 insertions(+), 6 deletions(-)

diff --git a/test/test_groupby.cpp b/test/test_groupby.cpp
index 1bbc7864..a102692f 100644
--- a/test/test_groupby.cpp
+++ b/test/test_groupby.cpp
@@ -30,9 +30,17 @@ TEST_CASE("groupby: works with lambda, callable, and function pointer") {
   std::vector<std::vector<std::string>> groups;
 
   SECTION("Function pointer") {
-    for (auto&& gb : groupby(vec, length)) {
-      keys.push_back(gb.first);
-      groups.emplace_back(std::begin(gb.second), std::end(gb.second));
+    SECTION("Normal call") {
+      for (auto&& gb : groupby(vec, length)) {
+        keys.push_back(gb.first);
+        groups.emplace_back(std::begin(gb.second), std::end(gb.second));
+      }
+    }
+    SECTION("Pipe") {
+      for (auto&& gb : vec | groupby(length)) {
+        keys.push_back(gb.first);
+        groups.emplace_back(std::begin(gb.second), std::end(gb.second));
+      }
     }
   }
 
@@ -109,9 +117,17 @@ TEST_CASE("groupby: single argument uses elements as keys", "[groupby]") {
   std::vector<int> ivec = {5, 5, 6, 6, 19, 19, 19, 19, 69, 0, 10, 10};
   std::vector<int> keys;
   std::vector<std::vector<int>> groups;
-  for (auto&& gb : groupby(ivec)) {
-    keys.push_back(gb.first);
-    groups.emplace_back(std::begin(gb.second), std::end(gb.second));
+  SECTION("Normal call") {
+    for (auto&& gb : groupby(ivec)) {
+      keys.push_back(gb.first);
+      groups.emplace_back(std::begin(gb.second), std::end(gb.second));
+    }
+  }
+  SECTION("Pipe") {
+    for (auto&& gb : ivec | groupby) {
+      keys.push_back(gb.first);
+      groups.emplace_back(std::begin(gb.second), std::end(gb.second));
+    }
   }
 
   const std::vector<int> kc = {5, 6, 19, 69, 0, 10};

From 475a54a15ab8469028b7518753a98285d82b62a3 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 9 Apr 2016 16:05:42 -0700
Subject: [PATCH 1432/1866] Uses GroupByFn$

---
 groupby.hpp | 43 +++++++++++--------------------------------
 1 file changed, 11 insertions(+), 32 deletions(-)

diff --git a/groupby.hpp b/groupby.hpp
index 52e6f097..a0af1d4d 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -14,9 +14,17 @@ namespace iter {
   namespace impl {
     template <typename Container, typename KeyFunc>
     class GroupProducer;
+
+    struct Identity {
+      template <typename T>
+      const T& operator()(const T& t) const {
+        return t;
+      }
+    };
+
+    using GroupByFn = IterToolFnOptionalBindSecond<GroupProducer, Identity>;
   }
-  template <typename Container, typename KeyFunc>
-  impl::GroupProducer<Container, KeyFunc> groupby(Container&&, KeyFunc);
+  constexpr impl::GroupByFn groupby{};
 }
 
 template <typename Container, typename KeyFunc>
@@ -25,7 +33,7 @@ class iter::impl::GroupProducer {
   Container container;
   KeyFunc key_func;
 
-  friend GroupProducer iter::groupby<Container, KeyFunc>(Container&&, KeyFunc);
+  friend GroupByFn;
 
   using key_func_ret = std::result_of_t<KeyFunc(iterator_deref<Container>)>;
 
@@ -257,33 +265,4 @@ class iter::impl::GroupProducer {
   }
 };
 
-template <typename Container, typename KeyFunc>
-iter::impl::GroupProducer<Container, KeyFunc> iter::groupby(
-    Container&& container, KeyFunc key_func) {
-  return {std::forward<Container>(container), key_func};
-}
-
-
-namespace iter {
-  namespace detail {
-    // Takes something and returns it, used for default key of comparing
-    // items in the sequence directly
-    template <typename Container>
-    class ItemReturner {
-     public:
-      impl::iterator_deref<Container> operator()(
-          impl::iterator_deref<Container> item) const {
-        return item;
-      }
-    };
-  }
-
-  template <typename Container>
-  auto groupby(Container&& container) {
-    return groupby(
-        std::forward<Container>(container), detail::ItemReturner<Container>());
-  }
-
-}
-
 #endif

From 899324350d286cc2a6c5e430729c71d1b8da9c94 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 10 Apr 2016 15:13:07 -0700
Subject: [PATCH 1433/1866] Tests that sorted works with pipe

---
 test/test_sorted.cpp | 27 ++++++++++++++++++++-------
 1 file changed, 20 insertions(+), 7 deletions(-)

diff --git a/test/test_sorted.cpp b/test/test_sorted.cpp
index f6c902ba..d04f9364 100644
--- a/test/test_sorted.cpp
+++ b/test/test_sorted.cpp
@@ -16,8 +16,15 @@ using Vec = const std::vector<int>;
 
 TEST_CASE("sorted: iterates through a vector in sorted order", "[sorted]") {
   Vec ns = {4, 0, 5, 1, 6, 7, 9, 3, 2, 8};
-  auto s = sorted(ns);
-  Vec v(std::begin(s), std::end(s));
+  std::vector<int> v;
+  SECTION("Normal Call") {
+    auto s = sorted(ns);
+    v.assign(std::begin(s), std::end(s));
+  }
+  SECTION("Pipe") {
+    auto s = ns | sorted;
+    v.assign(std::begin(s), std::end(s));
+  }
   Vec vc = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
   REQUIRE(v == vc);
 }
@@ -58,22 +65,28 @@ namespace {
   };
 }
 
-TEST_CASE("sorted: works with different functor types", "[sorted]") {
+TEST_CASE("sorted: works with different callable types", "[sorted]") {
   Vec ns = {4, 1, 3, 2, 0};
   std::vector<int> v;
   SECTION("with function pointer") {
     auto s = sorted(ns, int_greater_than);
-    v.insert(v.begin(), std::begin(s), std::end(s));
+    v.assign(std::begin(s), std::end(s));
   }
 
   SECTION("with callable object") {
-    auto s = sorted(ns, IntGreaterThan{});
-    v.insert(v.begin(), std::begin(s), std::end(s));
+    SECTION("Normal call") {
+      auto s = sorted(ns, IntGreaterThan{});
+      v.assign(std::begin(s), std::end(s));
+    }
+    SECTION("Pipe") {
+      auto s = ns | sorted(IntGreaterThan{});
+      v.assign(std::begin(s), std::end(s));
+    }
   }
 
   SECTION("with lambda") {
     auto s = sorted(ns, [](int lhs, int rhs) { return lhs > rhs; });
-    v.insert(v.begin(), std::begin(s), std::end(s));
+    v.assign(std::begin(s), std::end(s));
   }
 
   Vec vc = {4, 3, 2, 1, 0};

From ed9c8da8d731bb76370338f2f4bad096e5654933 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 10 Apr 2016 15:13:17 -0700
Subject: [PATCH 1434/1866] uses SortedFn

---
 sorted.hpp | 33 ++++++++-------------------------
 1 file changed, 8 insertions(+), 25 deletions(-)

diff --git a/sorted.hpp b/sorted.hpp
index 3fc4767d..529b8dcc 100644
--- a/sorted.hpp
+++ b/sorted.hpp
@@ -10,27 +10,24 @@
 
 namespace iter {
   namespace impl {
-    template <typename Container>
+    template <typename Container, typename CompareFunc>
     class SortedView;
+    using SortedFn = IterToolFnOptionalBindSecond<SortedView, std::less<>>;
   }
-
-  template <typename Container, typename CompareFunc>
-  impl::SortedView<Container> sorted(Container&&, CompareFunc);
+  constexpr impl::SortedFn sorted{};
 }
 
-template <typename Container>
+template <typename Container, typename CompareFunc>
 class iter::impl::SortedView {
  private:
   using IterIterWrap = IterIterWrapper<std::vector<iterator_type<Container>>>;
   using ItIt = iterator_type<IterIterWrap>;
 
-  template <typename C, typename F>
-  friend SortedView<C> iter::sorted(C&&, F);
+  friend SortedFn;
 
   Container container;
   IterIterWrap sorted_iters;
 
-  template <typename CompareFunc>
   SortedView(Container&& in_container, CompareFunc compare_func)
       : container(std::forward<Container>(in_container)) {
     // Fill the sorted_iters vector with an iterator to each
@@ -41,11 +38,10 @@ class iter::impl::SortedView {
     }
 
     // sort by comparing the elements that the iterators point to
-    std::sort(std::begin(sorted_iters.get()), std::end(sorted_iters.get()),
+    std::sort(
+        std::begin(sorted_iters.get()), std::end(sorted_iters.get()),
         [compare_func](iterator_type<Container> it1,
-                  iterator_type<Container> it2) {
-          return compare_func(*it1, *it2);
-        });
+            iterator_type<Container> it2) { return compare_func(*it1, *it2); });
   }
 
  public:
@@ -60,17 +56,4 @@ class iter::impl::SortedView {
   }
 };
 
-template <typename Container, typename CompareFunc>
-iter::impl::SortedView<Container> iter::sorted(
-    Container&& container, CompareFunc compare_func) {
-  return {std::forward<Container>(container), compare_func};
-}
-
-namespace iter {
-  template <typename Container>
-  auto sorted(Container&& container) {
-    return sorted(std::forward<Container>(container), std::less<>{});
-  }
-}
-
 #endif

From c056b37e9bffaa24e8a12faf1ed8c0aa013e125a Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 14 Apr 2016 22:28:42 -0700
Subject: [PATCH 1435/1866] tests unique_everseen with pipe

---
 test/test_unique_everseen.cpp | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/test/test_unique_everseen.cpp b/test/test_unique_everseen.cpp
index 76151efe..f83b358e 100644
--- a/test/test_unique_everseen.cpp
+++ b/test/test_unique_everseen.cpp
@@ -23,8 +23,15 @@ TEST_CASE("unique everseen: adjacent repeating values", "[unique_everseen]") {
 TEST_CASE(
     "unique everseen: nonadjacent repeating values", "[unique_everseen]") {
   Vec ns = {1, 2, 3, 4, 3, 2, 1, 5, 6};
-  auto ue = unique_everseen(ns);
-  Vec v(std::begin(ue), std::end(ue));
+  std::vector<int> v;
+  SECTION("Normal call") {
+    auto ue = unique_everseen(ns);
+    v.assign(std::begin(ue), std::end(ue));
+  }
+  SECTION("Pipe") {
+    auto ue = ns | unique_everseen;
+    v.assign(std::begin(ue), std::end(ue));
+  }
   Vec vc = {1, 2, 3, 4, 5, 6};
   REQUIRE(v == vc);
 }

From 0e50234aaca9e7ee31ff44ced19034a187dc6d6c Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 14 Apr 2016 22:28:55 -0700
Subject: [PATCH 1436/1866] supports pipe in unique_everseen

---
 unique_everseen.hpp | 20 +++++++++++++-------
 1 file changed, 13 insertions(+), 7 deletions(-)

diff --git a/unique_everseen.hpp b/unique_everseen.hpp
index 043c5e8f..21b15d21 100644
--- a/unique_everseen.hpp
+++ b/unique_everseen.hpp
@@ -11,15 +11,21 @@
 #include <iterator>
 
 namespace iter {
-  template <typename Container>
-  auto unique_everseen(Container&& container) {
-    using elem_type = impl::iterator_deref<Container>;
-    auto func = [elem_seen = std::unordered_set<std::decay_t<elem_type>>()](
-        const elem_type& e) mutable {
-      return elem_seen.insert(e).second;
+  namespace impl {
+    struct UniqueEverseenFn : Pipeable<UniqueEverseenFn> {
+      template <typename Container>
+      auto operator()(Container&& container) const {
+        using elem_type = impl::iterator_deref<Container>;
+        auto func = [elem_seen = std::unordered_set<std::decay_t<elem_type>>()](
+            const elem_type& e) mutable {
+          return elem_seen.insert(e).second;
+        };
+        return filter(func, std::forward<Container>(container));
+      }
     };
-    return filter(func, std::forward<Container>(container));
   }
+
+  constexpr impl::UniqueEverseenFn unique_everseen{};
 }
 
 #endif

From 86a822a7db45f09e00e1cdda9d99d39cda75a02b Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 14 Apr 2016 22:32:41 -0700
Subject: [PATCH 1437/1866] tests unique_justseen with pipe

---
 test/test_unique_justseen.cpp | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/test/test_unique_justseen.cpp b/test/test_unique_justseen.cpp
index 1167594f..e66bdee6 100644
--- a/test/test_unique_justseen.cpp
+++ b/test/test_unique_justseen.cpp
@@ -22,8 +22,15 @@ TEST_CASE("unique justseen: adjacent repeating values", "[unique_justseen]") {
 
 TEST_CASE("unique justseen: some repeating values", "[unique_justseen]") {
   Vec ns = {1, 2, 2, 3, 4, 4, 5, 6, 6};
-  auto ue = unique_justseen(ns);
-  Vec v(std::begin(ue), std::end(ue));
+  std::vector<int> v;
+  SECTION("Normal call") {
+    auto ue = unique_justseen(ns);
+    v.assign(std::begin(ue), std::end(ue));
+  }
+  SECTION("Pipe") {
+    auto ue = ns | unique_justseen;
+    v.assign(std::begin(ue), std::end(ue));
+  }
   Vec vc = {1, 2, 3, 4, 5, 6};
   REQUIRE(v == vc);
 }

From 261ca6c4eb2f0873682942e543bca2e08414ff06 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 14 Apr 2016 22:32:56 -0700
Subject: [PATCH 1438/1866] supports pipe in unique_justseen

---
 unique_justseen.hpp | 18 +++++++++++-------
 1 file changed, 11 insertions(+), 7 deletions(-)

diff --git a/unique_justseen.hpp b/unique_justseen.hpp
index 6b3963f0..caad5076 100644
--- a/unique_justseen.hpp
+++ b/unique_justseen.hpp
@@ -8,14 +8,18 @@
 #include <iterator>
 
 namespace iter {
-
-  template <typename Container>
-  auto unique_justseen(Container&& container) {
-    // explicit return type in lambda so reference types are preserved
-    return imap([](auto&& group) -> impl::iterator_deref<Container> {
-      return *std::begin(group.second);
-    }, groupby(std::forward<Container>(container)));
+  namespace impl {
+    struct UniqueJustseenFn : Pipeable<UniqueJustseenFn> {
+      template <typename Container>
+      auto operator()(Container&& container) const {
+        // explicit return type in lambda so reference types are preserved
+        return imap([](auto&& group) -> impl::iterator_deref<Container> {
+          return *std::begin(group.second);
+        }, groupby(std::forward<Container>(container)));
+      }
+    };
   }
+  constexpr impl::UniqueJustseenFn unique_justseen{};
 }
 
 #endif

From 39912a27a90f7e633e8ff6c5cb519c5c91f74dd5 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 15 Apr 2016 00:34:23 -0700
Subject: [PATCH 1439/1866] Factors out the callable from the template template

---
 internal/iterbase.hpp | 41 +++++++++++++++++++++++++----------------
 1 file changed, 25 insertions(+), 16 deletions(-)

diff --git a/internal/iterbase.hpp b/internal/iterbase.hpp
index ac96b2d6..196bcf69 100644
--- a/internal/iterbase.hpp
+++ b/internal/iterbase.hpp
@@ -346,15 +346,11 @@ namespace iter {
       }
     };
 
-    // This is a complicated class to generate a callable that can work:
-    //  (1) with just a single (iterable) passed, and DefaultFunc substituted
-    //  (2) with an iterable and a callable
-    //  (3) with just a callable, to have the iterable passed later via pipe
-    template <template <typename, typename> class ItImpl, typename DefaultFunc>
-    struct IterToolFnOptionalBindFirst
-        : Pipeable<IterToolFnOptionalBindFirst<ItImpl, DefaultFunc>> {
-     private:
-      // T is whatever is being held for later use
+    // Pipeable callable which allows binding of the first argument
+    // f(a, b) is the same as b | f(a)
+    template <typename F>
+    struct PipeableAndBindFirst : Pipeable<F> {
+     protected:
       template <typename T>
       struct FnPartial : Pipeable<FnPartial<T>> {
         mutable T stored_arg;
@@ -362,11 +358,25 @@ namespace iter {
 
         template <typename Container>
         auto operator()(Container&& container) const {
-          return IterToolFnOptionalBindFirst{}(
-              stored_arg, std::forward<Container>(container));
+          return F{}(stored_arg, std::forward<Container>(container));
         }
       };
 
+      template <typename T, typename = std::enable_if_t<!is_iterable<T>>>
+      FnPartial<T> operator()(T t) const {
+        return {std::move(t)};
+      }
+    };
+
+    // This is a complicated class to generate a callable that can work:
+    //  (1) with just a single (iterable) passed, and DefaultFunc substituted
+    //  (2) with an iterable and a callable
+    //  (3) with just a callable, to have the iterable passed later via pipe
+    template <template <typename, typename> class ItImpl, typename DefaultFunc>
+    struct IterToolFnOptionalBindFirst
+        : PipeableAndBindFirst<IterToolFnOptionalBindFirst<ItImpl,
+              DefaultFunc>> {
+     private:
      public:
       template <typename Func, typename Container>
       ItImpl<Func, Container> operator()(
@@ -374,16 +384,15 @@ namespace iter {
         return {std::move(func), std::forward<Container>(container)};
       }
 
-      template <typename Func, typename = std::enable_if_t<!is_iterable<Func>>>
-      FnPartial<Func> operator()(Func func) const {
-        return {std::move(func)};
-      }
-
       template <typename Container,
           typename = std::enable_if_t<is_iterable<Container>>>
       auto operator()(Container&& container) const {
         return (*this)(DefaultFunc{}, std::forward<Container>(container));
       }
+
+      using PipeableAndBindFirst<IterToolFnOptionalBindFirst<ItImpl,
+          DefaultFunc>>::
+      operator();
     };
 
     template <template <typename, typename> class ItImpl, typename DefaultFunc>

From 4cbbb7afb622eaf51a4fb18f01010b80c466886c Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 15 Apr 2016 00:34:51 -0700
Subject: [PATCH 1440/1866] tests imap with pipe

---
 test/test_imap.cpp | 24 ++++++++++++++----------
 1 file changed, 14 insertions(+), 10 deletions(-)

diff --git a/test/test_imap.cpp b/test/test_imap.cpp
index f150d3aa..4912b11f 100644
--- a/test/test_imap.cpp
+++ b/test/test_imap.cpp
@@ -34,26 +34,30 @@ namespace {
 
 TEST_CASE("imap: works with lambda, callable, and function", "[imap]") {
   Vec ns = {10, 20, 30};
+  std::vector<int> v;
   SECTION("with lambda") {
     auto im = imap([](int i) { return i + 1; }, ns);
-    Vec v(std::begin(im), std::end(im));
-    Vec vc = {11, 21, 31};
-    REQUIRE(v == vc);
+    v.assign(std::begin(im), std::end(im));
   }
 
   SECTION("with callable") {
-    auto im = imap(PlusOner{}, ns);
-    Vec v(std::begin(im), std::end(im));
-    Vec vc = {11, 21, 31};
-    REQUIRE(v == vc);
+    SECTION("Normal call") {
+      auto im = imap(PlusOner{}, ns);
+      v.assign(std::begin(im), std::end(im));
+    }
+    SECTION("Pipe") {
+      auto im = ns | imap(PlusOner{});
+      v.assign(std::begin(im), std::end(im));
+    }
   }
 
   SECTION("with function") {
     auto im = imap(PlusOner{}, ns);
-    Vec v(std::begin(im), std::end(im));
-    Vec vc = {11, 21, 31};
-    REQUIRE(v == vc);
+    v.assign(std::begin(im), std::end(im));
   }
+
+  Vec vc = {11, 21, 31};
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("imap: works with multiple sequences", "[imap]") {

From 57114afbdb4394f04b564d785b6f3058a217cdc7 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 15 Apr 2016 00:35:14 -0700
Subject: [PATCH 1441/1866] makes map work with pipe

---
 imap.hpp | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

diff --git a/imap.hpp b/imap.hpp
index 35e07378..807a2826 100644
--- a/imap.hpp
+++ b/imap.hpp
@@ -7,10 +7,17 @@
 #include <utility>
 
 namespace iter {
-  template <typename MapFunc, typename... Containers>
-  decltype(auto) imap(MapFunc map_func, Containers&&... containers) {
-    return starmap(map_func, zip(std::forward<Containers>(containers)...));
+  namespace impl {
+    struct IMapFn : PipeableAndBindFirst<IMapFn> {
+      template <typename MapFunc, typename... Containers>
+      decltype(auto) operator()(
+          MapFunc map_func, Containers&&... containers) const {
+        return starmap(map_func, zip(std::forward<Containers>(containers)...));
+      }
+      using PipeableAndBindFirst<IMapFn>::operator();
+    };
   }
+  constexpr impl::IMapFn imap{};
 }
 
 #endif

From 2178dc91ec3563f4059fcbd9eca97d886dd7b586 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 15 Apr 2016 00:41:44 -0700
Subject: [PATCH 1442/1866] formatting

---
 internal/iterbase.hpp | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/internal/iterbase.hpp b/internal/iterbase.hpp
index 196bcf69..2f6ec662 100644
--- a/internal/iterbase.hpp
+++ b/internal/iterbase.hpp
@@ -376,7 +376,6 @@ namespace iter {
     struct IterToolFnOptionalBindFirst
         : PipeableAndBindFirst<IterToolFnOptionalBindFirst<ItImpl,
               DefaultFunc>> {
-     private:
      public:
       template <typename Func, typename Container>
       ItImpl<Func, Container> operator()(
@@ -391,8 +390,7 @@ namespace iter {
       }
 
       using PipeableAndBindFirst<IterToolFnOptionalBindFirst<ItImpl,
-          DefaultFunc>>::
-      operator();
+          DefaultFunc>>::operator();
     };
 
     template <template <typename, typename> class ItImpl, typename DefaultFunc>

From 5d668f609dc6c0b383cbf949202dee6b93678c39 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 15 Apr 2016 01:03:14 -0700
Subject: [PATCH 1443/1866] tests (both kinds of) starmap with pipe

---
 test/test_starmap.cpp | 29 +++++++++++++++++++++--------
 1 file changed, 21 insertions(+), 8 deletions(-)

diff --git a/test/test_starmap.cpp b/test/test_starmap.cpp
index 751d3d4e..25451dcf 100644
--- a/test/test_starmap.cpp
+++ b/test/test_starmap.cpp
@@ -38,17 +38,23 @@ TEST_CASE("starmap: works with function pointer and lambda", "[starmap]") {
   const std::vector<std::pair<double, int>> v1 = {{1l, 2}, {3l, 11}, {6l, 7}};
   Vec vc = {2l, 33l, 42l};
 
+  std::vector<int> v;
   SECTION("with function") {
-    auto sm = starmap(f, v1);
-    Vec v(std::begin(sm), std::end(sm));
-    REQUIRE(v == vc);
+    SECTION("Normal call") {
+      auto sm = starmap(f, v1);
+      v.assign(std::begin(sm), std::end(sm));
+    }
+    SECTION("pipe") {
+      auto sm = v1 | starmap(f);
+      v.assign(std::begin(sm), std::end(sm));
+    }
   }
 
   SECTION("with lambda") {
     auto sm = starmap([](long a, int b) { return a * b; }, v1);
-    Vec v(std::begin(sm), std::end(sm));
-    REQUIRE(v == vc);
+    v.assign(std::begin(sm), std::end(sm));
   }
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("starmap: list of tuples", "[starmap]") {
@@ -66,10 +72,17 @@ TEST_CASE("starmap: list of tuples", "[starmap]") {
 TEST_CASE("starmap: tuple of tuples", "[starmap]") {
   using Vec = const std::vector<int>;
   auto tup = std::make_tuple(std::make_tuple(10, 19, 60), std::make_tuple(7));
-  auto sm = starmap(Callable{}, tup);
-  Vec v(std::begin(sm), std::end(sm));
-  Vec vc = {89, 7};
+  std::vector<int> v;
+  SECTION("Normal call") {
+    auto sm = starmap(Callable{}, tup);
+    v.assign(std::begin(sm), std::end(sm));
+  }
+  SECTION("Pipe") {
+    auto sm = tup | starmap(Callable{});
+    v.assign(std::begin(sm), std::end(sm));
+  }
 
+  Vec vc = {89, 7};
   REQUIRE(v == vc);
 }
 

From ecaef9ba8184855aac3a4c7481926d81ea10a345 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 15 Apr 2016 01:03:30 -0700
Subject: [PATCH 1444/1866] makes starmap work with pipe

---
 starmap.hpp | 95 +++++++++++++++++++++++++----------------------------
 1 file changed, 44 insertions(+), 51 deletions(-)

diff --git a/starmap.hpp b/starmap.hpp
index bfd7daa5..e4658e50 100644
--- a/starmap.hpp
+++ b/starmap.hpp
@@ -10,32 +10,21 @@
 #include <cassert>
 #include <memory>
 
-//NOTE I don't know why, but clang gets very confused by having this-> in the
-//Iterators' member functions
 namespace iter {
   namespace impl {
     template <typename Func, typename Container>
     class StarMapper;
 
-    template <typename Func, typename Container>
-    StarMapper<Func, Container> starmap_helper(
-        Func, Container&&, std::false_type);
-
-    template <typename Func, typename Container>
-    auto starmap_helper(Func, Container&&, std::true_type);
-
     template <typename Func, typename TupType, std::size_t... Is>
     class TupleStarMapper;
 
-    template <typename Func, typename TupType, std::size_t... Is>
-    TupleStarMapper<Func, TupType, Is...> starmap_with_tuples(
-        Func, TupType&&, std::index_sequence<Is...>);
+    struct StarMapFn;
   }
-
-  template <typename Func, typename Seq>
-  auto starmap(Func func, Seq&& sequence);
 }
 
+// NOTE I don't know why, but clang gets very confused by having this-> in the
+// Iterators' member functions for these classes
+
 // starmap with a container<T> where T is one of tuple, pair, array
 template <typename Func, typename Container>
 class iter::impl::StarMapper {
@@ -48,8 +37,8 @@ class iter::impl::StarMapper {
 
   StarMapper(Func f, Container&& c)
       : func(std::move(f)), container(std::forward<Container>(c)) {}
-  friend StarMapper starmap_helper<Func, Container>(
-      Func, Container&&, std::false_type);
+
+  friend StarMapFn;
 
  public:
   class Iterator
@@ -110,8 +99,7 @@ class iter::impl::TupleStarMapper {
   static_assert(sizeof...(Is) == std::tuple_size<std::decay_t<TupType>>::value,
       "tuple size doesn't match size of Is");
 
-  friend TupleStarMapper starmap_with_tuples<Func, TupType, Is...>(
-      Func, TupType&&, std::index_sequence<Is...>);
+  friend StarMapFn;
 
   template <std::size_t Idx>
   static decltype(auto) get_and_call_with_tuple(Func& f, TupType& t) {
@@ -182,44 +170,49 @@ constexpr std::array<
     typename iter::impl::TupleStarMapper<Func, TupType, Is...>::CallerFunc,
     sizeof...(Is)> iter::impl::TupleStarMapper<Func, TupType, Is...>::callers;
 
-template <typename Func, typename TupType, std::size_t... Is>
-iter::impl::TupleStarMapper<Func, TupType, Is...>
-iter::impl::starmap_with_tuples(
-    Func func, TupType&& tup, std::index_sequence<Is...>) {
-  return {std::move(func), std::forward<TupType>(tup)};
-}
+struct iter::impl::StarMapFn : PipeableAndBindFirst<StarMapFn> {
+ private:
+  template <typename Func, typename TupType, std::size_t... Is>
+  TupleStarMapper<Func, TupType, Is...> helper_with_tuples(
+      Func func, TupType&& tup, std::index_sequence<Is...>) const {
+    return {std::move(func), std::forward<TupType>(tup)};
+  }
 
-// handles tuple-like types
-template <typename Func, typename TupType>
-auto iter::impl::starmap_helper(Func func, TupType&& tup, std::true_type) {
-  return starmap_with_tuples(std::move(func), std::forward<TupType>(tup),
-      std::
-          make_index_sequence<std::tuple_size<std::decay_t<TupType>>::value>{});
-}
+  // handles tuple-like types
+  template <typename Func, typename TupType>
+  auto helper(Func func, TupType&& tup, std::true_type) const {
+    return helper_with_tuples(std::move(func), std::forward<TupType>(tup),
+        std::make_index_sequence<std::tuple_size<std::decay_t<TupType>>::
+                                      value>{});
+  }
 
-// handles everything else
-template <typename Func, typename Container>
-iter::impl::StarMapper<Func, Container> iter::impl::starmap_helper(
-    Func func, Container&& container, std::false_type) {
-  return {std::move(func), std::forward<Container>(container)};
-}
+  // handles everything else
+  template <typename Func, typename Container>
+  StarMapper<Func, Container> helper(
+      Func func, Container&& container, std::false_type) const {
+    return {std::move(func), std::forward<Container>(container)};
+  }
 
-namespace iter {
-  namespace impl {
-    template <typename T, typename = void>
-    struct is_tuple_like : public std::false_type {};
+  template <typename T, typename = void>
+  struct is_tuple_like : public std::false_type {};
+
+  template <typename T>
+  struct is_tuple_like<T,
+      void_t<decltype(std::tuple_size<std::decay_t<T>>::value)>>
+      : public std::true_type {};
 
-    template <typename T>
-    struct is_tuple_like<T,
-        void_t<decltype(std::tuple_size<std::decay_t<T>>::value)>>
-        : public std::true_type {};
+ public:
+  template <typename Func, typename Seq>
+  auto operator()(Func func, Seq&& sequence) const {
+    return helper(
+        std::move(func), std::forward<Seq>(sequence), is_tuple_like<Seq>{});
   }
-}
 
-template <typename Func, typename Seq>
-auto iter::starmap(Func func, Seq&& sequence) {
-  return impl::starmap_helper(
-      std::move(func), std::forward<Seq>(sequence), impl::is_tuple_like<Seq>{});
+  using PipeableAndBindFirst<StarMapFn>::operator();
+};
+
+namespace iter {
+  constexpr impl::StarMapFn starmap{};
 }
 
 #endif

From a82976065e77497a5bfae17d746c62f738af4f3e Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 15 Apr 2016 12:12:28 -0700
Subject: [PATCH 1445/1866] Adapts to clang issue:

http://llvm.org/bugs/show_bug.cgi?id=27377
---
 internal/iterbase.hpp | 55 ++++++++++++++++++++++++++-----------------
 1 file changed, 33 insertions(+), 22 deletions(-)

diff --git a/internal/iterbase.hpp b/internal/iterbase.hpp
index 2f6ec662..e84714cb 100644
--- a/internal/iterbase.hpp
+++ b/internal/iterbase.hpp
@@ -350,7 +350,7 @@ namespace iter {
     // f(a, b) is the same as b | f(a)
     template <typename F>
     struct PipeableAndBindFirst : Pipeable<F> {
-     protected:
+     public:
       template <typename T>
       struct FnPartial : Pipeable<FnPartial<T>> {
         mutable T stored_arg;
@@ -363,39 +363,51 @@ namespace iter {
       };
 
       template <typename T, typename = std::enable_if_t<!is_iterable<T>>>
-      FnPartial<T> operator()(T t) const {
-        return {std::move(t)};
+      FnPartial<std::decay_t<T>> operator()(T&& t) const {
+        return {std::forward<T>(t)};
       }
     };
 
     // This is a complicated class to generate a callable that can work:
-    //  (1) with just a single (iterable) passed, and DefaultFunc substituted
+    //  (1) with just a single (iterable) passed, and DefaultT substituted
     //  (2) with an iterable and a callable
     //  (3) with just a callable, to have the iterable passed later via pipe
-    template <template <typename, typename> class ItImpl, typename DefaultFunc>
+    template <template <typename, typename> class ItImpl, typename DefaultT>
     struct IterToolFnOptionalBindFirst
-        : PipeableAndBindFirst<IterToolFnOptionalBindFirst<ItImpl,
-              DefaultFunc>> {
+        : Pipeable<IterToolFnOptionalBindFirst<ItImpl, DefaultT>> {
      public:
-      template <typename Func, typename Container>
-      ItImpl<Func, Container> operator()(
-          Func func, Container&& container) const {
+      template <typename T, typename Container>
+      ItImpl<T, Container> operator()(T func, Container&& container) const {
         return {std::move(func), std::forward<Container>(container)};
       }
 
       template <typename Container,
           typename = std::enable_if_t<is_iterable<Container>>>
       auto operator()(Container&& container) const {
-        return (*this)(DefaultFunc{}, std::forward<Container>(container));
+        return (*this)(DefaultT{}, std::forward<Container>(container));
       }
 
-      using PipeableAndBindFirst<IterToolFnOptionalBindFirst<ItImpl,
-          DefaultFunc>>::operator();
+      template <typename T>
+      struct FnPartial : Pipeable<FnPartial<T>> {
+        mutable T stored_arg;
+        constexpr FnPartial(T in_t) : stored_arg(in_t) {}
+
+        template <typename Container>
+        auto operator()(Container&& container) const {
+          return IterToolFnOptionalBindFirst{}(
+              stored_arg, std::forward<Container>(container));
+        }
+      };
+
+      template <typename T, typename = std::enable_if_t<!is_iterable<T>>>
+      FnPartial<std::decay_t<T>> operator()(T&& t) const {
+        return {std::forward<T>(t)};
+      }
     };
 
-    template <template <typename, typename> class ItImpl, typename DefaultFunc>
+    template <template <typename, typename> class ItImpl, typename DefaultT>
     struct IterToolFnOptionalBindSecond
-        : Pipeable<IterToolFnOptionalBindSecond<ItImpl, DefaultFunc>> {
+        : Pipeable<IterToolFnOptionalBindSecond<ItImpl, DefaultT>> {
      private:
       // T is whatever is being held for later use
       template <typename T>
@@ -411,21 +423,20 @@ namespace iter {
       };
 
      public:
-      template <typename Container, typename Func>
-      ItImpl<Container, Func> operator()(
-          Container&& container, Func func) const {
+      template <typename Container, typename T>
+      ItImpl<Container, T> operator()(Container&& container, T func) const {
         return {std::forward<Container>(container), std::move(func)};
       }
 
-      template <typename Func, typename = std::enable_if_t<!is_iterable<Func>>>
-      FnPartial<Func> operator()(Func func) const {
-        return {std::move(func)};
+      template <typename T, typename = std::enable_if_t<!is_iterable<T>>>
+      FnPartial<std::decay_t<T>> operator()(T&& func) const {
+        return {std::forward<T>(func)};
       }
 
       template <typename Container,
           typename = std::enable_if_t<is_iterable<Container>>>
       auto operator()(Container&& container) const {
-        return (*this)(std::forward<Container>(container), DefaultFunc{});
+        return (*this)(std::forward<Container>(container), DefaultT{});
       }
     };
   }

From 0bafc43d10fa682e4ec3d57e5f835b63edf1b5d9 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 15 Apr 2016 12:13:57 -0700
Subject: [PATCH 1446/1866] tests enumerate with pipe and index

---
 test/test_enumerate.cpp | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/test/test_enumerate.cpp b/test/test_enumerate.cpp
index e3f55762..be5209ff 100644
--- a/test/test_enumerate.cpp
+++ b/test/test_enumerate.cpp
@@ -139,6 +139,15 @@ TEST_CASE("enumerate: works with pipe", "[enumerate]") {
   REQUIRE(v == vc);
 }
 
+TEST_CASE("enumerate: works index and pipe", "[enumerate]") {
+  constexpr char str[] = {'a', 'b', 'c'};
+  auto e = str | enumerate(2);
+  Vec v(std::begin(e), std::end(e));
+  Vec vc{{2, 'a'}, {3, 'b'}, {4, 'c'}};
+
+  REQUIRE(v == vc);
+}
+
 template <typename T>
 using ImpT = decltype(enumerate(std::declval<T>()));
 TEST_CASE("enumerate: has correct ctor and assign ops", "[enumerate]") {

From 42326d259674d3ed2bf01b835ff62aeb1161d94c Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 15 Apr 2016 12:14:33 -0700
Subject: [PATCH 1447/1866] Adapts enumerate to work with Fn generators

---
 enumerate.hpp | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index 28d17362..6492c909 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -11,27 +11,27 @@
 
 namespace iter {
   namespace impl {
-    template <typename Container>
+    template <typename Container, typename Index>
     class Enumerable;
 
-    using EnumerateFn = IterToolFn<Enumerable>;
+    using EnumerateFn = IterToolFnOptionalBindSecond<Enumerable, std::size_t>;
   }
   constexpr impl::EnumerateFn enumerate{};
 }
 
-template <typename Container>
+template <typename Container, typename Index>
 class iter::impl::Enumerable {
  private:
   Container container;
-  const std::size_t start;
+  const Index start;
 
   friend EnumerateFn;
 
   // for IterYield
-  using BasePair = std::pair<std::size_t, iterator_deref<Container>>;
+  using BasePair = std::pair<Index, iterator_deref<Container>>;
 
   // Value constructor for use only in the enumerate function
-  Enumerable(Container&& in_container, std::size_t in_start = 0)
+  Enumerable(Container&& in_container, Index in_start)
       : container(std::forward<Container>(in_container)), start{in_start} {}
 
  public:
@@ -46,16 +46,16 @@ class iter::impl::Enumerable {
     typename BasePair::second_type& element = BasePair::second;
   };
 
-  //  Holds an iterator of the contained type and a size_t for the
+  //  Holds an iterator of the contained type and an Index for the
   //  index.  Each call to ++ increments both of these data members.
   //  Each dereference returns an IterYield.
   class Iterator : public std::iterator<std::input_iterator_tag, IterYield> {
    private:
     iterator_type<Container> sub_iter;
-    std::size_t index;
+    Index index;
 
    public:
-    Iterator(iterator_type<Container>&& si, std::size_t start)
+    Iterator(iterator_type<Container>&& si, Index start)
         : sub_iter{std::move(si)}, index{start} {}
 
     IterYield operator*() {

From af4f86065794a7d49b9d90646c66c46c127c25e4 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 17 Apr 2016 10:33:32 -0700
Subject: [PATCH 1448/1866] merges PipeableAndBindFirst with generator

---
 internal/iterbase.hpp | 41 +++++++++++++++++++----------------------
 1 file changed, 19 insertions(+), 22 deletions(-)

diff --git a/internal/iterbase.hpp b/internal/iterbase.hpp
index e84714cb..a052302e 100644
--- a/internal/iterbase.hpp
+++ b/internal/iterbase.hpp
@@ -350,7 +350,7 @@ namespace iter {
     // f(a, b) is the same as b | f(a)
     template <typename F>
     struct PipeableAndBindFirst : Pipeable<F> {
-     public:
+     protected:
       template <typename T>
       struct FnPartial : Pipeable<FnPartial<T>> {
         mutable T stored_arg;
@@ -362,6 +362,7 @@ namespace iter {
         }
       };
 
+     public:
       template <typename T, typename = std::enable_if_t<!is_iterable<T>>>
       FnPartial<std::decay_t<T>> operator()(T&& t) const {
         return {std::forward<T>(t)};
@@ -374,35 +375,31 @@ namespace iter {
     //  (3) with just a callable, to have the iterable passed later via pipe
     template <template <typename, typename> class ItImpl, typename DefaultT>
     struct IterToolFnOptionalBindFirst
-        : Pipeable<IterToolFnOptionalBindFirst<ItImpl, DefaultT>> {
-     public:
-      template <typename T, typename Container>
-      ItImpl<T, Container> operator()(T func, Container&& container) const {
-        return {std::move(func), std::forward<Container>(container)};
+        : PipeableAndBindFirst<IterToolFnOptionalBindFirst<ItImpl, DefaultT>> {
+    private:
+      using Base = PipeableAndBindFirst<IterToolFnOptionalBindFirst<ItImpl, DefaultT>>;
+     protected:
+      template <typename Container>
+      auto operator()(Container&& container, std::false_type) const {
+        return static_cast<const Base&>(*this)(std::forward<Container>(container));
       }
 
-      template <typename Container,
-          typename = std::enable_if_t<is_iterable<Container>>>
-      auto operator()(Container&& container) const {
+      template <typename Container>
+      auto operator()(Container&& container, std::true_type) const {
         return (*this)(DefaultT{}, std::forward<Container>(container));
       }
 
+     public:
       template <typename T>
-      struct FnPartial : Pipeable<FnPartial<T>> {
-        mutable T stored_arg;
-        constexpr FnPartial(T in_t) : stored_arg(in_t) {}
-
-        template <typename Container>
-        auto operator()(Container&& container) const {
-          return IterToolFnOptionalBindFirst{}(
-              stored_arg, std::forward<Container>(container));
-        }
-      };
+      auto operator()(T&& t) const {
+        return (*this)(std::forward<T>(t), IsIterable<T>{});
+      }
 
-      template <typename T, typename = std::enable_if_t<!is_iterable<T>>>
-      FnPartial<std::decay_t<T>> operator()(T&& t) const {
-        return {std::forward<T>(t)};
+      template <typename T, typename Container, typename = std::enable_if_t<is_iterable<Container>>>
+      ItImpl<T, Container> operator()(T func, Container&& container) const {
+        return {std::move(func), std::forward<Container>(container)};
       }
+
     };
 
     template <template <typename, typename> class ItImpl, typename DefaultT>

From 5d6d33db7af0c55102dd3898f1e09ad53f578c78 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 23 Apr 2016 19:43:14 -0700
Subject: [PATCH 1449/1866] Adds template for itertools taking a size_t arg.

Anything that takes a mandatory size_t as its second argument.
---
 internal/iterbase.hpp | 40 +++++++++++++++++++++++++++++++++++-----
 1 file changed, 35 insertions(+), 5 deletions(-)

diff --git a/internal/iterbase.hpp b/internal/iterbase.hpp
index a052302e..aa6d6a2c 100644
--- a/internal/iterbase.hpp
+++ b/internal/iterbase.hpp
@@ -376,12 +376,15 @@ namespace iter {
     template <template <typename, typename> class ItImpl, typename DefaultT>
     struct IterToolFnOptionalBindFirst
         : PipeableAndBindFirst<IterToolFnOptionalBindFirst<ItImpl, DefaultT>> {
-    private:
-      using Base = PipeableAndBindFirst<IterToolFnOptionalBindFirst<ItImpl, DefaultT>>;
+     private:
+      using Base =
+          PipeableAndBindFirst<IterToolFnOptionalBindFirst<ItImpl, DefaultT>>;
+
      protected:
       template <typename Container>
       auto operator()(Container&& container, std::false_type) const {
-        return static_cast<const Base&>(*this)(std::forward<Container>(container));
+        return static_cast<const Base&> (*this)(
+            std::forward<Container>(container));
       }
 
       template <typename Container>
@@ -395,11 +398,11 @@ namespace iter {
         return (*this)(std::forward<T>(t), IsIterable<T>{});
       }
 
-      template <typename T, typename Container, typename = std::enable_if_t<is_iterable<Container>>>
+      template <typename T, typename Container,
+          typename = std::enable_if_t<is_iterable<Container>>>
       ItImpl<T, Container> operator()(T func, Container&& container) const {
         return {std::move(func), std::forward<Container>(container)};
       }
-
     };
 
     template <template <typename, typename> class ItImpl, typename DefaultT>
@@ -436,6 +439,33 @@ namespace iter {
         return (*this)(std::forward<Container>(container), DefaultT{});
       }
     };
+
+    template <template <typename> class ItImpl>
+    struct IterToolFnBindSizeTSecond {  // NOTE not pipeable
+     private:
+      using Size = std::size_t;
+      struct FnPartial : Pipeable<FnPartial> {
+        Size sz{};
+        constexpr FnPartial(Size in_sz) : sz{in_sz} {}
+
+        template <typename Container>
+        auto operator()(Container&& container) const {
+          return IterToolFnBindSizeTSecond{}(
+              std::forward<Container>(container), sz);
+        }
+      };
+
+     public:
+      FnPartial operator()(Size sz) const {
+        return {sz};
+      }
+
+      template <typename Container,
+          typename = std::enable_if_t<is_iterable<Container>>>
+      ItImpl<Container> operator()(Container&& container, Size sz) const {
+        return {std::forward<Container>(container), sz};
+      }
+    };
   }
 }
 

From 6f5248885ebe9a381e89b8e7d7512cab2bb9d085 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 23 Apr 2016 19:45:54 -0700
Subject: [PATCH 1450/1866] Tests combinations with pipe

---
 test/test_combinations.cpp | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/test/test_combinations.cpp b/test/test_combinations.cpp
index 5ce91e6e..2b994a75 100644
--- a/test/test_combinations.cpp
+++ b/test/test_combinations.cpp
@@ -19,8 +19,15 @@ using CharCombSet = std::vector<std::vector<char>>;
 TEST_CASE("combinations: Simple combination of 4", "[combinations]") {
   std::string s{"ABCD"};
   CharCombSet sc;
-  for (auto v : combinations(s, 2)) {
-    sc.emplace_back(std::begin(v), std::end(v));
+  SECTION("Normal call") {
+    for (auto&& v : combinations(s, 2)) {
+      sc.emplace_back(std::begin(v), std::end(v));
+    }
+  }
+  SECTION("Pipe") {
+    for (auto&& v : s | combinations(2)) {
+      sc.emplace_back(std::begin(v), std::end(v));
+    }
   }
 
   CharCombSet ans = {

From 8effde46a28b9759dcc38a8870e8828add9194d4 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 23 Apr 2016 19:48:39 -0700
Subject: [PATCH 1451/1866] Uses CombinationsFn

---
 combinations.hpp | 15 ++++-----------
 1 file changed, 4 insertions(+), 11 deletions(-)

diff --git a/combinations.hpp b/combinations.hpp
index 49424a24..d90e21c6 100644
--- a/combinations.hpp
+++ b/combinations.hpp
@@ -12,11 +12,10 @@ namespace iter {
   namespace impl {
     template <typename Container>
     class Combinator;
-  }
-
-  template <typename Container>
-  impl::Combinator<Container> combinations(Container&&, std::size_t);
 
+    using CombinationsFn = IterToolFnBindSizeTSecond<Combinator>;
+  }
+  constexpr impl::CombinationsFn combinations{};
 }
 
 template <typename Container>
@@ -25,7 +24,7 @@ class iter::impl::Combinator {
   Container container;
   std::size_t length;
 
-  friend Combinator iter::combinations<Container>(Container&&, std::size_t);
+  friend CombinationsFn;
 
   Combinator(Container&& in_container, std::size_t in_length)
       : container(std::forward<Container>(in_container)), length{in_length} {}
@@ -129,10 +128,4 @@ class iter::impl::Combinator {
   }
 };
 
-template <typename Container>
-iter::impl::Combinator<Container> iter::combinations(
-    Container&& container, std::size_t length) {
-  return {std::forward<Container>(container), length};
-}
-
 #endif

From b0dec5e5a4eed44d34067cc14ca9d169213ecb89 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 23 Apr 2016 19:48:55 -0700
Subject: [PATCH 1452/1866] Tests comb_w_repl with pipe

---
 test/test_combinations_with_replacement.cpp | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/test/test_combinations_with_replacement.cpp b/test/test_combinations_with_replacement.cpp
index 5f0fc4ef..9db79414 100644
--- a/test/test_combinations_with_replacement.cpp
+++ b/test/test_combinations_with_replacement.cpp
@@ -16,8 +16,15 @@ TEST_CASE("combinations_with_replacement: Simple combination",
     "[combinations_with_replacement]") {
   std::string s{"ABC"};
   CharCombSet sc;
-  for (auto v : combinations_with_replacement(s, 2)) {
-    sc.emplace_back(std::begin(v), std::end(v));
+  SECTION("Normal call") {
+    for (auto v : combinations_with_replacement(s, 2)) {
+      sc.emplace_back(std::begin(v), std::end(v));
+    }
+  }
+  SECTION("Pipe") {
+    for (auto v : s | combinations_with_replacement(2)) {
+      sc.emplace_back(std::begin(v), std::end(v));
+    }
   }
   CharCombSet ans = {
       {'A', 'A'}, {'A', 'B'}, {'A', 'C'}, {'B', 'B'}, {'B', 'C'}, {'C', 'C'}};

From 9b427d24eb8fa839d017cd6e02a89d5bde5eb1da Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 23 Apr 2016 19:49:33 -0700
Subject: [PATCH 1453/1866] Uses CombinationsWithReplacementFn

---
 combinations_with_replacement.hpp | 17 ++++-------------
 1 file changed, 4 insertions(+), 13 deletions(-)

diff --git a/combinations_with_replacement.hpp b/combinations_with_replacement.hpp
index b417d960..cfc04957 100644
--- a/combinations_with_replacement.hpp
+++ b/combinations_with_replacement.hpp
@@ -12,12 +12,10 @@ namespace iter {
   namespace impl {
     template <typename Container>
     class CombinatorWithReplacement;
+    using CombinationsWithReplacementFn =
+        IterToolFnBindSizeTSecond<CombinatorWithReplacement>;
   }
-
-  template <typename Container>
-  impl::CombinatorWithReplacement<Container> combinations_with_replacement(
-      Container&&, std::size_t);
-
+  constexpr impl::CombinationsWithReplacementFn combinations_with_replacement{};
 }
 
 template <typename Container>
@@ -26,8 +24,7 @@ class iter::impl::CombinatorWithReplacement {
   Container container;
   std::size_t length;
 
-  friend CombinatorWithReplacement
-  iter::combinations_with_replacement<Container>(Container&&, std::size_t);
+  friend CombinationsWithReplacementFn;
 
   CombinatorWithReplacement(Container&& in_container, std::size_t n)
       : container(std::forward<Container>(in_container)), length{n} {}
@@ -110,10 +107,4 @@ class iter::impl::CombinatorWithReplacement {
   }
 };
 
-template <typename Container>
-iter::impl::CombinatorWithReplacement<Container>
-iter::combinations_with_replacement(Container&& container, std::size_t length) {
-  return {std::forward<Container>(container), length};
-}
-
 #endif

From 61c6efdb0b70784fc9b614d642035c329b34baad Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 23 Apr 2016 20:02:02 -0700
Subject: [PATCH 1454/1866] Tests chunked with pipe

---
 test/test_chunked.cpp | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/test/test_chunked.cpp b/test/test_chunked.cpp
index 16c948ed..2bca55f4 100644
--- a/test/test_chunked.cpp
+++ b/test/test_chunked.cpp
@@ -15,8 +15,15 @@ using ResVec = std::vector<Vec>;
 TEST_CASE("chunked: basic test", "[chunked]") {
   Vec ns = {1, 2, 3, 4, 5, 6};
   ResVec results;
-  for (auto&& g : chunked(ns, 2)) {
-    results.emplace_back(std::begin(g), std::end(g));
+  SECTION("Normal call") {
+    for (auto&& g : chunked(ns, 2)) {
+      results.emplace_back(std::begin(g), std::end(g));
+    }
+  }
+  SECTION("Pipe") {
+    for (auto&& g : ns | chunked(2)) {
+      results.emplace_back(std::begin(g), std::end(g));
+    }
   }
 
   ResVec rc = {{1, 2}, {3, 4}, {5, 6}};

From 97a538ac5b8f2c2e74efb4e2b9a0a0d2513da5d7 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 23 Apr 2016 20:04:51 -0700
Subject: [PATCH 1455/1866] Uses ChunkedFn

---
 chunked.hpp | 15 ++++-----------
 1 file changed, 4 insertions(+), 11 deletions(-)

diff --git a/chunked.hpp b/chunked.hpp
index f642770b..d5676568 100644
--- a/chunked.hpp
+++ b/chunked.hpp
@@ -15,11 +15,10 @@ namespace iter {
   namespace impl {
     template <typename Container>
     class Chunker;
-  }
-
-  template <typename Container>
-  impl::Chunker<Container> chunked(Container&&, std::size_t);
 
+    using ChunkedFn = IterToolFnBindSizeTSecond<Chunker>;
+  }
+  constexpr impl::ChunkedFn chunked{};
 }
 
 template <typename Container>
@@ -31,7 +30,7 @@ class iter::impl::Chunker {
   Chunker(Container&& c, std::size_t sz)
       : container(std::forward<Container>(c)), chunk_size{sz} {}
 
-  friend Chunker iter::chunked<Container>(Container&&, std::size_t);
+  friend ChunkedFn;
 
   using IndexVector = std::vector<iterator_type<Container>>;
   using DerefVec = IterIterWrapper<IndexVector>;
@@ -107,10 +106,4 @@ class iter::impl::Chunker {
   }
 };
 
-template <typename Container>
-iter::impl::Chunker<Container> iter::chunked(
-    Container&& container, std::size_t chunk_size) {
-  return {std::forward<Container>(container), chunk_size};
-}
-
 #endif

From 7cbdb7355033d138c88ea6f30cf9760e068f0fb5 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 23 Apr 2016 20:17:58 -0700
Subject: [PATCH 1456/1866] Tests sliding_window with pipe

---
 test/test_sliding_window.cpp | 33 +++++++++++----------------------
 1 file changed, 11 insertions(+), 22 deletions(-)

diff --git a/test/test_sliding_window.cpp b/test/test_sliding_window.cpp
index d1c8cb18..0cd26a52 100644
--- a/test/test_sliding_window.cpp
+++ b/test/test_sliding_window.cpp
@@ -13,30 +13,19 @@ using Vec = const std::vector<int>;
 
 TEST_CASE("sliding_window: window of size 3", "[sliding_window]") {
   Vec ns = {10, 20, 30, 40, 50};
-  auto sw = sliding_window(ns, 3);
-  auto it = std::begin(sw);
-  REQUIRE(it != std::end(sw));
-  {
-    Vec v(std::begin(*it), std::end(*it));
-    Vec vc = {10, 20, 30};
-    REQUIRE(v == vc);
-  }
-  ++it;
-  REQUIRE(it != std::end(sw));
-  {
-    Vec v(std::begin(*it), std::end(*it));
-    Vec vc = {20, 30, 40};
-    REQUIRE(v == vc);
+  std::vector<std::vector<int>> vc = {{10, 20, 30}, {20, 30, 40}, {30, 40, 50}};
+  std::vector<std::vector<int>> v;
+  SECTION("Normal call") {
+    for (auto&& win : sliding_window(ns, 3)) {
+      v.emplace_back(std::begin(win), std::end(win));
+    }
   }
-  ++it;
-  REQUIRE(it != std::end(sw));
-  {
-    Vec v(std::begin(*it), std::end(*it));
-    Vec vc = {30, 40, 50};
-    REQUIRE(v == vc);
+  SECTION("Pipe") {
+    for (auto&& win : ns | sliding_window(3)) {
+      v.emplace_back(std::begin(win), std::end(win));
+    }
   }
-  ++it;
-  REQUIRE(it == std::end(sw));
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("sliding window: oversized window is empty", "[sliding_window]") {

From 8f851c62e2f62819cd3e02c429f25b33895b7f0f Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 23 Apr 2016 20:19:27 -0700
Subject: [PATCH 1457/1866] Uses SlidingWindowFn

---
 sliding_window.hpp | 15 +++------------
 1 file changed, 3 insertions(+), 12 deletions(-)

diff --git a/sliding_window.hpp b/sliding_window.hpp
index 49364044..9f58334b 100644
--- a/sliding_window.hpp
+++ b/sliding_window.hpp
@@ -12,11 +12,9 @@ namespace iter {
   namespace impl {
     template <typename Container>
     class WindowSlider;
+    using SlidingWindowFn = IterToolFnBindSizeTSecond<WindowSlider>;
   }
-
-  template <typename Container>
-  impl::WindowSlider<Container> sliding_window(Container&&, std::size_t);
-
+  constexpr impl::SlidingWindowFn sliding_window{};
 }
 
 template <typename Container>
@@ -25,8 +23,7 @@ class iter::impl::WindowSlider {
   Container container;
   std::size_t window_size;
 
-  friend WindowSlider iter::sliding_window<Container>(Container&&, std::size_t);
-
+  friend SlidingWindowFn;
 
   WindowSlider(Container&& in_container, std::size_t win_sz)
       : container(std::forward<Container>(in_container)), window_size{win_sz} {}
@@ -97,10 +94,4 @@ class iter::impl::WindowSlider {
   }
 };
 
-template <typename Container>
-iter::impl::WindowSlider<Container> iter::sliding_window(
-    Container&& container, std::size_t window_size) {
-  return {std::forward<Container>(container), window_size};
-}
-
 #endif

From 0e73feac0c0a8b4997ff2e578a8d3788c6ef1358 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 28 Apr 2016 22:34:30 -0700
Subject: [PATCH 1458/1866] Tests chain.from_iterable with pipe.

---
 test/test_chain.cpp | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/test/test_chain.cpp b/test/test_chain.cpp
index 7630270b..f026bfe8 100644
--- a/test/test_chain.cpp
+++ b/test/test_chain.cpp
@@ -158,8 +158,15 @@ TEST_CASE("chain: has correct ctor and assign ops", "[chain]") {
 
 TEST_CASE("chain.from_iterable: basic test", "[chain.from_iterable]") {
   std::vector<std::string> sv{"abc", "xyz"};
-  auto ch = chain.from_iterable(sv);
-  std::vector<char> v(std::begin(ch), std::end(ch));
+  std::vector<char> v;
+  SECTION("Normal call") {
+    auto ch = chain.from_iterable(sv);
+    v.assign(std::begin(ch), std::end(ch));
+  }
+  SECTION("Pipe") {
+    auto ch = sv | chain.from_iterable;
+    v.assign(std::begin(ch), std::end(ch));
+  }
 
   std::vector<char> vc{'a', 'b', 'c', 'x', 'y', 'z'};
   REQUIRE(v == vc);

From eadb4f11d997eefcda401a3756d1df61591165d3 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 28 Apr 2016 22:34:56 -0700
Subject: [PATCH 1459/1866] Uses ChainFromIterableFn

---
 chain.hpp | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/chain.hpp b/chain.hpp
index a4d497c0..38e7eb69 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -18,6 +18,8 @@ namespace iter {
     template <typename Container>
     class ChainedFromIterable;
 
+    using ChainFromIterableFn = IterToolFn<ChainedFromIterable>;
+
     // rather than a chain function, use a callable object to support
     // from_iterable
     class ChainMaker;
@@ -169,8 +171,8 @@ constexpr std::array<typename iter::impl::Chained<TupType, Is...>::NeqFunc,
 template <typename Container>
 class iter::impl::ChainedFromIterable {
  private:
+  friend ChainFromIterableFn;
   Container container;
-  friend ChainMaker;
   ChainedFromIterable(Container&& in_container)
       : container(std::forward<Container>(in_container)) {}
 
@@ -307,11 +309,7 @@ class iter::impl::ChainMaker {
         std::index_sequence_for<Containers...>{});
   }
 
-  // chain.from_iterable
-  template <typename Container>
-  ChainedFromIterable<Container> from_iterable(Container&& container) const {
-    return {std::forward<Container>(container)};
-  }
+  ChainFromIterableFn from_iterable;
 };
 
 namespace iter {

From a4971f935f226913266c1c3c91abe2f6e1ea4312 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 28 Apr 2016 23:11:55 -0700
Subject: [PATCH 1460/1866] tests slice with pipe

---
 test/test_slice.cpp | 39 ++++++++++++++++++++++++++++++---------
 1 file changed, 30 insertions(+), 9 deletions(-)

diff --git a/test/test_slice.cpp b/test/test_slice.cpp
index a94e8a14..1500da6e 100644
--- a/test/test_slice.cpp
+++ b/test/test_slice.cpp
@@ -12,31 +12,52 @@ using Vec = const std::vector<int>;
 
 TEST_CASE("slice: take from beginning", "[slice]") {
   Vec ns = {10, 11, 12, 13, 14, 15, 16, 17, 18, 19};
-  auto sl = slice(ns, 5);
 
-  Vec v(std::begin(sl), std::end(sl));
-  Vec vc = {10, 11, 12, 13, 14};
+  std::vector<int> v;
+  SECTION("Normal call") {
+    auto sl = slice(ns, 5);
+    v.assign(std::begin(sl), std::end(sl));
+  }
+  SECTION("Pipe") {
+    auto sl = ns | slice(5);
+    v.assign(std::begin(sl), std::end(sl));
+  }
 
+  Vec vc = {10, 11, 12, 13, 14};
   REQUIRE(v == vc);
 }
 
 TEST_CASE("slice: start and stop", "[slice]") {
   Vec ns = {10, 11, 12, 13, 14, 15, 16, 17, 18, 19};
-  auto sl = slice(ns, 2, 6);
 
-  Vec v(std::begin(sl), std::end(sl));
-  Vec vc = {12, 13, 14, 15};
+  std::vector<int> v;
+  SECTION("Normal call") {
+    auto sl = slice(ns, 2, 6);
+    v.assign(std::begin(sl), std::end(sl));
+  }
+  SECTION("Pipe") {
+    auto sl = ns | slice(2, 6);
+    v.assign(std::begin(sl), std::end(sl));
+  }
 
+  Vec vc = {12, 13, 14, 15};
   REQUIRE(v == vc);
 }
 
 TEST_CASE("slice: start, stop, step", "[slice]") {
   Vec ns = {10, 11, 12, 13, 14, 15, 16, 17, 18, 19};
-  auto sl = slice(ns, 2, 8, 2);
+  std::vector<int> v;
 
-  Vec v(std::begin(sl), std::end(sl));
-  Vec vc = {12, 14, 16};
+  SECTION("Normal call") {
+    auto sl = slice(ns, 2, 8, 2);
+    v.assign(std::begin(sl), std::end(sl));
+  }
+  SECTION("Pipe") {
+    auto sl = ns | slice(2, 8, 2);
+    v.assign(std::begin(sl), std::end(sl));
+  }
 
+  Vec vc = {12, 14, 16};
   REQUIRE(v == vc);
 }
 

From 9fe5d32fa425236ace48f031a203a5d641443a3f Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 28 Apr 2016 23:13:32 -0700
Subject: [PATCH 1461/1866] Uses SliceFn (explicit) to implement all the pipes

---
 slice.hpp | 81 ++++++++++++++++++++++++++++++++++++++-----------------
 1 file changed, 57 insertions(+), 24 deletions(-)

diff --git a/slice.hpp b/slice.hpp
index 53558c67..8ff5a6af 100644
--- a/slice.hpp
+++ b/slice.hpp
@@ -10,15 +10,9 @@ namespace iter {
   namespace impl {
     template <typename Container, typename DifferenceType>
     class Sliced;
-  }
-
-  template <typename Container, typename DifferenceType>
-  impl::Sliced<Container, DifferenceType> slice(Container&& container,
-      DifferenceType start, DifferenceType stop, DifferenceType step = 1);
 
-  template <typename Container, typename DifferenceType>
-  impl::Sliced<Container, DifferenceType> slice(
-      Container&& container, DifferenceType stop);
+    struct SliceFn;
+  }
 }
 
 template <typename Container, typename DifferenceType>
@@ -29,11 +23,7 @@ class iter::impl::Sliced {
   DifferenceType stop;
   DifferenceType step;
 
-  friend Sliced iter::slice<Container, DifferenceType>(
-      Container&&, DifferenceType, DifferenceType, DifferenceType);
-
-  friend Sliced iter::slice<Container, DifferenceType>(
-      Container&&, DifferenceType);
+  friend SliceFn;
 
   Sliced(Container&& in_container, DifferenceType in_start,
       DifferenceType in_stop, DifferenceType in_step)
@@ -107,18 +97,61 @@ class iter::impl::Sliced {
   }
 };
 
-// Helper function to instantiate a Sliced
-template <typename Container, typename DifferenceType>
-iter::impl::Sliced<Container, DifferenceType> iter::slice(Container&& container,
-    DifferenceType start, DifferenceType stop, DifferenceType step) {
-  return {std::forward<Container>(container), start, stop, step};
-}
+struct iter::impl::SliceFn {
+ private:
+  template <typename DifferenceType>
+  class FnPartial : public Pipeable<FnPartial<DifferenceType>> {
+   public:
+    template <typename Container>
+    Sliced<Container, DifferenceType> operator()(Container&& container) const {
+      return {std::forward<Container>(container), start, stop, step};
+    }
 
-// only give the end as an arg and assume step  is 1 and begin is 0
-template <typename Container, typename DifferenceType>
-iter::impl::Sliced<Container, DifferenceType> iter::slice(
-    Container&& container, DifferenceType stop) {
-  return {std::forward<Container>(container), 0, stop, 1};
+   private:
+    friend SliceFn;
+    constexpr FnPartial(DifferenceType in_start, DifferenceType in_stop,
+        DifferenceType in_step) noexcept : start{in_start},
+                                           stop{in_stop},
+                                           step{in_step} {}
+    DifferenceType start;
+    DifferenceType stop;
+    DifferenceType step;
+  };
+
+ public:
+  template <typename Container, typename DifferenceType,
+      typename = std::enable_if_t<is_iterable<Container>>>
+  Sliced<Container, DifferenceType> operator()(Container&& container,
+      DifferenceType start, DifferenceType stop,
+      DifferenceType step = 1) const {
+    return {std::forward<Container>(container), start, stop, step};
+  }
+
+  // only given the end, assume step is 1 and begin is 0
+  template <typename Container, typename DifferenceType,
+      typename = std::enable_if_t<is_iterable<Container>>>
+  iter::impl::Sliced<Container, DifferenceType> operator()(
+      Container&& container, DifferenceType stop) const {
+    return {std::forward<Container>(container), 0, stop, 1};
+  }
+
+  template <typename DifferenceType,
+      typename = std::enable_if_t<!is_iterable<DifferenceType>>>
+  constexpr FnPartial<DifferenceType> operator()(DifferenceType stop) const
+      noexcept {
+    return {0, stop, 1};
+  }
+
+  template <typename DifferenceType,
+      typename = std::enable_if_t<!is_iterable<DifferenceType>>>
+  constexpr FnPartial<DifferenceType> operator()(DifferenceType start,
+      DifferenceType stop, DifferenceType step = 1) const noexcept {
+    return {start, stop, step};
+  }
+};
+
+namespace iter {
+  constexpr impl::SliceFn slice{};
 }
 
 #endif

From 6ac9173d6099957fdb921bb2aeecfa3e1ac972e0 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 16 Sep 2016 23:36:32 -0700
Subject: [PATCH 1462/1866] Describes pipe in readme

---
 README.md | 44 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)

diff --git a/README.md b/README.md
index dd55604e..0f7d2d0a 100644
--- a/README.md
+++ b/README.md
@@ -113,6 +113,50 @@ from `zip` must be moved into the `enumerate` object. As a more specific
 result, itertools can be mixed and nested.
 
 
+
+#### Pipe syntax
+Wherever it makes sense I've implemented the "pipe" operator that has become
+common in similar libraries. When the syntax is available it is done by pulling
+out the iterable from the call and placing it before the tool. For example:
+
+```c++
+filter(pred, seq);  // regular call
+seq | filter(pred);  // pipe-style
+enumerate(seq);  // regular call
+seq | enumerate;  // pipe-style.
+```
+
+The following tools support pipe. The remaining I left out because although
+some of them have multiple reasonable versions, it wasn't obvious to me how I
+would expect them to behave:
+
+- accumulate
+- chain.from\_iterable
+- chunked
+- combinations
+- combinations\_with\_replacement
+- cycle
+- dropwhile
+- enumerate
+- filter
+- filterfalse
+- groupby
+- imap
+- permutations
+- powerset
+- reversed
+- slice
+- sliding\_window
+- sorted
+- starmap
+- takewhile
+- unique\_everseen
+- unique\_justseen
+
+I don't personally care for the piping style, but it seemed to be desired by
+the users.
+
+
 range
 -----
 

From 278480496de9835d6450bc94c4abdde1f7b2cd0c Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 16 Sep 2016 23:36:45 -0700
Subject: [PATCH 1463/1866] Mixes some pipes

---
 test/test_mixed.cpp | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/test/test_mixed.cpp b/test/test_mixed.cpp
index fae47b27..cc607e64 100644
--- a/test/test_mixed.cpp
+++ b/test/test_mixed.cpp
@@ -126,3 +126,19 @@ TEST_CASE("sorted(chain.from_iterable)", "[sorted][chain.from_iterable]") {
   std::vector<std::vector<int>> v = {{2,4,6}};
   auto s = iter::sorted(iter::chain.from_iterable(v));
 }
+
+TEST_CASE("filter into enumerate with pipe", "[filter][enumerate]") {
+  using iter::imap;
+  using iter::filter;
+  using iter::enumerate;
+
+  std::array<MyUnMovable, 4> arr = {{{41}, {42}, {43}, {44}}};
+  auto seq = arr
+    | filter([](const MyUnMovable& mv) { return mv.get_val() % 2 == 0; })
+    | enumerate
+    | imap([] (const auto& imv) { return std::make_pair(imv.first, imv.second.get_val());});
+  using Vec = std::vector<std::pair<std::size_t, int>>;
+  const Vec v(std::begin(seq), std::end(seq));
+  const Vec vc = {{0, 42}, {1, 44}};
+  REQUIRE(v == vc);
+}

From c178704ad28e642dec9c0cf9f5837317923be252 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 27 Sep 2016 11:03:00 -0700
Subject: [PATCH 1464/1866] update readme for c++14

---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 0f7d2d0a..498da157 100644
--- a/README.md
+++ b/README.md
@@ -657,8 +657,8 @@ for (auto&& i : chain.from_iterable(matrix)) {
 
 reversed
 -------
-*Additional Requirements*: Input must have `.rbegin()` and `.rend()`, or be
-a plain C array.
+*Additional Requirements*: Input must be compatible with `std::rbegin()` and
+`std::rend()`
 
 Iterates over elements of a sequence in reverse order.
 

From d410f2f4053d763c7bc307bc2390360e85617b51 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 6 Oct 2016 10:14:10 -0700
Subject: [PATCH 1465/1866] Update README.md

adds twitter handle that I will optimistically use.
---
 README.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/README.md b/README.md
index 498da157..a02a9b50 100644
--- a/README.md
+++ b/README.md
@@ -6,6 +6,8 @@ evaluation wherever possible.
 
 *Note*: Everthing is inside the `iter` namespace.
 
+[@cppitertools on twitter](https://twitter.com/cppitertools)
+
 #### Table of Contents
 [range](#range)<br />
 [enumerate](#enumerate)<br />

From 394cc4debcd037db199551546b6fbc3ea3066722 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 7 Oct 2016 10:50:41 -0700
Subject: [PATCH 1466/1866] follow me XD

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index a02a9b50..a740372d 100644
--- a/README.md
+++ b/README.md
@@ -6,7 +6,7 @@ evaluation wherever possible.
 
 *Note*: Everthing is inside the `iter` namespace.
 
-[@cppitertools on twitter](https://twitter.com/cppitertools)
+Follow [@cppitertools](https://twitter.com/cppitertools) for updates.
 
 #### Table of Contents
 [range](#range)<br />

From 57b7fa038567a08c740b6997746080eea9c31025 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 29 Oct 2016 00:03:13 -0700
Subject: [PATCH 1467/1866] Adds test for "base_iterator"

---
 test/test_base_iterator.cpp | 190 ++++++++++++++++++++++++++++++++++++
 1 file changed, 190 insertions(+)
 create mode 100644 test/test_base_iterator.cpp

diff --git a/test/test_base_iterator.cpp b/test/test_base_iterator.cpp
new file mode 100644
index 00000000..8f323392
--- /dev/null
+++ b/test/test_base_iterator.cpp
@@ -0,0 +1,190 @@
+// NOTE this header tests implementation details
+
+#include "internal/base_iterator.hpp"
+#include "catch.hpp"
+
+
+// I'm using a std::vector of 1 int instead of just an int in order to give
+// the iterator types non-trivial constructors, destructors, and assignment.
+
+// same begin() and end() types
+struct SameTypes {
+  struct iterator {
+    iterator(int) : value_(1) { }
+
+    bool operator!=(const iterator& other) const { return value_ != other.value_; }
+    iterator& operator++() { ++value_.front(); return *this; }
+    const int& operator*() const { return value_.front(); }
+    std::vector<int> value_; // non-trvial operations
+  };
+
+  iterator begin() const { return {0}; }
+  iterator end() const { return {0}; }
+};
+
+
+// different begin() and end() types
+struct DifferentTypes {
+  struct iterator;
+  struct end_iterator;
+  struct iterator {
+    iterator(int i) : value_(1, i) {}
+
+    bool operator!=(const iterator& other) const { return value() != other.value(); }
+    bool operator!=(const end_iterator&) const { return value() != 3; }
+    iterator& operator++() { ++value_.front(); return *this; }
+    const int& operator*() const { return value(); }
+
+    const int& value() const { return value_.front(); }
+    std::vector<int> value_;
+  };
+
+  struct end_iterator {
+    end_iterator(int){}
+
+    bool operator!=(const end_iterator&) const { return false; }
+    bool operator!=(const iterator& other) const { return other.value() != 3; }
+    end_iterator& operator++() { return *this; }
+    const int& operator*() const { assert(false); return value(); }
+
+    const int& value() const { return value_.front(); }
+    std::vector<int> value_{};
+  };
+
+  iterator begin() const { return {0}; }
+  end_iterator end() const { return {0}; }
+};
+
+// Explicit instatiations, which could cause failures if the implementation
+// details of the implementation details change.
+template class iter::impl::BaseIteratorImpl<SameTypes, true>;
+template class iter::impl::BaseIteratorImpl<DifferentTypes, false>;
+
+using iter::impl::BaseIterator;
+
+
+TEST_CASE("ensure test type iterators are totally comparable", "[test_util") {
+  {
+    SameTypes s{};
+    auto it = s.begin();
+    (void)(it != it);
+  }
+
+  {
+    DifferentTypes d{};
+    auto b = d.begin();
+    auto e = d.end();
+    (void)(b != b);
+    (void)(e != e);
+    (void)(b != e);
+    (void)(e != b);
+  }
+}
+
+
+TEST_CASE("Same and different iterator types gets the correct BaseIterator",
+          "[base_iterator]") {
+  REQUIRE((
+        std::is_same<BaseIterator<SameTypes>,
+                     iter::impl::BaseIteratorImpl<SameTypes, true>>{}));
+  REQUIRE((
+        std::is_same<BaseIterator<DifferentTypes>,
+                     iter::impl::BaseIteratorImpl<DifferentTypes, false>>{}));
+}
+
+TEST_CASE("Operations on BaseIterators with SameTypes work",
+    "[base_iterator]") {
+  SameTypes s;
+  BaseIterator<SameTypes> it(s.begin());
+  REQUIRE(it.same_iterator_types);
+  REQUIRE(it.deref() == 0);
+  it.inc();
+  REQUIRE(it.deref() == 1);
+}
+
+TEST_CASE("Operations on BaseIterators with DifferentTypes work",
+    "[base_iterator]") {
+  DifferentTypes d;
+  using BI = BaseIterator<DifferentTypes>;
+  BI it(d.begin());
+  REQUIRE(it.deref() == 0);
+  it.inc();
+  REQUIRE(it.deref() == 1);
+
+  BI it2(d.begin());
+
+  REQUIRE(it.not_equal(it2));
+  REQUIRE(it2.not_equal(it));
+  it2.inc();
+
+  REQUIRE_FALSE(it.not_equal(it2));
+  REQUIRE_FALSE(it2.not_equal(it));
+
+  BI bend(d.end());
+  REQUIRE(it.not_equal(bend));
+  REQUIRE(bend.not_equal(it));
+
+  it.inc();
+  it.inc();
+  REQUIRE_FALSE(it.not_equal(bend));
+  REQUIRE_FALSE(bend.not_equal(it));
+}
+
+TEST_CASE("Can copy construct a BaseIterator with SameTypes",
+    "[base_iterator]") {
+  SameTypes s;
+  using BI = BaseIterator<SameTypes>;
+  BI it(s.begin());
+  BI it2(it);
+  REQUIRE_FALSE(it.not_equal(it2));
+  it2.inc();
+  REQUIRE(it.not_equal(it2));
+}
+
+
+TEST_CASE("Can copy assign a BaseIterator with SameTypes", "[base_iterator]") {
+  SameTypes s;
+  using BI = BaseIterator<SameTypes>;
+  BI it(s.begin());
+  BI it2(s.begin());
+  REQUIRE_FALSE(it.not_equal(it2));
+  it2.inc();
+  REQUIRE(it.not_equal(it2));
+  it = it2;
+  REQUIRE_FALSE(it.not_equal(it2));
+}
+
+TEST_CASE("Can copy construct a BaseIterator with DifferentTypes",
+    "[base_iterator]") {
+  using BI = BaseIterator<DifferentTypes>;
+  DifferentTypes d;
+  BI it(d.begin());
+  BI it2(it);
+  REQUIRE_FALSE(it.not_equal(it2));
+  it.inc();
+  REQUIRE(it.not_equal(it2));
+}
+
+TEST_CASE("Can copy construct a BaseIterator with DifferenTypes",
+    "[base_iterator]") {
+  using BI = BaseIterator<DifferentTypes>;
+  DifferentTypes d;
+  BI it(d.begin());
+  BI it2(it);
+  it = it2;
+  // break assignment into a different test
+  REQUIRE_FALSE(it.not_equal(it2));
+  BI it_end(d.end());
+  REQUIRE(it.not_equal(it_end));
+  SECTION("normal = end") {
+    it = it_end;
+    REQUIRE_FALSE(it.not_equal(it_end));
+  }
+  SECTION("end = normal") {
+    it_end = BI{d.begin()};
+    REQUIRE_FALSE(it.not_equal(it_end));
+  }
+}
+  
+
+// TODO test move operations

From 63c7273f9be1c8ce769c09dd2c34f01e22b341e1 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 29 Oct 2016 00:03:27 -0700
Subject: [PATCH 1468/1866] Adds BaseIterator

This is suppose to handle an iterable with different types for begin()
and end(). In the case where they are the same, there should be little,
if any, overhead generally. If they are different, there is some
branching that needs to happen but it doesn't seem too bad.
---
 internal/base_iterator.hpp | 179 +++++++++++++++++++++++++++++++++++++
 1 file changed, 179 insertions(+)
 create mode 100755 internal/base_iterator.hpp

diff --git a/internal/base_iterator.hpp b/internal/base_iterator.hpp
new file mode 100755
index 00000000..a8d9ce9f
--- /dev/null
+++ b/internal/base_iterator.hpp
@@ -0,0 +1,179 @@
+#ifndef ITERTOOLS_BASE_ITERATOR_HPP_
+#define ITERTOOLS_BASE_ITERATOR_HPP_
+
+#include "iterbase.hpp"
+#include <cassert>
+
+namespace iter {
+namespace impl {
+// iterator_end_type<C> is the type of C's end iterator
+template <typename Container>
+using iterator_end_type = decltype(std::end(std::declval<Container&>()));
+
+template <typename Container, bool SameIteratorTypes>
+class BaseIteratorImpl;
+
+template <typename Container>
+using BaseIterator = impl::BaseIteratorImpl<Container,
+      std::is_same<impl::iterator_type<Container>,
+                   impl::iterator_end_type<Container>>{}>;
+}
+}
+
+
+// Container's begin() and end() are the same type.
+template <typename Container>
+class iter::impl::BaseIteratorImpl<Container, true> {
+ private:
+  static_assert(
+      std::is_same<iterator_type<Container>, iterator_end_type<Container>>{},
+      "");
+  using SubIter = iterator_type<Container>;
+
+  SubIter sub_iter_;
+ public:
+  static constexpr bool same_iterator_types = true;
+  BaseIteratorImpl() = default;
+  BaseIteratorImpl(SubIter&& it) : sub_iter_(std::move(it)) { }
+
+  // I'm choosing to use named functions so that they aren't accidentally
+  // used by subclasses
+  bool not_equal(const BaseIteratorImpl& other) const {
+    return sub_iter_ != other.sub_iter_;
+  }
+
+  void inc() {
+    ++sub_iter_;
+  }
+
+  // TODO implement const deref?
+  decltype(auto) deref() {
+    return *sub_iter_;
+  }
+};
+
+template <typename Container>
+class iter::impl::BaseIteratorImpl<Container, false> {
+  private:
+    static_assert(
+        !std::is_same<iterator_type<Container>, iterator_end_type<Container>>{},
+        "");
+
+    using SubIter = iterator_type<Container>;
+    using SubEnd = iterator_end_type<Container>;
+
+    enum class IterState { Normal, End, Uninitialized};
+
+    void destroy_sub() {
+      if (state_ == IterState::Normal) {
+        sub_iter_.~SubIter();
+      } else if (state_ == IterState::End) {
+        sub_end_.~SubEnd();
+      }
+      state_ = IterState::Uninitialized;
+    }
+
+    template <typename T>
+    void copy_or_move_sub_from(T&& other) {
+      if (this == &other) { return; }
+      if (state_ == other.state_) {
+        if (state_ == IterState::Normal) {
+          sub_iter_ = std::forward<T>(other).sub_iter_;
+        } else if (state_ == IterState::End) {
+          sub_end_ = std::forward<T>(other).sub_end_;
+        }
+      } else {
+        // state_s are different, must destroy and reconstruct
+        destroy_sub();
+        if (other.state_ == IterState::Normal) {
+          new (&sub_iter_) SubIter(std::forward<T>(other).sub_iter_);
+        } else if (other.state_ == IterState::End) {
+          new (&sub_end_) SubEnd(std::forward<T>(other).sub_end_);
+        }
+        state_ = other.state_;
+      }
+    }
+
+
+    void copy_sub_from(const BaseIteratorImpl& other) {
+      copy_or_move_sub_from(other);
+    }
+
+    void move_sub_from(BaseIteratorImpl&& other) {
+      copy_or_move_sub_from(std::move(other));
+    }
+
+    // TODO replace with std::variant when C++17 is going strong
+    union {
+      SubIter sub_iter_;
+      SubEnd sub_end_;
+    };
+    IterState state_{IterState::Uninitialized};
+
+  public:
+    BaseIteratorImpl() {}
+
+    BaseIteratorImpl(const BaseIteratorImpl& other) {
+      copy_sub_from(other);
+    }
+
+    BaseIteratorImpl& operator=(const BaseIteratorImpl& other) {
+      copy_sub_from(other);
+      return *this;
+    }
+
+    BaseIteratorImpl(BaseIteratorImpl&& other) {
+      move_sub_from(std::move(other));
+    }
+
+    BaseIteratorImpl& operator=(BaseIteratorImpl&& other) {
+      move_sub_from(std::move(other));
+      return *this;
+    }
+
+    BaseIteratorImpl(SubIter&& it)
+      : sub_iter_{std::move(it)},
+      state_{IterState::Normal} { }
+
+    BaseIteratorImpl(SubEnd&& it)
+      : sub_end_(std::move(it)),
+      state_{IterState::End} { }
+
+    void inc() {
+      assert(state_ == IterState::Normal); // because ++ing the end is UB
+      ++sub_iter_;
+    }
+
+    // TODO implement const deref?
+    decltype(auto) deref() {
+      assert(state_ == IterState::Normal); //because *ing the end is UB
+      return *sub_iter_;
+    }
+
+    bool not_equal(const BaseIteratorImpl& other) const {
+      assert(state_ != IterState::Uninitialized
+          && other.state_ != IterState::Uninitialized);
+      if (state_ == other.state_) {
+        if (state_ == IterState::End) {
+          return sub_end_ != other.sub_end_;
+        } else {
+          return sub_iter_ != other.sub_iter_;
+        }
+      } else {
+        if(state_ == IterState::Normal) { // other is End
+          return sub_iter_ != other.sub_end_;
+        } else { // other is Normal
+          return sub_end_ != other.sub_iter_;
+        }
+      }
+    }
+
+    ~BaseIteratorImpl() {
+      this->destroy_sub();
+    }
+
+};
+
+
+
+#endif

From 31959056bb14cb42126d100f7d5a1569d7bd2059 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 29 Oct 2016 00:11:46 -0700
Subject: [PATCH 1469/1866] Replaces inc/deref/not_equal with ++/*/!=

I originally thought BaseIter would be a base class for the other
iterators, now I'm thinking composition will be better.
---
 internal/base_iterator.hpp  | 14 +++++----
 test/test_base_iterator.cpp | 62 ++++++++++++++++++-------------------
 2 files changed, 39 insertions(+), 37 deletions(-)

diff --git a/internal/base_iterator.hpp b/internal/base_iterator.hpp
index a8d9ce9f..daccaa1e 100755
--- a/internal/base_iterator.hpp
+++ b/internal/base_iterator.hpp
@@ -38,16 +38,17 @@ class iter::impl::BaseIteratorImpl<Container, true> {
 
   // I'm choosing to use named functions so that they aren't accidentally
   // used by subclasses
-  bool not_equal(const BaseIteratorImpl& other) const {
+  bool operator!=(const BaseIteratorImpl& other) const {
     return sub_iter_ != other.sub_iter_;
   }
 
-  void inc() {
+  BaseIteratorImpl& operator++() {
     ++sub_iter_;
+    return *this;
   }
 
   // TODO implement const deref?
-  decltype(auto) deref() {
+  decltype(auto) operator*() {
     return *sub_iter_;
   }
 };
@@ -139,18 +140,19 @@ class iter::impl::BaseIteratorImpl<Container, false> {
       : sub_end_(std::move(it)),
       state_{IterState::End} { }
 
-    void inc() {
+    BaseIteratorImpl& operator++() {
       assert(state_ == IterState::Normal); // because ++ing the end is UB
       ++sub_iter_;
+      return *this;
     }
 
     // TODO implement const deref?
-    decltype(auto) deref() {
+    decltype(auto) operator*() {
       assert(state_ == IterState::Normal); //because *ing the end is UB
       return *sub_iter_;
     }
 
-    bool not_equal(const BaseIteratorImpl& other) const {
+    bool operator!=(const BaseIteratorImpl& other) const {
       assert(state_ != IterState::Uninitialized
           && other.state_ != IterState::Uninitialized);
       if (state_ == other.state_) {
diff --git a/test/test_base_iterator.cpp b/test/test_base_iterator.cpp
index 8f323392..98981415 100644
--- a/test/test_base_iterator.cpp
+++ b/test/test_base_iterator.cpp
@@ -97,9 +97,9 @@ TEST_CASE("Operations on BaseIterators with SameTypes work",
   SameTypes s;
   BaseIterator<SameTypes> it(s.begin());
   REQUIRE(it.same_iterator_types);
-  REQUIRE(it.deref() == 0);
-  it.inc();
-  REQUIRE(it.deref() == 1);
+  REQUIRE(*it == 0);
+  ++it;
+  REQUIRE(*it == 1);
 }
 
 TEST_CASE("Operations on BaseIterators with DifferentTypes work",
@@ -107,27 +107,27 @@ TEST_CASE("Operations on BaseIterators with DifferentTypes work",
   DifferentTypes d;
   using BI = BaseIterator<DifferentTypes>;
   BI it(d.begin());
-  REQUIRE(it.deref() == 0);
-  it.inc();
-  REQUIRE(it.deref() == 1);
+  REQUIRE(*it == 0);
+  ++it;
+  REQUIRE(*it == 1);
 
   BI it2(d.begin());
 
-  REQUIRE(it.not_equal(it2));
-  REQUIRE(it2.not_equal(it));
-  it2.inc();
+  REQUIRE(it != it2);
+  REQUIRE(it2 != it);
+  ++it2;
 
-  REQUIRE_FALSE(it.not_equal(it2));
-  REQUIRE_FALSE(it2.not_equal(it));
+  REQUIRE_FALSE(it != it2);
+  REQUIRE_FALSE(it2 != it);
 
   BI bend(d.end());
-  REQUIRE(it.not_equal(bend));
-  REQUIRE(bend.not_equal(it));
+  REQUIRE(it != bend);
+  REQUIRE(bend != it);
 
-  it.inc();
-  it.inc();
-  REQUIRE_FALSE(it.not_equal(bend));
-  REQUIRE_FALSE(bend.not_equal(it));
+  ++it;
+  ++it;
+  REQUIRE_FALSE(it != bend);
+  REQUIRE_FALSE(bend != it);
 }
 
 TEST_CASE("Can copy construct a BaseIterator with SameTypes",
@@ -136,9 +136,9 @@ TEST_CASE("Can copy construct a BaseIterator with SameTypes",
   using BI = BaseIterator<SameTypes>;
   BI it(s.begin());
   BI it2(it);
-  REQUIRE_FALSE(it.not_equal(it2));
-  it2.inc();
-  REQUIRE(it.not_equal(it2));
+  REQUIRE_FALSE(it != it2);
+  ++it2;
+  REQUIRE(it != it2);
 }
 
 
@@ -147,11 +147,11 @@ TEST_CASE("Can copy assign a BaseIterator with SameTypes", "[base_iterator]") {
   using BI = BaseIterator<SameTypes>;
   BI it(s.begin());
   BI it2(s.begin());
-  REQUIRE_FALSE(it.not_equal(it2));
-  it2.inc();
-  REQUIRE(it.not_equal(it2));
+  REQUIRE_FALSE(it != it2);
+  ++it2;
+  REQUIRE(it != it2);
   it = it2;
-  REQUIRE_FALSE(it.not_equal(it2));
+  REQUIRE_FALSE(it != it2);
 }
 
 TEST_CASE("Can copy construct a BaseIterator with DifferentTypes",
@@ -160,9 +160,9 @@ TEST_CASE("Can copy construct a BaseIterator with DifferentTypes",
   DifferentTypes d;
   BI it(d.begin());
   BI it2(it);
-  REQUIRE_FALSE(it.not_equal(it2));
-  it.inc();
-  REQUIRE(it.not_equal(it2));
+  REQUIRE_FALSE(it != it2);
+  ++it;
+  REQUIRE(it != it2);
 }
 
 TEST_CASE("Can copy construct a BaseIterator with DifferenTypes",
@@ -173,16 +173,16 @@ TEST_CASE("Can copy construct a BaseIterator with DifferenTypes",
   BI it2(it);
   it = it2;
   // break assignment into a different test
-  REQUIRE_FALSE(it.not_equal(it2));
+  REQUIRE_FALSE(it != it2);
   BI it_end(d.end());
-  REQUIRE(it.not_equal(it_end));
+  REQUIRE(it != it_end);
   SECTION("normal = end") {
     it = it_end;
-    REQUIRE_FALSE(it.not_equal(it_end));
+    REQUIRE_FALSE(it != it_end);
   }
   SECTION("end = normal") {
     it_end = BI{d.begin()};
-    REQUIRE_FALSE(it.not_equal(it_end));
+    REQUIRE_FALSE(it != it_end);
   }
 }
   

From a712dc6b1472e3c6ffea6c47e8778c117d03c653 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 29 Oct 2016 00:28:33 -0700
Subject: [PATCH 1470/1866] If begin() and end() are the same, no wrapping.

Rather than a thin wrapper around whatever the iterator type is, an
extra layer jammed in the middle can make it actually directly use that
iterator type rather than wrapping it in a way that only really serves
to limit it.
---
 internal/base_iterator.hpp  | 54 +++++++++++++------------------------
 test/test_base_iterator.cpp | 20 +++++---------
 2 files changed, 25 insertions(+), 49 deletions(-)

diff --git a/internal/base_iterator.hpp b/internal/base_iterator.hpp
index daccaa1e..b46b27ed 100755
--- a/internal/base_iterator.hpp
+++ b/internal/base_iterator.hpp
@@ -10,51 +10,33 @@ namespace impl {
 template <typename Container>
 using iterator_end_type = decltype(std::end(std::declval<Container&>()));
 
-template <typename Container, bool SameIteratorTypes>
+template <typename Container>
 class BaseIteratorImpl;
 
+
+// If begin and end return the same type, type will be iterator_type<Container>
+// If begin and end return different types, type will be BaseIteratorImpl
+template <typename Container, bool same_types>
+struct BaseIteratorImplType;
+
+template <typename Container>
+struct BaseIteratorImplType<Container, true>
+: type_is<iterator_type<Container>>{};
+
 template <typename Container>
-using BaseIterator = impl::BaseIteratorImpl<Container,
+struct BaseIteratorImplType<Container, false>
+: type_is<BaseIteratorImpl<Container>>{};
+
+template <typename Container>
+using BaseIterator = typename BaseIteratorImplType<Container,
       std::is_same<impl::iterator_type<Container>,
-                   impl::iterator_end_type<Container>>{}>;
+                   impl::iterator_end_type<Container>>{}>::type;
 }
 }
 
 
-// Container's begin() and end() are the same type.
-template <typename Container>
-class iter::impl::BaseIteratorImpl<Container, true> {
- private:
-  static_assert(
-      std::is_same<iterator_type<Container>, iterator_end_type<Container>>{},
-      "");
-  using SubIter = iterator_type<Container>;
-
-  SubIter sub_iter_;
- public:
-  static constexpr bool same_iterator_types = true;
-  BaseIteratorImpl() = default;
-  BaseIteratorImpl(SubIter&& it) : sub_iter_(std::move(it)) { }
-
-  // I'm choosing to use named functions so that they aren't accidentally
-  // used by subclasses
-  bool operator!=(const BaseIteratorImpl& other) const {
-    return sub_iter_ != other.sub_iter_;
-  }
-
-  BaseIteratorImpl& operator++() {
-    ++sub_iter_;
-    return *this;
-  }
-
-  // TODO implement const deref?
-  decltype(auto) operator*() {
-    return *sub_iter_;
-  }
-};
-
 template <typename Container>
-class iter::impl::BaseIteratorImpl<Container, false> {
+class iter::impl::BaseIteratorImpl {
   private:
     static_assert(
         !std::is_same<iterator_type<Container>, iterator_end_type<Container>>{},
diff --git a/test/test_base_iterator.cpp b/test/test_base_iterator.cpp
index 98981415..db2062f0 100644
--- a/test/test_base_iterator.cpp
+++ b/test/test_base_iterator.cpp
@@ -57,8 +57,7 @@ struct DifferentTypes {
 
 // Explicit instatiations, which could cause failures if the implementation
 // details of the implementation details change.
-template class iter::impl::BaseIteratorImpl<SameTypes, true>;
-template class iter::impl::BaseIteratorImpl<DifferentTypes, false>;
+template class iter::impl::BaseIteratorImpl<DifferentTypes>;
 
 using iter::impl::BaseIterator;
 
@@ -82,21 +81,13 @@ TEST_CASE("ensure test type iterators are totally comparable", "[test_util") {
 }
 
 
-TEST_CASE("Same and different iterator types gets the correct BaseIterator",
-          "[base_iterator]") {
-  REQUIRE((
-        std::is_same<BaseIterator<SameTypes>,
-                     iter::impl::BaseIteratorImpl<SameTypes, true>>{}));
-  REQUIRE((
-        std::is_same<BaseIterator<DifferentTypes>,
-                     iter::impl::BaseIteratorImpl<DifferentTypes, false>>{}));
-}
-
 TEST_CASE("Operations on BaseIterators with SameTypes work",
     "[base_iterator]") {
   SameTypes s;
   BaseIterator<SameTypes> it(s.begin());
-  REQUIRE(it.same_iterator_types);
+  REQUIRE((std::is_same<
+        std::decay_t<decltype(it)>,
+        std::decay_t<decltype(s.begin())>>{}));
   REQUIRE(*it == 0);
   ++it;
   REQUIRE(*it == 1);
@@ -107,6 +98,9 @@ TEST_CASE("Operations on BaseIterators with DifferentTypes work",
   DifferentTypes d;
   using BI = BaseIterator<DifferentTypes>;
   BI it(d.begin());
+  REQUIRE((!std::is_same<
+        std::decay_t<decltype(it)>,
+        std::decay_t<decltype(d.begin())>>{}));
   REQUIRE(*it == 0);
   ++it;
   REQUIRE(*it == 1);

From 508f44cce832a91e6cfcb8769b97c20120fe3059 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 19 Feb 2017 13:16:23 -0800
Subject: [PATCH 1471/1866] Renames BaseIterator to IteratorWrapper

Originally wanted BaseIterator to be a base class. The new name is more
honest about what it does.
---
 ...base_iterator.hpp => iterator_wrapper.hpp} | 45 +++++++++----------
 test/SConstruct                               |  1 +
 ...iterator.cpp => test_iterator_wrapper.cpp} | 30 ++++++-------
 3 files changed, 38 insertions(+), 38 deletions(-)
 rename internal/{base_iterator.hpp => iterator_wrapper.hpp} (76%)
 rename test/{test_base_iterator.cpp => test_iterator_wrapper.cpp} (81%)

diff --git a/internal/base_iterator.hpp b/internal/iterator_wrapper.hpp
similarity index 76%
rename from internal/base_iterator.hpp
rename to internal/iterator_wrapper.hpp
index b46b27ed..6d241020 100755
--- a/internal/base_iterator.hpp
+++ b/internal/iterator_wrapper.hpp
@@ -1,5 +1,5 @@
-#ifndef ITERTOOLS_BASE_ITERATOR_HPP_
-#define ITERTOOLS_BASE_ITERATOR_HPP_
+#ifndef ITERTOOLS_ITERATOR_WRAPPER_HPP_
+#define ITERTOOLS_ITERATOR_WRAPPER_HPP_
 
 #include "iterbase.hpp"
 #include <cassert>
@@ -11,24 +11,24 @@ template <typename Container>
 using iterator_end_type = decltype(std::end(std::declval<Container&>()));
 
 template <typename Container>
-class BaseIteratorImpl;
+class IteratorWrapperImpl;
 
 
 // If begin and end return the same type, type will be iterator_type<Container>
-// If begin and end return different types, type will be BaseIteratorImpl
+// If begin and end return different types, type will be IteratorWrapperImpl
 template <typename Container, bool same_types>
-struct BaseIteratorImplType;
+struct IteratorWrapperImplType;
 
 template <typename Container>
-struct BaseIteratorImplType<Container, true>
+struct IteratorWrapperImplType<Container, true>
 : type_is<iterator_type<Container>>{};
 
 template <typename Container>
-struct BaseIteratorImplType<Container, false>
-: type_is<BaseIteratorImpl<Container>>{};
+struct IteratorWrapperImplType<Container, false>
+: type_is<IteratorWrapperImpl<Container>>{};
 
 template <typename Container>
-using BaseIterator = typename BaseIteratorImplType<Container,
+using IteratorWrapper = typename IteratorWrapperImplType<Container,
       std::is_same<impl::iterator_type<Container>,
                    impl::iterator_end_type<Container>>{}>::type;
 }
@@ -36,7 +36,7 @@ using BaseIterator = typename BaseIteratorImplType<Container,
 
 
 template <typename Container>
-class iter::impl::BaseIteratorImpl {
+class iter::impl::IteratorWrapperImpl {
   private:
     static_assert(
         !std::is_same<iterator_type<Container>, iterator_end_type<Container>>{},
@@ -78,11 +78,11 @@ class iter::impl::BaseIteratorImpl {
     }
 
 
-    void copy_sub_from(const BaseIteratorImpl& other) {
+    void copy_sub_from(const IteratorWrapperImpl& other) {
       copy_or_move_sub_from(other);
     }
 
-    void move_sub_from(BaseIteratorImpl&& other) {
+    void move_sub_from(IteratorWrapperImpl&& other) {
       copy_or_move_sub_from(std::move(other));
     }
 
@@ -94,35 +94,35 @@ class iter::impl::BaseIteratorImpl {
     IterState state_{IterState::Uninitialized};
 
   public:
-    BaseIteratorImpl() {}
+    IteratorWrapperImpl() {}
 
-    BaseIteratorImpl(const BaseIteratorImpl& other) {
+    IteratorWrapperImpl(const IteratorWrapperImpl& other) {
       copy_sub_from(other);
     }
 
-    BaseIteratorImpl& operator=(const BaseIteratorImpl& other) {
+    IteratorWrapperImpl& operator=(const IteratorWrapperImpl& other) {
       copy_sub_from(other);
       return *this;
     }
 
-    BaseIteratorImpl(BaseIteratorImpl&& other) {
+    IteratorWrapperImpl(IteratorWrapperImpl&& other) {
       move_sub_from(std::move(other));
     }
 
-    BaseIteratorImpl& operator=(BaseIteratorImpl&& other) {
+    IteratorWrapperImpl& operator=(IteratorWrapperImpl&& other) {
       move_sub_from(std::move(other));
       return *this;
     }
 
-    BaseIteratorImpl(SubIter&& it)
+    IteratorWrapperImpl(SubIter&& it)
       : sub_iter_{std::move(it)},
       state_{IterState::Normal} { }
 
-    BaseIteratorImpl(SubEnd&& it)
+    IteratorWrapperImpl(SubEnd&& it)
       : sub_end_(std::move(it)),
       state_{IterState::End} { }
 
-    BaseIteratorImpl& operator++() {
+    IteratorWrapperImpl& operator++() {
       assert(state_ == IterState::Normal); // because ++ing the end is UB
       ++sub_iter_;
       return *this;
@@ -134,7 +134,7 @@ class iter::impl::BaseIteratorImpl {
       return *sub_iter_;
     }
 
-    bool operator!=(const BaseIteratorImpl& other) const {
+    bool operator!=(const IteratorWrapperImpl& other) const {
       assert(state_ != IterState::Uninitialized
           && other.state_ != IterState::Uninitialized);
       if (state_ == other.state_) {
@@ -152,12 +152,11 @@ class iter::impl::BaseIteratorImpl {
       }
     }
 
-    ~BaseIteratorImpl() {
+    ~IteratorWrapperImpl() {
       this->destroy_sub();
     }
 
 };
 
 
-
 #endif
diff --git a/test/SConstruct b/test/SConstruct
index cbf3cd3c..d2198470 100644
--- a/test/SConstruct
+++ b/test/SConstruct
@@ -43,6 +43,7 @@ progs = Split(
     zip
 
     iteratoriterator
+    iterator_wrapper
     iterbase
     mixed
     helpers
diff --git a/test/test_base_iterator.cpp b/test/test_iterator_wrapper.cpp
similarity index 81%
rename from test/test_base_iterator.cpp
rename to test/test_iterator_wrapper.cpp
index db2062f0..0f0a210b 100644
--- a/test/test_base_iterator.cpp
+++ b/test/test_iterator_wrapper.cpp
@@ -1,6 +1,6 @@
 // NOTE this header tests implementation details
 
-#include "internal/base_iterator.hpp"
+#include "internal/iterator_wrapper.hpp"
 #include "catch.hpp"
 
 
@@ -57,9 +57,9 @@ struct DifferentTypes {
 
 // Explicit instatiations, which could cause failures if the implementation
 // details of the implementation details change.
-template class iter::impl::BaseIteratorImpl<DifferentTypes>;
+template class iter::impl::IteratorWrapperImpl<DifferentTypes>;
 
-using iter::impl::BaseIterator;
+using iter::impl::IteratorWrapper;
 
 
 TEST_CASE("ensure test type iterators are totally comparable", "[test_util") {
@@ -81,10 +81,10 @@ TEST_CASE("ensure test type iterators are totally comparable", "[test_util") {
 }
 
 
-TEST_CASE("Operations on BaseIterators with SameTypes work",
+TEST_CASE("Operations on IteratorWrappers with SameTypes work",
     "[base_iterator]") {
   SameTypes s;
-  BaseIterator<SameTypes> it(s.begin());
+  IteratorWrapper<SameTypes> it(s.begin());
   REQUIRE((std::is_same<
         std::decay_t<decltype(it)>,
         std::decay_t<decltype(s.begin())>>{}));
@@ -93,10 +93,10 @@ TEST_CASE("Operations on BaseIterators with SameTypes work",
   REQUIRE(*it == 1);
 }
 
-TEST_CASE("Operations on BaseIterators with DifferentTypes work",
+TEST_CASE("Operations on IteratorWrappers with DifferentTypes work",
     "[base_iterator]") {
   DifferentTypes d;
-  using BI = BaseIterator<DifferentTypes>;
+  using BI = IteratorWrapper<DifferentTypes>;
   BI it(d.begin());
   REQUIRE((!std::is_same<
         std::decay_t<decltype(it)>,
@@ -124,10 +124,10 @@ TEST_CASE("Operations on BaseIterators with DifferentTypes work",
   REQUIRE_FALSE(bend != it);
 }
 
-TEST_CASE("Can copy construct a BaseIterator with SameTypes",
+TEST_CASE("Can copy construct a IteratorWrapper with SameTypes",
     "[base_iterator]") {
   SameTypes s;
-  using BI = BaseIterator<SameTypes>;
+  using BI = IteratorWrapper<SameTypes>;
   BI it(s.begin());
   BI it2(it);
   REQUIRE_FALSE(it != it2);
@@ -136,9 +136,9 @@ TEST_CASE("Can copy construct a BaseIterator with SameTypes",
 }
 
 
-TEST_CASE("Can copy assign a BaseIterator with SameTypes", "[base_iterator]") {
+TEST_CASE("Can copy assign a IteratorWrapper with SameTypes", "[base_iterator]") {
   SameTypes s;
-  using BI = BaseIterator<SameTypes>;
+  using BI = IteratorWrapper<SameTypes>;
   BI it(s.begin());
   BI it2(s.begin());
   REQUIRE_FALSE(it != it2);
@@ -148,9 +148,9 @@ TEST_CASE("Can copy assign a BaseIterator with SameTypes", "[base_iterator]") {
   REQUIRE_FALSE(it != it2);
 }
 
-TEST_CASE("Can copy construct a BaseIterator with DifferentTypes",
+TEST_CASE("Can copy construct a IteratorWrapper with DifferentTypes",
     "[base_iterator]") {
-  using BI = BaseIterator<DifferentTypes>;
+  using BI = IteratorWrapper<DifferentTypes>;
   DifferentTypes d;
   BI it(d.begin());
   BI it2(it);
@@ -159,9 +159,9 @@ TEST_CASE("Can copy construct a BaseIterator with DifferentTypes",
   REQUIRE(it != it2);
 }
 
-TEST_CASE("Can copy construct a BaseIterator with DifferenTypes",
+TEST_CASE("Can copy construct a IteratorWrapper with DifferenTypes",
     "[base_iterator]") {
-  using BI = BaseIterator<DifferentTypes>;
+  using BI = IteratorWrapper<DifferentTypes>;
   DifferentTypes d;
   BI it(d.begin());
   BI it2(it);

From 24bde75170a23ed046abc33e1363a2cbb6d71127 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 19 Feb 2017 18:45:47 -0800
Subject: [PATCH 1472/1866] Doesn't actually compare end iterators

range-v3 sentinels can't be compared, but if both iterators are of "end"
type, they must (or should?) be equal.
---
 internal/iterator_wrapper.hpp | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/internal/iterator_wrapper.hpp b/internal/iterator_wrapper.hpp
index 6d241020..8b9d050a 100755
--- a/internal/iterator_wrapper.hpp
+++ b/internal/iterator_wrapper.hpp
@@ -139,7 +139,10 @@ class iter::impl::IteratorWrapperImpl {
           && other.state_ != IterState::Uninitialized);
       if (state_ == other.state_) {
         if (state_ == IterState::End) {
-          return sub_end_ != other.sub_end_;
+          // NOTE this used to be return sub_end_ != other.sub_end_;
+          // but rangev3 sentinels aren't comparable
+          // https://github.com/ericniebler/range-v3/issues/564
+          return false;
         } else {
           return sub_iter_ != other.sub_iter_;
         }

From 310a01b8a5f19f2509e33ae485f61fcbde661a47 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 19 Feb 2017 19:05:37 -0800
Subject: [PATCH 1473/1866] IteratorWrapper default constructs SubIter

Instead of leaving uninitialized. This seems more correct, and will make
the eventual switch to std::variant more straight forward.
---
 internal/iterator_wrapper.hpp  | 2 +-
 test/test_iterator_wrapper.cpp | 2 ++
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/internal/iterator_wrapper.hpp b/internal/iterator_wrapper.hpp
index 8b9d050a..a817323c 100755
--- a/internal/iterator_wrapper.hpp
+++ b/internal/iterator_wrapper.hpp
@@ -94,7 +94,7 @@ class iter::impl::IteratorWrapperImpl {
     IterState state_{IterState::Uninitialized};
 
   public:
-    IteratorWrapperImpl() {}
+    IteratorWrapperImpl() : IteratorWrapperImpl(SubIter{}) {}
 
     IteratorWrapperImpl(const IteratorWrapperImpl& other) {
       copy_sub_from(other);
diff --git a/test/test_iterator_wrapper.cpp b/test/test_iterator_wrapper.cpp
index 0f0a210b..b3b99f2d 100644
--- a/test/test_iterator_wrapper.cpp
+++ b/test/test_iterator_wrapper.cpp
@@ -28,6 +28,7 @@ struct DifferentTypes {
   struct iterator;
   struct end_iterator;
   struct iterator {
+    iterator() : value_{} { REQUIRE(false); }
     iterator(int i) : value_(1, i) {}
 
     bool operator!=(const iterator& other) const { return value() != other.value(); }
@@ -40,6 +41,7 @@ struct DifferentTypes {
   };
 
   struct end_iterator {
+    end_iterator() { REQUIRE(false); }
     end_iterator(int){}
 
     bool operator!=(const end_iterator&) const { return false; }

From 99b05d3fc87aa3f073bea8984b02b73805c30734 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 19 Feb 2017 19:45:54 -0800
Subject: [PATCH 1474/1866] Moves iterator tuple aliases into their own header

I want these to use iterator_wrapper.hpp, which includes iterbase.hpp,
gotta resolve the circular dependency.
---
 chain.hpp                |  1 +
 internal/iter_tuples.hpp | 59 ++++++++++++++++++++++++++++++++++++++++
 internal/iterbase.hpp    | 49 ---------------------------------
 zip.hpp                  |  1 +
 zip_longest.hpp          |  1 +
 5 files changed, 62 insertions(+), 49 deletions(-)
 create mode 100644 internal/iter_tuples.hpp

diff --git a/chain.hpp b/chain.hpp
index 38e7eb69..bce306b6 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -2,6 +2,7 @@
 #define ITER_CHAIN_HPP_
 
 #include "internal/iterbase.hpp"
+#include "internal/iter_tuples.hpp"
 
 #include <array>
 #include <iterator>
diff --git a/internal/iter_tuples.hpp b/internal/iter_tuples.hpp
new file mode 100644
index 00000000..a70c3fd2
--- /dev/null
+++ b/internal/iter_tuples.hpp
@@ -0,0 +1,59 @@
+#ifndef ITERTOOLS_ITER_TUPLES_HPP_
+#define ITERTOOLS_ITER_TUPLES_HPP_
+
+#include "iterbase.hpp"
+
+namespace iter {
+  namespace impl {
+    namespace detail {
+      template <typename... Ts>
+      std::tuple<iterator_deref<Ts>...> iterator_tuple_deref_helper(
+          const std::tuple<Ts...>&);
+    }
+
+    namespace detail {
+      template <typename... Ts>
+      std::tuple<iterator_type<Ts>...> iterator_tuple_type_helper(
+          const std::tuple<Ts...>&);
+    }
+    // Given a tuple template argument, evaluates to a tuple of iterators
+    // for the template argument's contained types.
+    template <typename TupleType>
+    using iterator_tuple_type =
+        decltype(detail::iterator_tuple_type_helper(std::declval<TupleType>()));
+
+    // Given a tuple template argument, evaluates to a tuple of
+    // what the iterators for the template argument's contained types
+    // dereference to
+    template <typename TupleType>
+    using iterator_deref_tuple = decltype(
+        detail::iterator_tuple_deref_helper(std::declval<TupleType>()));
+
+    // ---- Tuple utilities ---- //
+
+    // function absorbing all arguments passed to it. used when
+    // applying a function to a parameter pack but not passing the evaluated
+    // results anywhere
+    template <typename... Ts>
+    void absorb(Ts&&...) {}
+
+    namespace detail {
+      template <typename Func, typename TupleType, std::size_t... Is>
+      decltype(auto) call_with_tuple_impl(
+          Func&& mf, TupleType&& tup, std::index_sequence<Is...>) {
+        return mf(std::forward<std::tuple_element_t<Is,
+                std::remove_reference_t<TupleType>>>(std::get<Is>(tup))...);
+      }
+    }
+
+    // expand a TupleType into individual arguments when calling a Func
+    template <typename Func, typename TupleType>
+    decltype(auto) call_with_tuple(Func&& mf, TupleType&& tup) {
+      constexpr auto TUP_SIZE = std::tuple_size<std::decay_t<TupleType>>::value;
+      return detail::call_with_tuple_impl(std::forward<Func>(mf),
+          std::forward<TupleType>(tup), std::make_index_sequence<TUP_SIZE>{});
+    }
+  }
+}
+
+#endif
diff --git a/internal/iterbase.hpp b/internal/iterbase.hpp
index aa6d6a2c..ad547d66 100644
--- a/internal/iterbase.hpp
+++ b/internal/iterbase.hpp
@@ -192,55 +192,6 @@ namespace iter {
         : std::integral_constant<bool,
               std::is_same<T, U>::value && are_same<T, Ts...>::value> {};
 
-    namespace detail {
-      template <typename... Ts>
-      std::tuple<iterator_deref<Ts>...> iterator_tuple_deref_helper(
-          const std::tuple<Ts...>&);
-    }
-
-    namespace detail {
-      template <typename... Ts>
-      std::tuple<iterator_type<Ts>...> iterator_tuple_type_helper(
-          const std::tuple<Ts...>&);
-    }
-    // Given a tuple template argument, evaluates to a tuple of iterators
-    // for the template argument's contained types.
-    template <typename TupleType>
-    using iterator_tuple_type =
-        decltype(detail::iterator_tuple_type_helper(std::declval<TupleType>()));
-
-    // Given a tuple template argument, evaluates to a tuple of
-    // what the iterators for the template argument's contained types
-    // dereference to
-    template <typename TupleType>
-    using iterator_deref_tuple = decltype(
-        detail::iterator_tuple_deref_helper(std::declval<TupleType>()));
-
-    // ---- Tuple utilities ---- //
-
-    // function absorbing all arguments passed to it. used when
-    // applying a function to a parameter pack but not passing the evaluated
-    // results anywhere
-    template <typename... Ts>
-    void absorb(Ts&&...) {}
-
-    namespace detail {
-      template <typename Func, typename TupleType, std::size_t... Is>
-      decltype(auto) call_with_tuple_impl(
-          Func&& mf, TupleType&& tup, std::index_sequence<Is...>) {
-        return mf(std::forward<std::tuple_element_t<Is,
-                std::remove_reference_t<TupleType>>>(std::get<Is>(tup))...);
-      }
-    }
-
-    // expand a TupleType into individual arguments when calling a Func
-    template <typename Func, typename TupleType>
-    decltype(auto) call_with_tuple(Func&& mf, TupleType&& tup) {
-      constexpr auto TUP_SIZE = std::tuple_size<std::decay_t<TupleType>>::value;
-      return detail::call_with_tuple_impl(std::forward<Func>(mf),
-          std::forward<TupleType>(tup), std::make_index_sequence<TUP_SIZE>{});
-    }
-
     // DerefHolder holds the value gotten from an iterator dereference
     // if the iterate dereferences to an lvalue references, a pointer to the
     //     element is stored
diff --git a/zip.hpp b/zip.hpp
index ede3514e..b02c71c5 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -1,6 +1,7 @@
 #ifndef ITER_ZIP_HPP_
 #define ITER_ZIP_HPP_
 
+#include "internal/iter_tuples.hpp"
 #include "internal/iterbase.hpp"
 
 #include <iterator>
diff --git a/zip_longest.hpp b/zip_longest.hpp
index ad4cafab..dfbcf5c1 100644
--- a/zip_longest.hpp
+++ b/zip_longest.hpp
@@ -2,6 +2,7 @@
 #define ITER_ZIP_LONGEST_HPP_
 
 #include "internal/iterbase.hpp"
+#include "internal/iter_tuples.hpp"
 
 #include <boost/optional.hpp>
 #include <iterator>

From dbf3c7e0f6f290ed63b0e8cec5c4393e8981cfae Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 19 Feb 2017 20:38:50 -0800
Subject: [PATCH 1475/1866] Makes dumb_advance handle different end type

---
 internal/iterbase.hpp  | 16 ++++++++--------
 test/test_iterbase.cpp |  2 +-
 2 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/internal/iterbase.hpp b/internal/iterbase.hpp
index ad547d66..9d955a52 100644
--- a/internal/iterbase.hpp
+++ b/internal/iterbase.hpp
@@ -131,23 +131,23 @@ namespace iter {
 
     // version that will work with most things
     template <typename InputIt, typename Distance = std::size_t>
-    void dumb_advance(InputIt& iter, Distance distance = 1) {
+    void dumb_advance_unsafe(InputIt& iter, Distance distance) {
       for (Distance i(0); i < distance; ++i) {
         ++iter;
       }
     }
 
-    template <typename Iter, typename Distance>
+    template <typename Iter, typename EndIter, typename Distance>
     void dumb_advance_impl(
-        Iter& iter, const Iter& end, Distance distance, std::false_type) {
+        Iter& iter, const EndIter& end, Distance distance, std::false_type) {
       for (Distance i(0); i < distance && iter != end; ++i) {
         ++iter;
       }
     }
 
-    template <typename Iter, typename Distance>
+    template <typename Iter, typename EndIter, typename Distance>
     void dumb_advance_impl(
-        Iter& iter, const Iter& end, Distance distance, std::true_type) {
+        Iter& iter, const EndIter& end, Distance distance, std::true_type) {
       if (static_cast<Distance>(end - iter) < distance) {
         iter = end;
       } else {
@@ -156,14 +156,14 @@ namespace iter {
     }
 
     // iter will not be incremented past end
-    template <typename Iter, typename Distance = std::size_t>
-    void dumb_advance(Iter& iter, const Iter& end, Distance distance = 1) {
+    template <typename Iter, typename EndIter, typename Distance = std::size_t>
+    void dumb_advance(Iter& iter, const EndIter& end, Distance distance) {
       dumb_advance_impl(iter, end, distance, is_random_access_iter<Iter>{});
     }
 
     template <typename ForwardIt, typename Distance = std::size_t>
     ForwardIt dumb_next(ForwardIt it, Distance distance = 1) {
-      dumb_advance(it, distance);
+      dumb_advance_unsafe(it, distance);
       return it;
     }
 
diff --git a/test/test_iterbase.cpp b/test/test_iterbase.cpp
index 91671155..a19247da 100644
--- a/test/test_iterbase.cpp
+++ b/test/test_iterbase.cpp
@@ -49,7 +49,7 @@ TEST_CASE("advance, next, size", "[iterbase]") {
   auto itr = std::begin(v);
   REQUIRE(it::apply_arrow(itr) == &v[0]);
 
-  it::dumb_advance(itr, 3);
+  it::dumb_advance_unsafe(itr, 3);
   REQUIRE(itr == (std::begin(v) + 3));
   REQUIRE(it::dumb_next(std::begin(v), 3) == std::begin(v) + 3);
   REQUIRE(it::dumb_size(v) == v.size());

From fa10ace4628a32e9da4ef55bee76a47f3596ee03 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 14:13:44 -0800
Subject: [PATCH 1476/1866] Makes dumb_size handle different end types

---
 internal/iterbase.hpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/internal/iterbase.hpp b/internal/iterbase.hpp
index 9d955a52..8f73cb0d 100644
--- a/internal/iterbase.hpp
+++ b/internal/iterbase.hpp
@@ -177,8 +177,9 @@ namespace iter {
     template <typename Container, typename Distance = std::size_t>
     Distance dumb_size(Container&& container) {
       Distance d{0};
-      for (auto it = std::begin(container), end = std::end(container);
-           it != end; ++it) {
+      auto end_it = std::end(container);
+      for (auto it = std::begin(container);
+           it != end_it; ++it) {
         ++d;
       }
       return d;

From 4a231af2d0f57b8a30a5ff6943d7cad8dc0cfffb Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 14:14:44 -0800
Subject: [PATCH 1477/1866] Adds operators, uses iterators for types

templating the wrapper on iterator types instead of a container makes
this work with reversed()
---
 internal/iterator_wrapper.hpp | 29 +++++++++++++++++++----------
 1 file changed, 19 insertions(+), 10 deletions(-)

diff --git a/internal/iterator_wrapper.hpp b/internal/iterator_wrapper.hpp
index a817323c..1f5e5536 100755
--- a/internal/iterator_wrapper.hpp
+++ b/internal/iterator_wrapper.hpp
@@ -10,7 +10,7 @@ namespace impl {
 template <typename Container>
 using iterator_end_type = decltype(std::end(std::declval<Container&>()));
 
-template <typename Container>
+template <typename SubIter, typename SubEnd>
 class IteratorWrapperImpl;
 
 
@@ -25,7 +25,7 @@ struct IteratorWrapperImplType<Container, true>
 
 template <typename Container>
 struct IteratorWrapperImplType<Container, false>
-: type_is<IteratorWrapperImpl<Container>>{};
+: type_is<IteratorWrapperImpl<iterator_type<Container>, iterator_end_type<Container>>>{};
 
 template <typename Container>
 using IteratorWrapper = typename IteratorWrapperImplType<Container,
@@ -34,17 +34,12 @@ using IteratorWrapper = typename IteratorWrapperImplType<Container,
 }
 }
 
-
-template <typename Container>
+template <typename SubIter, typename SubEnd>
 class iter::impl::IteratorWrapperImpl {
   private:
     static_assert(
-        !std::is_same<iterator_type<Container>, iterator_end_type<Container>>{},
+        !std::is_same<SubIter, SubEnd>{},
         "");
-
-    using SubIter = iterator_type<Container>;
-    using SubEnd = iterator_end_type<Container>;
-
     enum class IterState { Normal, End, Uninitialized};
 
     void destroy_sub() {
@@ -128,12 +123,26 @@ class iter::impl::IteratorWrapperImpl {
       return *this;
     }
 
-    // TODO implement const deref?
     decltype(auto) operator*() {
       assert(state_ == IterState::Normal); //because *ing the end is UB
       return *sub_iter_;
     }
 
+    decltype(auto) operator*() const {
+      assert(state_ == IterState::Normal); //because *ing the end is UB
+      return *sub_iter_;
+    }
+
+    decltype(auto) operator->() {
+      assert(state_ == IterState::Normal);
+      return apply_arrow(sub_iter_);
+    }
+
+    decltype(auto) operator->() const {
+      assert(state_ == IterState::Normal);
+      return apply_arrow(sub_iter_);
+    }
+
     bool operator!=(const IteratorWrapperImpl& other) const {
       assert(state_ != IterState::Uninitialized
           && other.state_ != IterState::Uninitialized);

From 3adcb327d081780df96ea80f2e8ce5448886a730 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 14:15:48 -0800
Subject: [PATCH 1478/1866] Changes iterator tuples to use wrappers

---
 internal/iter_tuples.hpp | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/internal/iter_tuples.hpp b/internal/iter_tuples.hpp
index a70c3fd2..8e68f16e 100644
--- a/internal/iter_tuples.hpp
+++ b/internal/iter_tuples.hpp
@@ -2,6 +2,7 @@
 #define ITERTOOLS_ITER_TUPLES_HPP_
 
 #include "iterbase.hpp"
+#include "iterator_wrapper.hpp"
 
 namespace iter {
   namespace impl {
@@ -13,7 +14,7 @@ namespace iter {
 
     namespace detail {
       template <typename... Ts>
-      std::tuple<iterator_type<Ts>...> iterator_tuple_type_helper(
+      std::tuple<IteratorWrapper<Ts>...> iterator_tuple_type_helper(
           const std::tuple<Ts...>&);
     }
     // Given a tuple template argument, evaluates to a tuple of iterators
@@ -29,8 +30,6 @@ namespace iter {
     using iterator_deref_tuple = decltype(
         detail::iterator_tuple_deref_helper(std::declval<TupleType>()));
 
-    // ---- Tuple utilities ---- //
-
     // function absorbing all arguments passed to it. used when
     // applying a function to a parameter pack but not passing the evaluated
     // results anywhere

From 3dff623ebd5a8476c53862f821873a5b65288cf3 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 14:16:11 -0800
Subject: [PATCH 1479/1866] Adds range types with different begin and end

---
 test/helpers.hpp | 218 ++++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 204 insertions(+), 14 deletions(-)

diff --git a/test/helpers.hpp b/test/helpers.hpp
index d16f3bd4..9cf67fd0 100644
--- a/test/helpers.hpp
+++ b/test/helpers.hpp
@@ -6,6 +6,7 @@
 #include <stdexcept>
 #include <type_traits>
 #include <utility>
+#include <vector>
 
 namespace itertest {
 
@@ -168,7 +169,7 @@ namespace itertest {
 #ifdef DECLARE_REVERSE_ITERATOR
     Iterator rbegin();
     Iterator rend();
-#endif // ifdef DECLARE_REVERSE_ITERATOR
+#endif  // ifdef DECLARE_REVERSE_ITERATOR
   };
 
   using iter::impl::void_t;
@@ -178,19 +179,16 @@ namespace itertest {
 
   template <typename T>
   struct IsIterator<T,
-      void_t<decltype(T(std::declval<const T&>())),  // copyctor
-                        decltype(std::declval<T&>() =
-                                     std::declval<const T&>()),  // copy =
-                        decltype(*std::declval<T&>()),           // operator*
-                        decltype(
-                            std::declval<T&>().operator->()),  // operator->
-                        decltype(++std::declval<T&>()),        // prefix ++
-                        decltype(std::declval<T&>()++),        // postfix ++
-                        decltype(std::declval<const T&>()
-                                 != std::declval<const T&>()),  //  !=
-                        decltype(std::declval<const T&>()
-                                 == std::declval<const T&>())  //  ==
-                        >> : std::true_type {};
+      void_t<decltype(T(std::declval<const T&>())),                 // copyctor
+          decltype(std::declval<T&>() = std::declval<const T&>()),  // copy =
+          decltype(*std::declval<T&>()),                            // operator*
+          decltype(std::declval<T&>().operator->()),  // operator->
+          decltype(++std::declval<T&>()),             // prefix ++
+          decltype(std::declval<T&>()++),             // postfix ++
+          decltype(
+              std::declval<const T&>() != std::declval<const T&>()),      //  !=
+          decltype(std::declval<const T&>() == std::declval<const T&>())  //  ==
+          >> : std::true_type {};
 
   template <typename T>
   struct IsForwardIterator
@@ -205,5 +203,197 @@ namespace itertest {
                 && !std::is_move_assignable<T>::value
                 && std::is_move_constructible<T>::value> {};
 }
+template <typename T, typename Inc>
+class DiffEndRange {
+ private:
+  T start_;
+  T stop_;
+  std::vector<T> all_results_;
+
+ public:
+  constexpr DiffEndRange(T start, T stop) : start_{start}, stop_{stop} {
+    while (start < stop_) {
+      all_results_.push_back(start);
+      Inc{}(start);
+    }
+  }
+
+  class Iterator;
+  class EndIterator;
+
+  class Iterator {
+    using SubIter = typename std::vector<T>::iterator;
+   private:
+    SubIter it_;
+    SubIter end_;
+
+   public:
+#ifdef CHAR_RANGE_DEFAULT_CONSTRUCTIBLE
+    Iterator() = default;
+#endif
+    Iterator(SubIter it, SubIter end_it) : it_{it}, end_{end_it} {}
+
+    T& operator*() const {
+      return *it_;
+    }
+    T* operator->() const {
+      return &*it_;
+    }
+
+    Iterator& operator++() {
+      ++it_;
+      return *this;
+    }
+
+    bool operator!=(const Iterator& other) const {
+      return it_ != other.it_;
+    }
+
+    bool operator!=(const EndIterator&) const {
+      return it_ != end_;
+    }
+
+    friend bool operator!=(const EndIterator& lhs, const Iterator& rhs) {
+      return rhs != lhs;
+    }
+  };
+
+  class ReverseIterator {
+    using SubIter = typename std::vector<T>::reverse_iterator;
+   private:
+    SubIter it_;
+    SubIter end_;
+
+   public:
+#ifdef CHAR_RANGE_DEFAULT_CONSTRUCTIBLE
+    ReverseIterator() = default;
+#endif
+    ReverseIterator(SubIter it, SubIter end_it) : it_{it}, end_{end_it} {}
+
+    T& operator*() const {
+      return *it_;
+    }
+    T* operator->() const {
+      return &*it_;
+    }
+
+    Iterator& operator++() {
+      ++it_;
+      return *this;
+    }
+
+    bool operator!=(const Iterator& other) const {
+      return it_ != other.it_;
+    }
+
+    bool operator!=(const EndIterator&) const {
+      return it_ != end_;
+    }
+
+    friend bool operator!=(const EndIterator& lhs, const Iterator& rhs) {
+      return rhs != lhs;
+    }
+  };
+
+  class EndIterator {};
+  class ReverseEndIterator {};
+
+  Iterator begin() {
+    return {std::begin(all_results_), std::end(all_results_)};
+  }
+
+  EndIterator end() {
+    return {};
+  }
+
+  ReverseIterator rbegin() {
+    return {std::rbegin(all_results_), std::rend(all_results_)};
+  }
+
+  ReverseEndIterator rend() {
+    return {};
+  }
+};
+
+struct CharInc {
+  void operator()(char& c) {
+    ++c;
+  }
+};
+
+// A range from 'a' to stop, begin() and end() are different
+class CharRange : public DiffEndRange<char, CharInc> {
+ public:
+  constexpr CharRange(char stop) : DiffEndRange<char, CharInc>('a', stop) {}
+};
+
+struct IncIntCharPair {
+  void operator()(std::pair<int, char>& p) {
+    ++p.first;
+    ++p.second;
+  }
+};
+
+class IntCharPairRange
+    : public DiffEndRange<std::pair<int, char>, IncIntCharPair> {
+ public:
+  IntCharPairRange(std::pair<int, char> stop)
+      : DiffEndRange<std::pair<int, char>, IncIntCharPair>({0, 'a'}, stop) {}
+};
+
+#if 0
+class CharRange {
+  private:
+    char stop_{};
+
+  public:
+    constexpr CharRange(char stop) : stop_{stop} {}
+
+    class Iterator;
+    class EndIterator;
+
+    class Iterator {
+      private:
+        char stop_{};
+        mutable char value_{'a'};
+      public:
+#ifdef CHAR_RANGE_DEFAULT_CONSTRUCTIBLE
+        Iterator() = default;
+#endif
+        Iterator(char stop) : stop_{stop} {}
+
+        char& operator*() const { return value_; }
+        char* operator->() const { return &value_; }
+
+        Iterator& operator++() {
+          ++value_;
+          return *this;
+        }
+
+        bool operator!=(const Iterator& other) const {
+          return value_ != other.value_;
+        }
+
+        bool operator!=(const EndIterator&) const {
+          return value_ < stop_;
+        }
+
+        friend bool operator!=(const EndIterator& lhs, const Iterator& rhs) {
+          return rhs != lhs;
+        }
+
+    };
+
+    class EndIterator { };
+
+    Iterator begin() {
+      return {stop_};
+    }
+
+    EndIterator end() {
+      return {};
+    }
+};
+#endif
 
 #endif

From 43d6f4aed5743dd1e973dbac058ba4c0e0a9a36b Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 14:17:23 -0800
Subject: [PATCH 1480/1866] tests accumulate with different begin and end

---
 test/test_accumulate.cpp | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/test/test_accumulate.cpp b/test/test_accumulate.cpp
index 7df80628..fdab1913 100644
--- a/test/test_accumulate.cpp
+++ b/test/test_accumulate.cpp
@@ -102,6 +102,16 @@ TEST_CASE("accumulate: iterator meets requirements", "[accumulate]") {
   REQUIRE(itertest::IsIterator<decltype(std::begin(a))>::value);
 }
 
+TEST_CASE("accumulate: Works with different begin and end types",
+    "[accumulate]") {
+  CharRange cr{'d'};
+  auto a = accumulate(cr);
+  Vec v(a.begin(), a.end());
+  Vec vc{'a', 'a' + 'b', 'a' + 'b' + 'c'};
+  REQUIRE(v == vc);
+}
+
+
 template <typename T>
 using ImpT = decltype(accumulate(std::declval<T>()));
 TEST_CASE("accumulate: has correct ctor and assign ops", "[accumulate]") {

From 02d4e8b0bd6e7ad67e495b9b384226ee83f5dc38 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 14:17:38 -0800
Subject: [PATCH 1481/1866] Supports different begin and end in accumulate

---
 accumulate.hpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/accumulate.hpp b/accumulate.hpp
index 3df0fd29..cad5f29c 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -2,6 +2,7 @@
 #define ITER_ACCUMULATE_H_
 
 #include "internal/iterbase.hpp"
+#include "internal/iterator_wrapper.hpp"
 
 #include <utility>
 #include <iterator>
@@ -39,13 +40,13 @@ class iter::impl::Accumulator {
 
   class Iterator : public std::iterator<std::input_iterator_tag, AccumVal> {
    private:
-    iterator_type<Container> sub_iter;
-    iterator_type<Container> sub_end;
+    IteratorWrapper<Container> sub_iter;
+    IteratorWrapper<Container> sub_end;
     AccumulateFunc* accumulate_func;
     std::unique_ptr<AccumVal> acc_val;
 
    public:
-    Iterator(iterator_type<Container>&& iter, iterator_type<Container>&& end,
+    Iterator(IteratorWrapper<Container>&& iter, IteratorWrapper<Container>&& end,
         AccumulateFunc& in_accumulate_fun)
         : sub_iter{std::move(iter)},
           sub_end{std::move(end)},

From d39c02ca02bbe0423a9951550c7f14dce345c3dd Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 14:18:02 -0800
Subject: [PATCH 1482/1866] Tests chain with different begin and end

---
 chain.hpp           |  9 +++++----
 test/test_chain.cpp | 22 ++++++++++++++++++++++
 2 files changed, 27 insertions(+), 4 deletions(-)

diff --git a/chain.hpp b/chain.hpp
index bce306b6..44e6f94f 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -2,6 +2,7 @@
 #define ITER_CHAIN_HPP_
 
 #include "internal/iterbase.hpp"
+#include "internal/iterator_wrapper.hpp"
 #include "internal/iter_tuples.hpp"
 
 #include <array>
@@ -183,10 +184,10 @@ class iter::impl::ChainedFromIterable {
                        iterator_traits_deref<iterator_deref<Container>>> {
    private:
     using SubContainer = iterator_deref<Container>;
-    using SubIter = iterator_type<SubContainer>;
+    using SubIter = IteratorWrapper<SubContainer>;
 
-    iterator_type<Container> top_level_iter;
-    iterator_type<Container> top_level_end;
+    IteratorWrapper<Container> top_level_iter;
+    IteratorWrapper<Container> top_level_end;
     std::unique_ptr<SubIter> sub_iter_p;
     std::unique_ptr<SubIter> sub_end_p;
 
@@ -208,7 +209,7 @@ class iter::impl::ChainedFromIterable {
 
    public:
     Iterator(
-        iterator_type<Container>&& top_iter, iterator_type<Container>&& top_end)
+        IteratorWrapper<Container>&& top_iter, IteratorWrapper<Container>&& top_end)
         : top_level_iter{std::move(top_iter)},
           top_level_end{std::move(top_end)},
           sub_iter_p{!(top_iter != top_end)
diff --git a/test/test_chain.cpp b/test/test_chain.cpp
index f026bfe8..c0c6efb7 100644
--- a/test/test_chain.cpp
+++ b/test/test_chain.cpp
@@ -39,6 +39,19 @@ TEST_CASE("chain: with different container types", "[chain]") {
   REQUIRE(v == vc);
 }
 
+TEST_CASE("chain: where one container has different begin and end types",
+    "[chain]") {
+  std::string s1{"abc"};
+  std::list<char> li{'m', 'n', 'o'};
+  CharRange cr('e');
+  auto ch = chain(s1, li, cr);
+
+  Vec v(std::begin(ch), std::end(ch));
+  Vec vc{'a', 'b', 'c', 'm', 'n', 'o', 'a', 'b', 'c', 'd'};
+
+  REQUIRE(v == vc);
+}
+
 TEST_CASE("chain: handles empty containers", "[chain]") {
   std::string emp;
   std::string a{"a"};
@@ -172,6 +185,15 @@ TEST_CASE("chain.from_iterable: basic test", "[chain.from_iterable]") {
   REQUIRE(v == vc);
 }
 
+TEST_CASE("chain.fromm_iterable: Works with different begin and end types",
+    "[chain.from_iterable]") {
+  std::vector<CharRange> crv = {{'c'}, {'d'}};
+  auto ch = chain.from_iterable(crv);
+  const std::vector<char> v(std::begin(ch), std::end(ch));
+  const std::vector<char> vc = {'a', 'b', 'a', 'b', 'c'};
+  REQUIRE(v == vc);
+}
+
 TEST_CASE(
     "chain.from_iterable: iterators cant be copy constructed "
     "and assigned",

From 197706b415c2cec56897b485c3ea9e8752eb2c3a Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 14:19:02 -0800
Subject: [PATCH 1483/1866] Tests chunked with different begin and end

---
 test/test_chunked.cpp | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/test/test_chunked.cpp b/test/test_chunked.cpp
index 2bca55f4..2ecfc8c4 100644
--- a/test/test_chunked.cpp
+++ b/test/test_chunked.cpp
@@ -60,6 +60,17 @@ TEST_CASE("chunked: size 0 is empty", "[chunked]") {
   REQUIRE(std::begin(g) == std::end(g));
 }
 
+TEST_CASE("chunked: Works with different begin and end types",
+    "[chunked]") {
+  CharRange cr{'f'};
+  std::vector<std::vector<char>> results;
+  for (auto&& g : chunked(cr, 3)) {
+    results.emplace_back(std::begin(g), std::end(g));
+  }
+  std::vector<std::vector<char>> rc = {{'a', 'b', 'c'}, {'d', 'e'}};
+  REQUIRE(results == rc);
+}
+
 TEST_CASE("chunked: empty iterable gives empty chunked", "[chunked]") {
   Vec ns{};
   auto g = chunked(ns, 1);

From 6064bec41aceea02b26cea8d40c4b28c081c575e Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 14:19:15 -0800
Subject: [PATCH 1484/1866] Supports different begin and end in chunked

---
 chunked.hpp | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/chunked.hpp b/chunked.hpp
index d5676568..a0009896 100644
--- a/chunked.hpp
+++ b/chunked.hpp
@@ -3,6 +3,7 @@
 
 #include "internal/iterbase.hpp"
 #include "internal/iteratoriterator.hpp"
+#include "internal/iterator_wrapper.hpp"
 
 #include <vector>
 #include <algorithm>
@@ -32,15 +33,15 @@ class iter::impl::Chunker {
 
   friend ChunkedFn;
 
-  using IndexVector = std::vector<iterator_type<Container>>;
+  using IndexVector = std::vector<IteratorWrapper<Container>>;
   using DerefVec = IterIterWrapper<IndexVector>;
 
  public:
   Chunker(Chunker&&) = default;
   class Iterator : public std::iterator<std::input_iterator_tag, DerefVec> {
    private:
-    iterator_type<Container> sub_iter;
-    iterator_type<Container> sub_end;
+    IteratorWrapper<Container> sub_iter;
+    IteratorWrapper<Container> sub_end;
     DerefVec chunk;
     std::size_t chunk_size = 0;
 
@@ -59,8 +60,8 @@ class iter::impl::Chunker {
     }
 
    public:
-    Iterator(iterator_type<Container>&& in_iter,
-        iterator_type<Container>&& in_end, std::size_t s)
+    Iterator(IteratorWrapper<Container>&& in_iter,
+        IteratorWrapper<Container>&& in_end, std::size_t s)
         : sub_iter{std::move(in_iter)},
           sub_end{std::move(in_end)},
           chunk_size{s} {

From 113db4184dfbd7ba2e1a5f287fb9f5bf5ae920cb Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 14:19:30 -0800
Subject: [PATCH 1485/1866] Tests combinations with different begin and end

---
 test/test_combinations.cpp | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/test/test_combinations.cpp b/test/test_combinations.cpp
index 2b994a75..ef4e4653 100644
--- a/test/test_combinations.cpp
+++ b/test/test_combinations.cpp
@@ -1,5 +1,7 @@
 #define DEFINE_DEFAULT_ITERATOR_CTOR
+#define CHAR_RANGE_DEFAULT_CONSTRUCTIBLE
 #include "helpers.hpp"
+#undef CHAR_RANGE_DEFAULT_CONSTRUCTIBLE
 #undef DEFINE_DEFAULT_ITERATOR_CTOR
 
 #include <combinations.hpp>
@@ -35,6 +37,18 @@ TEST_CASE("combinations: Simple combination of 4", "[combinations]") {
   REQUIRE(ans == sc);
 }
 
+TEST_CASE("combinations: Works with different begin and end types",
+    "[combinations]") {
+  CharRange cr{'e'};
+  CharCombSet sc;
+  for (auto&& v : combinations(cr, 2)) {
+    sc.emplace_back(std::begin(v), std::end(v));
+  }
+  CharCombSet ans = {
+      {'a', 'b'}, {'a', 'c'}, {'a', 'd'}, {'b', 'c'}, {'b', 'd'}, {'c', 'd'}};
+  REQUIRE(ans == sc);
+}
+
 TEST_CASE("combinations: iterators can be compared", "[combinations]") {
   std::string s{"ABCD"};
   auto c = combinations(s, 2);

From d10d54e9a63066eb4d35e7569a721a6f1050fd88 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 14:20:09 -0800
Subject: [PATCH 1486/1866] Tests comb_w_repl with different begin and end

---
 test/test_combinations_with_replacement.cpp | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/test/test_combinations_with_replacement.cpp b/test/test_combinations_with_replacement.cpp
index 9db79414..9540588d 100644
--- a/test/test_combinations_with_replacement.cpp
+++ b/test/test_combinations_with_replacement.cpp
@@ -5,7 +5,9 @@
 #include <set>
 #include <vector>
 
+#define CHAR_RANGE_DEFAULT_CONSTRUCTIBLE
 #include "helpers.hpp"
+#undef CHAR_RANGE_DEFAULT_CONSTRUCTIBLE
 #include "catch.hpp"
 
 using iter::combinations_with_replacement;
@@ -31,6 +33,18 @@ TEST_CASE("combinations_with_replacement: Simple combination",
   REQUIRE(ans == sc);
 }
 
+TEST_CASE("combinations_with_replacement: Works with different begin and end types",
+    "[combinations_with_replacement]") {
+  CharRange cr{'d'};
+  CharCombSet sc;
+  for (auto&& v : combinations_with_replacement(cr, 2)) {
+    sc.emplace_back(std::begin(v), std::end(v));
+  }
+  CharCombSet ans = {
+      {'a', 'a'}, {'a', 'b'}, {'a', 'c'}, {'b', 'b'}, {'b', 'c'}, {'c', 'c'}};
+  REQUIRE(ans == sc);
+}
+
 TEST_CASE("combinations_with_replacement: iterators can be compared",
     "[combinations_with_replacement]") {
   std::string s{"ABCD"};

From 4d5c3ee3e8112d7a5831aadeac40704e34f2c816 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 14:20:23 -0800
Subject: [PATCH 1487/1866] Tests compress with different begin and end

---
 test/test_compress.cpp | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/test/test_compress.cpp b/test/test_compress.cpp
index 9a0c30b2..7938b23a 100644
--- a/test/test_compress.cpp
+++ b/test/test_compress.cpp
@@ -136,6 +136,15 @@ TEST_CASE("compress: iterator meets requirements", "[compress]") {
   REQUIRE(itertest::IsIterator<decltype(std::begin(c))>::value);
 }
 
+TEST_CASE("compress: Works with different begin and end types",
+    "[compress]") {
+  CharRange cr{'d'};
+  auto c = compress(cr, std::vector<bool>{true, false, true});
+  Vec v(c.begin(), c.end());
+  Vec vc{'a', 'c'};
+  REQUIRE(v == vc);
+}
+
 template <typename T, typename U>
 using ImpT = decltype(compress(std::declval<T>(), std::declval<U>()));
 TEST_CASE("compress: has correct ctor and assign ops", "[compress]") {

From 1dc483e5c8fb1655d9a0f437053c0c52a6683cce Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 14:20:34 -0800
Subject: [PATCH 1488/1866] Supports different begin and end in compress

---
 compress.hpp | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/compress.hpp b/compress.hpp
index 22d8cded..0482298d 100644
--- a/compress.hpp
+++ b/compress.hpp
@@ -2,6 +2,7 @@
 #define ITER_COMPRESS_H_
 
 #include "internal/iterbase.hpp"
+#include "internal/iterator_wrapper.hpp"
 
 #include <utility>
 #include <iterator>
@@ -38,8 +39,8 @@ class iter::impl::Compressed {
   class Iterator : public std::iterator<std::input_iterator_tag,
                        iterator_traits_deref<Container>> {
    private:
-    iterator_type<Container> sub_iter;
-    iterator_type<Container> sub_end;
+    IteratorWrapper<Container> sub_iter;
+    IteratorWrapper<Container> sub_end;
 
     selector_iter_type selector_iter;
     selector_iter_type selector_end;
@@ -58,8 +59,8 @@ class iter::impl::Compressed {
     }
 
    public:
-    Iterator(iterator_type<Container>&& cont_iter,
-        iterator_type<Container>&& cont_end, selector_iter_type&& sel_iter,
+    Iterator(IteratorWrapper<Container>&& cont_iter,
+        IteratorWrapper<Container>&& cont_end, selector_iter_type&& sel_iter,
         selector_iter_type&& sel_end)
         : sub_iter{std::move(cont_iter)},
           sub_end{std::move(cont_end)},

From 48123d612175961736fa348a07ac7b15d351ec86 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 14:23:42 -0800
Subject: [PATCH 1489/1866] Tests cycle with different begin and end

---
 test/test_cycle.cpp | 22 ++++++++++++++++++++--
 1 file changed, 20 insertions(+), 2 deletions(-)

diff --git a/test/test_cycle.cpp b/test/test_cycle.cpp
index 8d4ab37c..3066d00d 100644
--- a/test/test_cycle.cpp
+++ b/test/test_cycle.cpp
@@ -17,7 +17,7 @@ TEST_CASE("cycle: iterate twice", "[cycle]") {
   for (auto i : cycle(ns)) {
     v.push_back(i);
     ++count;
-    if (count == ns.size() * 2) break;
+    if (count == ns.size() * 2) { break; }
   }
 
   auto vc = ns;
@@ -25,6 +25,24 @@ TEST_CASE("cycle: iterate twice", "[cycle]") {
   REQUIRE(v == vc);
 }
 
+TEST_CASE("cycle: Works with different begin and end types",
+    "[cycle]") {
+  constexpr auto sz = 'd' - 'a';
+  CharRange cr{'d'};
+  const std::vector<char> vc{'a', 'b', 'c', 'a', 'b', 'c'};
+  std::vector<char> v;
+  std::size_t count = 0;
+  for (auto i : cycle(cr)) {
+    v.push_back(i);
+    ++count;
+    if (count == sz * 2) { break; }
+  }
+
+  REQUIRE(v == vc);
+}
+
+
+
 TEST_CASE("cycle: with pipe", "[cycle]") {
   std::vector<int> ns{2, 4, 6};
   std::vector<int> v;
@@ -32,7 +50,7 @@ TEST_CASE("cycle: with pipe", "[cycle]") {
   for (auto i : ns | cycle) {
     v.push_back(i);
     ++count;
-    if (count == ns.size() * 2) break;
+    if (count == ns.size() * 2) { break; } 
   }
 
   auto vc = ns;

From d2d5adc21fe2ad31d6f814e85e34a5b309c9fa4e Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 14:24:31 -0800
Subject: [PATCH 1490/1866] Supports different begin and end in cycle

---
 cycle.hpp | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/cycle.hpp b/cycle.hpp
index 64b3ee84..b416553f 100644
--- a/cycle.hpp
+++ b/cycle.hpp
@@ -2,6 +2,7 @@
 #define ITER_CYCLE_H_
 
 #include "internal/iterbase.hpp"
+#include "internal/iterator_wrapper.hpp"
 
 #include <utility>
 #include <iterator>
@@ -32,13 +33,13 @@ class iter::impl::Cycler {
   class Iterator : public std::iterator<std::input_iterator_tag,
                        iterator_traits_deref<Container>> {
    private:
-    iterator_type<Container> sub_iter;
-    iterator_type<Container> begin;
-    iterator_type<Container> end;
+    IteratorWrapper<Container> sub_iter;
+    IteratorWrapper<Container> begin;
+    IteratorWrapper<Container> end;
 
    public:
     Iterator(
-        const iterator_type<Container>& iter, iterator_type<Container>&& in_end)
+        IteratorWrapper<Container>&& iter, IteratorWrapper<Container>&& in_end)
         : sub_iter{iter}, begin{iter}, end{std::move(in_end)} {}
 
     iterator_deref<Container> operator*() {

From 95c503414e263c057833ab9c1f77cd8e6ac12465 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 14:24:41 -0800
Subject: [PATCH 1491/1866] Tests dropwhile with different begin and end

---
 test/test_dropwhile.cpp | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/test/test_dropwhile.cpp b/test/test_dropwhile.cpp
index 599ab407..aba3ec09 100644
--- a/test/test_dropwhile.cpp
+++ b/test/test_dropwhile.cpp
@@ -27,6 +27,15 @@ TEST_CASE("dropwhile: skips initial elements", "[dropwhile]") {
   REQUIRE(v == vc);
 }
 
+TEST_CASE("dropwhile: Works with different begin and end types",
+    "[dropwhile]") {
+  CharRange cr{'f'};
+  auto d = dropwhile([](char c){return c < 'c';}, cr);
+  Vec v(d.begin(), d.end());
+  Vec vc{'c', 'd', 'e'};
+  REQUIRE(v == vc);
+}
+
 TEST_CASE("dropwhile: doesn't skip anything if it shouldn't", "[dropwhile]") {
   Vec ns{3, 4, 5, 6};
   auto d = dropwhile([](int i) { return i < 3; }, ns);

From 35d55c8847f5fdbbc078b3e7bc8f5ce97d03a014 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 14:24:49 -0800
Subject: [PATCH 1492/1866] Supports different begin and end in dropwhile

---
 dropwhile.hpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/dropwhile.hpp b/dropwhile.hpp
index 869e0070..1f8c587d 100644
--- a/dropwhile.hpp
+++ b/dropwhile.hpp
@@ -2,6 +2,7 @@
 #define ITER_DROPWHILE_H_
 
 #include "internal/iterbase.hpp"
+#include "internal/iterator_wrapper.hpp"
 #include "filter.hpp"
 
 #include <utility>
@@ -35,8 +36,8 @@ class iter::impl::Dropper {
                        iterator_traits_deref<Container>> {
    private:
     using Holder = DerefHolder<iterator_deref<Container>>;
-    iterator_type<Container> sub_iter;
-    iterator_type<Container> sub_end;
+    IteratorWrapper<Container> sub_iter;
+    IteratorWrapper<Container> sub_end;
     Holder item;
     FilterFunc* filter_func;
 
@@ -56,7 +57,7 @@ class iter::impl::Dropper {
     }
 
    public:
-    Iterator(iterator_type<Container>&& iter, iterator_type<Container>&& end,
+    Iterator(IteratorWrapper<Container>&& iter, IteratorWrapper<Container>&& end,
         FilterFunc& in_filter_func)
         : sub_iter{std::move(iter)},
           sub_end{std::move(end)},

From 9d012aa330356c5755fa20c255bc59353f48f0e8 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 14:24:56 -0800
Subject: [PATCH 1493/1866] Tests takewhile with different begin and end

---
 test/test_takewhile.cpp | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/test/test_takewhile.cpp b/test/test_takewhile.cpp
index af5f6091..202e99ab 100644
--- a/test/test_takewhile.cpp
+++ b/test/test_takewhile.cpp
@@ -57,6 +57,15 @@ TEST_CASE("takewhile: works with lambda, callable, and function pointer",
   }
 }
 
+TEST_CASE("takewhile: Works with different begin and end types",
+    "[takewhile]") {
+  CharRange cr{'f'};
+  auto t = takewhile([](char c){return c < 'd';}, cr);
+  Vec v(t.begin(), t.end());
+  Vec vc{'a', 'b', 'c'};
+  REQUIRE(v == vc);
+}
+
 TEST_CASE("takewhile: identity", "[takewhile]") {
   Vec ns{1, 2, 3, 0, 4, 5, 0};
   std::vector<int> v;

From 473fded048f9ae55beef9435ce85d880afcb165d Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 14:25:02 -0800
Subject: [PATCH 1494/1866] Supports different begin and end in takewhile

---
 takewhile.hpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/takewhile.hpp b/takewhile.hpp
index 003e38a0..f05828dd 100644
--- a/takewhile.hpp
+++ b/takewhile.hpp
@@ -2,6 +2,7 @@
 #define ITER_TAKEWHILE_H_
 
 #include "internal/iterbase.hpp"
+#include "internal/iterator_wrapper.hpp"
 #include "filter.hpp"
 
 #include <utility>
@@ -36,8 +37,8 @@ class iter::impl::Taker {
                        iterator_traits_deref<Container>> {
    private:
     using Holder = DerefHolder<iterator_deref<Container>>;
-    iterator_type<Container> sub_iter;
-    iterator_type<Container> sub_end;
+    IteratorWrapper<Container> sub_iter;
+    IteratorWrapper<Container> sub_end;
     Holder item;
     FilterFunc* filter_func;
 
@@ -56,7 +57,7 @@ class iter::impl::Taker {
     }
 
    public:
-    Iterator(iterator_type<Container>&& iter, iterator_type<Container>&& end,
+    Iterator(IteratorWrapper<Container>&& iter, IteratorWrapper<Container>&& end,
         FilterFunc& in_filter_func)
         : sub_iter{std::move(iter)},
           sub_end{std::move(end)},

From 1d59f3f2da1f2511ae00fb03baa26d658d41139d Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 14:25:10 -0800
Subject: [PATCH 1495/1866] Tests enumerate with different begin and end

---
 test/test_enumerate.cpp | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/test/test_enumerate.cpp b/test/test_enumerate.cpp
index be5209ff..3b8f56ac 100644
--- a/test/test_enumerate.cpp
+++ b/test/test_enumerate.cpp
@@ -148,6 +148,15 @@ TEST_CASE("enumerate: works index and pipe", "[enumerate]") {
   REQUIRE(v == vc);
 }
 
+TEST_CASE("enumerate: Works with different begin and end types",
+    "[enumerate]") {
+  CharRange cr{'d'};
+  auto e = enumerate(cr);
+  Vec v(e.begin(), e.end());
+  Vec vc{{0, 'a'}, {1, 'b'}, {2, 'c'}};
+  REQUIRE(v == vc);
+}
+
 template <typename T>
 using ImpT = decltype(enumerate(std::declval<T>()));
 TEST_CASE("enumerate: has correct ctor and assign ops", "[enumerate]") {

From f1ba8f6eb661ece762e2fb810ddf0b7ae3feaa03 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 14:25:15 -0800
Subject: [PATCH 1496/1866] Supports different begin and end in enumerate

---
 enumerate.hpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index 6492c909..3f4ab47c 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -2,6 +2,7 @@
 #define ITER_ENUMERATE_H_
 
 #include "internal/iterbase.hpp"
+#include "internal/iterator_wrapper.hpp"
 
 #include <utility>
 #include <iterator>
@@ -51,11 +52,11 @@ class iter::impl::Enumerable {
   //  Each dereference returns an IterYield.
   class Iterator : public std::iterator<std::input_iterator_tag, IterYield> {
    private:
-    iterator_type<Container> sub_iter;
+    IteratorWrapper<Container> sub_iter;
     Index index;
 
    public:
-    Iterator(iterator_type<Container>&& si, Index start)
+    Iterator(IteratorWrapper<Container>&& si, Index start)
         : sub_iter{std::move(si)}, index{start} {}
 
     IterYield operator*() {

From d6d6a95afd7bf38a0255a576763fa9b861a244bc Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 14:25:19 -0800
Subject: [PATCH 1497/1866] Tests filter with different begin and end

---
 test/test_filter.cpp | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/test/test_filter.cpp b/test/test_filter.cpp
index 63b8e068..d5c1aed3 100644
--- a/test/test_filter.cpp
+++ b/test/test_filter.cpp
@@ -145,6 +145,15 @@ TEST_CASE("filter: using identity and pipe", "[filter]") {
   REQUIRE(v == vc);
 }
 
+TEST_CASE("filter: Works with different begin and end types",
+    "[filter]") {
+  CharRange cr{'d'};
+  auto f = filter([](char c){return c != 'b';}, cr);
+  Vec v(f.begin(), f.end());
+  Vec vc{'a', 'c'};
+  REQUIRE(v == vc);
+}
+
 TEST_CASE("filter: iterator meets requirements", "[filter]") {
   std::string s{};
   auto c = filter([] { return true; }, s);

From 6265e6606921dd3cc4df111532389b05ce291e71 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 14:25:56 -0800
Subject: [PATCH 1498/1866] Supports different begin and end in filter

---
 filter.hpp | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/filter.hpp b/filter.hpp
index f7364f3a..42ad09bd 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -2,6 +2,7 @@
 #define ITER_FILTER_H_
 
 #include "internal/iterbase.hpp"
+#include "internal/iterator_wrapper.hpp"
 
 #include <utility>
 #include <iterator>
@@ -46,8 +47,8 @@ class iter::impl::Filtered {
                        iterator_traits_deref<Container>> {
    protected:
     using Holder = DerefHolder<iterator_deref<Container>>;
-    iterator_type<Container> sub_iter;
-    iterator_type<Container> sub_end;
+    IteratorWrapper<Container> sub_iter;
+    IteratorWrapper<Container> sub_end;
     Holder item;
     FilterFunc* filter_func;
 
@@ -68,9 +69,9 @@ class iter::impl::Filtered {
     }
 
    public:
-    Iterator(iterator_type<Container> iter, iterator_type<Container> end,
+    Iterator(IteratorWrapper<Container>&& iter, IteratorWrapper<Container>&& end,
         FilterFunc& in_filter_func)
-        : sub_iter{iter}, sub_end{end}, filter_func(&in_filter_func) {
+        : sub_iter{std::move(iter)}, sub_end{std::move(end)}, filter_func(&in_filter_func) {
       if (this->sub_iter != this->sub_end) {
         this->item.reset(*this->sub_iter);
       }

From 4295c840b09864f818be80215d8a28ed621bca2e Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 14:26:20 -0800
Subject: [PATCH 1499/1866] Tests groupby with different begin and end

---
 test/test_groupby.cpp | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/test/test_groupby.cpp b/test/test_groupby.cpp
index a102692f..c353b491 100644
--- a/test/test_groupby.cpp
+++ b/test/test_groupby.cpp
@@ -69,6 +69,21 @@ TEST_CASE("groupby: works with lambda, callable, and function pointer") {
   REQUIRE(groups == gc);
 }
 
+TEST_CASE("groupby: Works with different begin and end types",
+    "[groupby]") {
+  CharRange cr{'f'};
+  std::vector<bool> keys;
+  std::vector<std::vector<char>> groups;
+  for (auto&& gb : groupby(cr, [](char c){return c == 'c';})) {
+    keys.push_back(gb.first);
+    groups.emplace_back(std::begin(gb.second), std::end(gb.second));
+  }
+  const std::vector<bool> kc = {false, true, false};
+  const std::vector<std::vector<char>> gc = {{'a' ,'b'}, {'c'}, {'d', 'e'}};
+  REQUIRE(keys == kc);
+  REQUIRE(groups == gc);
+}
+
 TEST_CASE("groupby: groups can be skipped completely", "[groupby]") {
   std::vector<int> keys;
   std::vector<std::vector<std::string>> groups;

From cfe0c367b144a0dce2c4335e394f5a3a88f7d0db Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 14:26:20 -0800
Subject: [PATCH 1500/1866] Supports different begin and end in groupby

---
 groupby.hpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/groupby.hpp b/groupby.hpp
index a0af1d4d..e0a5f53a 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -4,6 +4,7 @@
 // this is easily the most functionally complex itertool
 
 #include "internal/iterbase.hpp"
+#include "internal/iterator_wrapper.hpp"
 
 #include <type_traits>
 #include <memory>
@@ -54,15 +55,15 @@ class iter::impl::GroupProducer {
  public:
   class Iterator : public std::iterator<std::input_iterator_tag, KeyGroupPair> {
    private:
-    iterator_type<Container> sub_iter;
-    iterator_type<Container> sub_end;
+    IteratorWrapper<Container> sub_iter;
+    IteratorWrapper<Container> sub_end;
     Holder item;
     KeyFunc* key_func;
 
     std::unique_ptr<KeyGroupPair> current_key_group_pair;
 
    public:
-    Iterator(iterator_type<Container>&& si, iterator_type<Container>&& end,
+    Iterator(IteratorWrapper<Container>&& si, IteratorWrapper<Container>&& end,
         KeyFunc& in_key_func)
         : sub_iter{std::move(si)},
           sub_end{std::move(end)},

From df05e374f016385906d0807507128a91e7a0730d Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 14:26:45 -0800
Subject: [PATCH 1501/1866] Tests permutations with different begin and end

---
 test/test_permutations.cpp | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/test/test_permutations.cpp b/test/test_permutations.cpp
index c184e651..a2ab49ee 100644
--- a/test/test_permutations.cpp
+++ b/test/test_permutations.cpp
@@ -31,6 +31,22 @@ TEST_CASE("permutations: basic test, 3 element sequence", "[permutations]") {
   REQUIRE(v == vc);
 }
 
+TEST_CASE("permutations: Works with different begin and end types",
+    "[permutations]") {
+  CharRange cr{'d'};
+  using CharPermSet = std::multiset<std::vector<char>>;
+  CharPermSet sc;
+  for (auto&& v : permutations(cr)) {
+    sc.emplace(std::begin(v), std::end(v));
+  }
+  const CharPermSet ans = {
+    {'a', 'b', 'c'}, {'a', 'c', 'b'},
+    {'b', 'a', 'c'}, {'b', 'c', 'a'},
+    {'c', 'a', 'b'}, {'c', 'b', 'a'}};
+    
+  REQUIRE(ans == sc);
+}
+
 TEST_CASE(
     "permutations: empty sequence has one empy permutation", "[permutations]") {
   const std::vector<int> ns{};

From 53260484e7906580869ed33f55a1e736f6df4c73 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 14:26:45 -0800
Subject: [PATCH 1502/1866] Supports different begin and end in permutations

---
 permutations.hpp | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/permutations.hpp b/permutations.hpp
index dea9fa8c..0e6c3aa5 100644
--- a/permutations.hpp
+++ b/permutations.hpp
@@ -3,6 +3,7 @@
 
 #include "internal/iterbase.hpp"
 #include "internal/iteratoriterator.hpp"
+#include "internal/iterator_wrapper.hpp"
 
 #include <algorithm>
 #include <initializer_list>
@@ -25,7 +26,7 @@ class iter::impl::Permuter {
   friend PermutationsFn;
   Container container;
 
-  using IndexVector = std::vector<iterator_type<Container>>;
+  using IndexVector = std::vector<IteratorWrapper<Container>>;
   using Permutable = IterIterWrapper<IndexVector>;
 
   Permuter(Container&& in_container)
@@ -37,8 +38,8 @@ class iter::impl::Permuter {
   class Iterator : public std::iterator<std::input_iterator_tag, Permutable> {
    private:
     static constexpr const int COMPLETE = -1;
-    static bool cmp_iters(const iterator_type<Container>& lhs,
-        const iterator_type<Container>& rhs) noexcept {
+    static bool cmp_iters(IteratorWrapper<Container> lhs,
+        IteratorWrapper<Container> rhs) noexcept {
       return *lhs < *rhs;
     }
 
@@ -47,7 +48,8 @@ class iter::impl::Permuter {
 
    public:
     Iterator(
-        iterator_type<Container>&& sub_iter, iterator_type<Container>&& sub_end)
+        IteratorWrapper<Container>&& sub_iter,
+        IteratorWrapper<Container>&& sub_end)
         : steps{sub_iter != sub_end ? 0 : COMPLETE} {
       // done like this instead of using vector ctor with
       // two iterators because that causes a substitution

From cd36279b1167228c40b21167faa61ff6dcf0f84b Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 14:26:56 -0800
Subject: [PATCH 1503/1866] Tests product with different begin and end

---
 test/test_product.cpp | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/test/test_product.cpp b/test/test_product.cpp
index d42cde31..4f9f1d2c 100644
--- a/test/test_product.cpp
+++ b/test/test_product.cpp
@@ -26,6 +26,21 @@ TEST_CASE("product: basic test, two sequences", "[product]") {
   REQUIRE(v == vc);
 }
 
+TEST_CASE("product: two sequences where one has different begin and end", "[product]") {
+  using TP = std::tuple<int, char>;
+  using ResType = std::vector<TP>;
+
+  Vec n1 = {0, 1};
+  CharRange cr('d');
+
+  auto p = product(n1, cr);
+  ResType v(std::begin(p), std::end(p));
+  ResType vc = {
+      TP{0, 'a'}, TP{0, 'b'}, TP{0, 'c'}, TP{1, 'a'}, TP{1, 'b'}, TP{1, 'c'}};
+
+  REQUIRE(v == vc);
+}
+
 TEST_CASE("product: three sequences", "[product]") {
   using TP = std::tuple<int, char, int>;
   using ResType = const std::vector<TP>;

From 65d96d75fb256218bdf9496baa2f60cf1ed3a086 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 14:26:56 -0800
Subject: [PATCH 1504/1866] Supports different begin and end in product

---
 product.hpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/product.hpp b/product.hpp
index 8939a28e..3b1b5572 100644
--- a/product.hpp
+++ b/product.hpp
@@ -2,6 +2,7 @@
 #define ITER_PRODUCT_HPP_
 
 #include "internal/iterbase.hpp"
+#include "internal/iterator_wrapper.hpp"
 
 #include <iterator>
 #include <tuple>
@@ -50,15 +51,15 @@ class iter::impl::Productor<Container, RestContainers...> {
    private:
     using RestIter = typename Productor<RestContainers...>::Iterator;
 
-    iterator_type<Container> iter;
-    iterator_type<Container> begin;
+    IteratorWrapper<Container> iter;
+    IteratorWrapper<Container> begin;
 
     RestIter rest_iter;
     RestIter rest_end;
 
    public:
     constexpr static const bool is_base_iter = false;
-    Iterator(const iterator_type<Container>& it, RestIter&& rest,
+    Iterator(IteratorWrapper<Container>&& it, RestIter&& rest,
         RestIter&& in_rest_end)
         : iter{it}, begin{it}, rest_iter{rest}, rest_end{in_rest_end} {}
 

From 089eee761a95753183be7452e6cdac94fdd770d3 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 14:27:01 -0800
Subject: [PATCH 1505/1866] Tests reversed with different begin and end

---
 test/test_reversed.cpp | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/test/test_reversed.cpp b/test/test_reversed.cpp
index 1cd6fcfa..2ccf5d2f 100644
--- a/test/test_reversed.cpp
+++ b/test/test_reversed.cpp
@@ -31,6 +31,17 @@ TEST_CASE("reversed: can reverse a vector", "[reversed]") {
   REQUIRE(v == vc);
 }
 
+#if 0
+TEST_CASE("reversed: Works with different begin and end types",
+    "[reversed]") {
+  CharRange cr{'d'};
+  auto r = reversed(cr);
+  Vec v(r.begin(), r.end());
+  Vec vc{'c', 'b', 'a'};
+  REQUIRE(v == vc);
+}
+#endif
+
 TEST_CASE("reversed: can reverse an array", "[reversed]") {
   int ns[] = {10, 20, 30, 40};
   auto r = reversed(ns);

From b9840c30ecf895dffcfe703ebda806b4099a4adf Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 14:27:01 -0800
Subject: [PATCH 1506/1866] Supports different begin and end in reversed

---
 reversed.hpp | 45 +++++++++++++++++++++++++++++++++++++--------
 1 file changed, 37 insertions(+), 8 deletions(-)

diff --git a/reversed.hpp b/reversed.hpp
index 82ae9b46..b17457c3 100644
--- a/reversed.hpp
+++ b/reversed.hpp
@@ -1,13 +1,43 @@
 #ifndef ITER_REVERSE_HPP_
 #define ITER_REVERSE_HPP_
 
+#include "internal/iterator_wrapper.hpp"
 #include "internal/iterbase.hpp"
 
-#include <utility>
 #include <iterator>
+#include <utility>
 
 namespace iter {
   namespace impl {
+    template <typename Container>
+    using reverse_iterator_type =
+        decltype(std::rbegin(std::declval<Container&>()));
+    template <typename Container>
+    using reverse_iterator_end_type =
+        decltype(std::rend(std::declval<Container&>()));
+
+    // If rbegin and rend return the same type, type will be
+    // reverse_iterator_type<Container>
+    // If rbegin and rend return different types, type will be
+    // IteratorWrapperImpl
+    template <typename Container, bool same_types>
+    struct ReverseIteratorWrapperImplType;
+
+    template <typename Container>
+    struct ReverseIteratorWrapperImplType<Container, true>
+        : type_is<reverse_iterator_type<Container>> {};
+
+    template <typename Container>
+    struct ReverseIteratorWrapperImplType<Container, false>
+        : type_is<IteratorWrapperImpl<reverse_iterator_type<Container>,
+              reverse_iterator_end_type<Container>>> {};
+
+    template <typename Container>
+    using ReverseIteratorWrapper =
+        typename ReverseIteratorWrapperImplType<Container,
+            std::is_same<impl::reverse_iterator_type<Container>,
+                impl::reverse_iterator_end_type<Container>>{}>::type;
+
     template <typename Container>
     class Reverser;
 
@@ -25,26 +55,25 @@ class iter::impl::Reverser {
   Reverser(Container&& in_container)
       : container(std::forward<Container>(in_container)) {}
 
-  using reverse_iterator_type =
-      decltype(std::rbegin(std::declval<Container&>()));
-
   using reverse_iterator_deref =
-      decltype(*std::declval<reverse_iterator_type&>());
+      decltype(*std::declval<reverse_iterator_type<Container>&>());
 
   using reverse_iterator_traits_deref =
       std::remove_reference_t<reverse_iterator_deref>;
 
-  using reverse_iterator_arrow = detail::arrow<reverse_iterator_type>;
+  using reverse_iterator_arrow =
+      detail::arrow<reverse_iterator_type<Container>>;
 
  public:
   Reverser(Reverser&&) = default;
   class Iterator : public std::iterator<std::input_iterator_tag,
                        reverse_iterator_traits_deref> {
    private:
-    reverse_iterator_type sub_iter;
+    ReverseIteratorWrapper<Container> sub_iter;
 
    public:
-    Iterator(reverse_iterator_type&& iter) : sub_iter{std::move(iter)} {}
+    Iterator(ReverseIteratorWrapper<Container>&& iter)
+        : sub_iter{std::move(iter)} {}
 
     reverse_iterator_deref operator*() {
       return *this->sub_iter;

From 8ba3bd5ddb353a3c38c0094f24326bd0972068ef Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 14:27:09 -0800
Subject: [PATCH 1507/1866] Tests slice with different begin and end

---
 test/test_slice.cpp | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/test/test_slice.cpp b/test/test_slice.cpp
index 1500da6e..8cb3ee66 100644
--- a/test/test_slice.cpp
+++ b/test/test_slice.cpp
@@ -44,6 +44,15 @@ TEST_CASE("slice: start and stop", "[slice]") {
   REQUIRE(v == vc);
 }
 
+TEST_CASE("slice: Works with different begin and end types",
+    "[slice]") {
+  CharRange cr{'z'};
+  auto sl = slice(cr, 2, 5);
+  std::vector<char> v(std::begin(sl), std::end(sl));
+  const std::vector<char> vc = {'c', 'd', 'e'};
+  REQUIRE(v == vc);
+}
+
 TEST_CASE("slice: start, stop, step", "[slice]") {
   Vec ns = {10, 11, 12, 13, 14, 15, 16, 17, 18, 19};
   std::vector<int> v;

From d9fc76d7cadef8299a7a5867f7819aad01b91ad2 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 14:27:09 -0800
Subject: [PATCH 1508/1866] Supports different begin and end in slice

---
 slice.hpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/slice.hpp b/slice.hpp
index 8ff5a6af..df2ce0a2 100644
--- a/slice.hpp
+++ b/slice.hpp
@@ -2,6 +2,7 @@
 #define ITER_SLICE_HPP_
 
 #include "internal/iterbase.hpp"
+#include "internal/iterator_wrapper.hpp"
 
 #include <iterator>
 #include <type_traits>
@@ -37,14 +38,14 @@ class iter::impl::Sliced {
   class Iterator : public std::iterator<std::input_iterator_tag,
                        iterator_traits_deref<Container>> {
    private:
-    iterator_type<Container> sub_iter;
-    iterator_type<Container> sub_end;
+    IteratorWrapper<Container> sub_iter;
+    IteratorWrapper<Container> sub_end;
     DifferenceType current;
     DifferenceType stop;
     DifferenceType step;
 
    public:
-    Iterator(iterator_type<Container>&& si, iterator_type<Container>&& se,
+    Iterator(IteratorWrapper<Container>&& si, IteratorWrapper<Container>&& se,
         DifferenceType in_start, DifferenceType in_stop, DifferenceType in_step)
         : sub_iter{std::move(si)},
           sub_end{std::move(se)},

From 2ad5f0f7132bc008aa476656c83d98c956be01f7 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 14:27:15 -0800
Subject: [PATCH 1509/1866] Tests sliding_window with different begin and end

---
 test/test_sliding_window.cpp | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/test/test_sliding_window.cpp b/test/test_sliding_window.cpp
index 0cd26a52..8400aedf 100644
--- a/test/test_sliding_window.cpp
+++ b/test/test_sliding_window.cpp
@@ -28,6 +28,20 @@ TEST_CASE("sliding_window: window of size 3", "[sliding_window]") {
   REQUIRE(v == vc);
 }
 
+TEST_CASE("sliding_window: Works with different begin and end types",
+    "[sliding_window]") {
+  CharRange cr{'f'};
+  std::vector<std::vector<char>> results;
+  for (auto&& g : sliding_window(cr, 3)) {
+    results.emplace_back(std::begin(g), std::end(g));
+  }
+  std::vector<std::vector<char>> rc = {
+    {'a', 'b', 'c'},
+    {'b', 'c', 'd'},
+    {'c', 'd', 'e'}};
+  REQUIRE(results == rc);
+}
+
 TEST_CASE("sliding window: oversized window is empty", "[sliding_window]") {
   Vec ns = {10, 20, 30};
   auto sw = sliding_window(ns, 5);

From c82f9c8dcda59260988f34e4a508bbce295d7920 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 14:27:15 -0800
Subject: [PATCH 1510/1866] Supports different begin and end in sliding_window

---
 sliding_window.hpp | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/sliding_window.hpp b/sliding_window.hpp
index 9f58334b..6a68faaa 100644
--- a/sliding_window.hpp
+++ b/sliding_window.hpp
@@ -2,6 +2,7 @@
 #define ITER_SLIDING_WINDOW_HPP_
 
 #include "internal/iterbase.hpp"
+#include "internal/iterator_wrapper.hpp"
 #include "internal/iteratoriterator.hpp"
 
 #include <deque>
@@ -28,19 +29,19 @@ class iter::impl::WindowSlider {
   WindowSlider(Container&& in_container, std::size_t win_sz)
       : container(std::forward<Container>(in_container)), window_size{win_sz} {}
 
-  using IndexVector = std::deque<iterator_type<Container>>;
+  using IndexVector = std::deque<IteratorWrapper<Container>>;
   using DerefVec = IterIterWrapper<IndexVector>;
 
  public:
   WindowSlider(WindowSlider&&) = default;
   class Iterator : public std::iterator<std::input_iterator_tag, DerefVec> {
    private:
-    iterator_type<Container> sub_iter;
+    IteratorWrapper<Container> sub_iter;
     DerefVec window;
 
    public:
-    Iterator(iterator_type<Container>&& in_iter,
-        const iterator_type<Container>& in_end, std::size_t window_sz)
+    Iterator(IteratorWrapper<Container>&& in_iter,
+         IteratorWrapper<Container>&& in_end, std::size_t window_sz)
         : sub_iter(std::move(in_iter)) {
       std::size_t i{0};
       while (i < window_sz && this->sub_iter != in_end) {
@@ -83,8 +84,8 @@ class iter::impl::WindowSlider {
   };
 
   Iterator begin() {
-    return {(this->window_size != 0 ? std::begin(this->container)
-                                    : std::end(this->container)),
+    return {(this->window_size != 0 ? IteratorWrapper<Container>{std::begin(this->container)}
+                                    : IteratorWrapper<Container>{std::end(this->container)}),
         std::end(this->container), this->window_size};
   }
 

From edcf82a521fad4c61c2c707aa96195f52980a14b Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 14:27:38 -0800
Subject: [PATCH 1511/1866] Tests starmap with different begin and end

---
 test/test_starmap.cpp | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/test/test_starmap.cpp b/test/test_starmap.cpp
index 25451dcf..6f1e7d7b 100644
--- a/test/test_starmap.cpp
+++ b/test/test_starmap.cpp
@@ -57,6 +57,18 @@ TEST_CASE("starmap: works with function pointer and lambda", "[starmap]") {
   REQUIRE(v == vc);
 }
 
+TEST_CASE("starmap: Works with different begin and end types",
+    "[starmap]") {
+  IntCharPairRange icr{{3, 'd'}};
+  using Vec = std::vector<std::string>;
+  auto sm = starmap([](int i, char c) {
+      return std::to_string(i) + c;},
+      icr);
+  Vec v(sm.begin(), sm.end());
+  Vec vc{"0a", "1b", "2c"};
+  REQUIRE(v == vc);
+}
+
 TEST_CASE("starmap: list of tuples", "[starmap]") {
   using Vec = const std::vector<std::string>;
   using T = std::tuple<std::string, int, double>;

From 24a69cd5684c5255653d15041d7de285ecff9740 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 14:27:38 -0800
Subject: [PATCH 1512/1866] Supports different begin and end in starmap

---
 starmap.hpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/starmap.hpp b/starmap.hpp
index e4658e50..7570e03e 100644
--- a/starmap.hpp
+++ b/starmap.hpp
@@ -2,6 +2,7 @@
 #define ITER_STARMAP_H_
 
 #include "internal/iterbase.hpp"
+#include "internal/iterator_wrapper.hpp"
 
 #include <utility>
 #include <iterator>
@@ -45,10 +46,10 @@ class iter::impl::StarMapper {
       : public std::iterator<std::input_iterator_tag, StarIterDeref> {
    private:
     Func* func;
-    iterator_type<Container> sub_iter;
+    IteratorWrapper<Container> sub_iter;
 
    public:
-    Iterator(Func& f, iterator_type<Container>&& iter)
+    Iterator(Func& f, IteratorWrapper<Container>&& iter)
         : func(&f), sub_iter(std::move(iter)) {}
 
     bool operator!=(const Iterator& other) const {

From 3e260982740e4371a9a0b15114019ce24cfff65b Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 14:27:59 -0800
Subject: [PATCH 1513/1866] Tests filterfalse with different begin and end

---
 test/test_filterfalse.cpp | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/test/test_filterfalse.cpp b/test/test_filterfalse.cpp
index b9de4bd2..dbf826fd 100644
--- a/test/test_filterfalse.cpp
+++ b/test/test_filterfalse.cpp
@@ -60,6 +60,15 @@ TEST_CASE("filterfalse: handles different functor types", "[filterfalse]") {
   }
 }
 
+TEST_CASE("filterfalse: Works with different begin and end types",
+    "[filterfalse]") {
+  CharRange cr{'d'};
+  auto f = filterfalse([](char c){return c == 'b';}, cr);
+  Vec v(f.begin(), f.end());
+  Vec vc{'a', 'c'};
+  REQUIRE(v == vc);
+}
+
 TEST_CASE("filterfalse: using identity", "[filterfalse]") {
   Vec ns{0, 1, 2, 0, 3, 0, 0, 0, 4, 5, 0};
   std::vector<int> v;

From ac46acc3a32581c264f66c4351b8f083107efb1c Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 14:28:04 -0800
Subject: [PATCH 1514/1866] Tests imap with different begin and end

---
 test/test_imap.cpp | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/test/test_imap.cpp b/test/test_imap.cpp
index 4912b11f..2ab1f5a6 100644
--- a/test/test_imap.cpp
+++ b/test/test_imap.cpp
@@ -5,6 +5,7 @@
 #include <vector>
 #include <string>
 #include <iterator>
+#include <cctype>
 
 #include "catch.hpp"
 
@@ -60,6 +61,15 @@ TEST_CASE("imap: works with lambda, callable, and function", "[imap]") {
   REQUIRE(v == vc);
 }
 
+TEST_CASE("imap: Works with different begin and end types",
+    "[imap]") {
+  CharRange cr{'d'};
+  auto m = imap([](char c) { return std::toupper(c);}, cr);
+  Vec v(m.begin(), m.end());
+  Vec vc{'A', 'B', 'C'};
+  REQUIRE(v == vc);
+}
+
 TEST_CASE("imap: works with multiple sequences", "[imap]") {
   Vec bases = {0, 1, 2, 3};
   Vec exps = {1, 2, 3, 4};

From c6f7e5591a98d80d49fdedbb886cdc35326d7de7 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 14:28:15 -0800
Subject: [PATCH 1515/1866] Tests powerset with different begin and end

---
 test/test_powerset.cpp | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/test/test_powerset.cpp b/test/test_powerset.cpp
index 923baa13..b8fb388e 100644
--- a/test/test_powerset.cpp
+++ b/test/test_powerset.cpp
@@ -1,6 +1,8 @@
 #include <powerset.hpp>
 
+#define CHAR_RANGE_DEFAULT_CONSTRUCTIBLE
 #include "helpers.hpp"
+#undef CHAR_RANGE_DEFAULT_CONSTRUCTIBLE
 
 #include <vector>
 #include <string>
@@ -31,6 +33,23 @@ TEST_CASE("powerset: basic test, [1, 2, 3]", "[powerset]") {
   REQUIRE(v == vc);
 }
 
+TEST_CASE("powerset: Works with different begin and end types",
+    "[powerset]") {
+  CharRange cr{'d'};
+  using CharPermSet = std::multiset<std::vector<char>>;
+  CharPermSet sc;
+  for (auto&& v : powerset(cr)) {
+    sc.emplace(std::begin(v), std::end(v));
+  }
+  const CharPermSet ans = {
+    {},
+    {'a'}, {'b'}, {'c'},
+    {'a', 'b'}, {'a', 'c'}, {'b', 'c'},
+    {'a', 'b', 'c'}};
+    
+  REQUIRE(ans == sc);
+}
+
 TEST_CASE("powerset: empty sequence gives only empty set", "[powerset]") {
   const std::vector<int> ns = {};
   auto ps = powerset(ns);

From f7b94d7c6481df4a0aadb0b91327f6b64e7a8169 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 14:28:24 -0800
Subject: [PATCH 1516/1866] Tests sorted with different begin and end

---
 test/test_sorted.cpp | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/test/test_sorted.cpp b/test/test_sorted.cpp
index d04f9364..55a0a11c 100644
--- a/test/test_sorted.cpp
+++ b/test/test_sorted.cpp
@@ -38,6 +38,20 @@ TEST_CASE("sorted: can modify elements through sorted", "[sorted]") {
   REQUIRE(ns == vc);
 }
 
+char inc_vowels(char c) {
+  return c == 'a' || c == 'e' ? c + 10 : c;
+}
+
+TEST_CASE("sorted: Works with different begin and end types",
+    "[sorted]") {
+  using Vec = std::vector<char>;
+  CharRange cr{'g'};
+  auto s = sorted(cr, [](char x, char y){return inc_vowels(x) < inc_vowels(y);});
+  Vec v(s.begin(), s.end());
+  Vec vc{'b', 'c', 'd', 'f', 'a', 'e'};
+  REQUIRE(v == vc);
+}
+
 TEST_CASE("sorted: can iterate over unordered container", "[sorted]") {
   std::unordered_set<int> ns = {1, 3, 2, 0, 4};
   auto s = sorted(ns);

From cfb0854c157d14c0378094c8f27b2425155cc177 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 14:28:31 -0800
Subject: [PATCH 1517/1866] Tests unique_everseen with different begin and end

---
 test/test_unique_everseen.cpp | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/test/test_unique_everseen.cpp b/test/test_unique_everseen.cpp
index f83b358e..44380d27 100644
--- a/test/test_unique_everseen.cpp
+++ b/test/test_unique_everseen.cpp
@@ -46,6 +46,16 @@ TEST_CASE(
   REQUIRE(bi.was_moved_from());
 }
 
+TEST_CASE("unique everseen: Works with different begin and end types",
+    "[unique_everseen]") {
+  CharRange cr{'d'};
+  using Vec = std::vector<char>;
+  auto ue = unique_everseen(cr);
+  Vec v(ue.begin(), ue.end());
+  Vec vc{'a', 'b', 'c'};
+  REQUIRE(v == vc);
+}
+
 TEST_CASE("unique_everseen: iterator meets requirements", "[unique_everseen]") {
   std::string s{};
   auto c = unique_everseen(s);

From 844ac9d695f04af424ce04a3ccb629f72a54c519 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 14:28:37 -0800
Subject: [PATCH 1518/1866] Tests unique_justseen with different begin and end

---
 test/test_unique_justseen.cpp | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/test/test_unique_justseen.cpp b/test/test_unique_justseen.cpp
index e66bdee6..bbfb6a5d 100644
--- a/test/test_unique_justseen.cpp
+++ b/test/test_unique_justseen.cpp
@@ -35,6 +35,16 @@ TEST_CASE("unique justseen: some repeating values", "[unique_justseen]") {
   REQUIRE(v == vc);
 }
 
+TEST_CASE("unique justseen: Works with different begin and end types",
+    "[unique_justseen]") {
+  CharRange cr{'d'};
+  using Vec = std::vector<char>;
+  auto uj = unique_justseen(cr);
+  Vec v(uj.begin(), uj.end());
+  Vec vc{'a', 'b', 'c'};
+  REQUIRE(v == vc);
+}
+
 TEST_CASE("unique justseen: doesn't omit non-adjacent duplicates",
     "[unique_justseen]") {
   Vec ns = {1, 2, 3, 2, 1, 2, 3, 2, 1};

From 1134aa32808aa1e1ae4acbc9c9fba9d243375467 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 14:28:54 -0800
Subject: [PATCH 1519/1866] Tests zip with different begin and end

---
 test/test_zip.cpp | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/test/test_zip.cpp b/test/test_zip.cpp
index d8cb80e5..a5e002d8 100644
--- a/test/test_zip.cpp
+++ b/test/test_zip.cpp
@@ -29,6 +29,19 @@ TEST_CASE("zip: Simple case, same length", "[zip]") {
   REQUIRE(v == vc);
 }
 
+TEST_CASE("zip: three sequences, one sequence has different begin and end", "[zip]") {
+  using Tu = std::tuple<int, char, double>;
+  using ResVec = const std::vector<Tu>;
+  std::vector<int> iv{10, 20, 30};
+  CharRange cr('d');
+  double arr[] = {1.0, 2.0, 4.0};
+
+  auto z = zip(iv, cr, arr);
+  ResVec v(std::begin(z), std::end(z));
+  ResVec vc{Tu{10, 'a', 1.0}, Tu{20, 'b', 2.0}, Tu{30, 'c', 4.0}};
+  REQUIRE(v == vc);
+}
+
 TEST_CASE("zip: One empty, all empty", "[zip]") {
   std::vector<int> iv = {1, 2, 3};
   std::string s{};

From f78b813cda21adf8c8504eed60ef138d248a9837 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 14:29:00 -0800
Subject: [PATCH 1520/1866] Tests zip_longest with different begin and end

---
 test/test_zip_longest.cpp | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/test/test_zip_longest.cpp b/test/test_zip_longest.cpp
index c8694e9e..d7d28b61 100644
--- a/test/test_zip_longest.cpp
+++ b/test/test_zip_longest.cpp
@@ -80,6 +80,22 @@ TEST_CASE(
   }
 }
 
+TEST_CASE("zip_longest: three sequences, one sequence has different begin and end", "[zip_longest]") {
+  //using TP = const_opt_tuple</*int,*/ char>;
+  using TP = std::tuple<int, char>;
+  using ResVec = std::vector<TP>;
+
+  std::vector<int> iv{10, 20};
+  CharRange cr('c');
+
+  ResVec v;
+  for (auto&& p : zip_longest(iv, cr)) {
+    v.push_back(TP{*std::get<0>(p), *std::get<1>(p)});
+  }
+  ResVec vc{TP{10, 'a'}, TP{20, 'b'}};
+  REQUIRE(v == vc);
+}
+
 TEST_CASE(
     "zip longest: when all are empty, terminates right away", "[zip_longest]") {
   const std::vector<int> ivec{};

From 2e9d815bb5d6ae1f87fb8a06570735c3d57fa5d9 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 14:29:22 -0800
Subject: [PATCH 1521/1866] Updates iterator wrapper test

For templating on begin and end types instead of container
---
 test/test_iterator_wrapper.cpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/test/test_iterator_wrapper.cpp b/test/test_iterator_wrapper.cpp
index b3b99f2d..c133d725 100644
--- a/test/test_iterator_wrapper.cpp
+++ b/test/test_iterator_wrapper.cpp
@@ -59,7 +59,9 @@ struct DifferentTypes {
 
 // Explicit instatiations, which could cause failures if the implementation
 // details of the implementation details change.
-template class iter::impl::IteratorWrapperImpl<DifferentTypes>;
+template class iter::impl::IteratorWrapperImpl<
+iter::impl::iterator_type<DifferentTypes>,
+  iter::impl::iterator_end_type<DifferentTypes>>;
 
 using iter::impl::IteratorWrapper;
 

From cce0ce6fcbb70efa77b08043dc5cd80ddb34f9e8 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 14:39:31 -0800
Subject: [PATCH 1522/1866] clang-formats tests

---
 test/test_accumulate.cpp                    |   7 +-
 test/test_chain.cpp                         |  11 +-
 test/test_chunked.cpp                       |   7 +-
 test/test_combinations.cpp                  |   4 +-
 test/test_combinations_with_replacement.cpp |   5 +-
 test/test_compress.cpp                      |  10 +-
 test/test_count.cpp                         |   4 +-
 test/test_cycle.cpp                         |  21 ++--
 test/test_dropwhile.cpp                     |  12 +-
 test/test_enumerate.cpp                     |  10 +-
 test/test_filter.cpp                        |   9 +-
 test/test_filterfalse.cpp                   |  10 +-
 test/test_groupby.cpp                       |  11 +-
 test/test_imap.cpp                          |  11 +-
 test/test_iterator_wrapper.cpp              | 128 +++++++++++++-------
 test/test_iteratoriterator.cpp              |   2 +-
 test/test_iterbase.cpp                      |   8 +-
 test/test_mixed.cpp                         |  11 +-
 test/test_permutations.cpp                  |  12 +-
 test/test_powerset.cpp                      |  19 ++-
 test/test_product.cpp                       |   7 +-
 test/test_range.cpp                         |   6 +-
 test/test_repeat.cpp                        |   4 +-
 test/test_reversed.cpp                      |   2 +-
 test/test_slice.cpp                         |   7 +-
 test/test_sliding_window.cpp                |   8 +-
 test/test_sorted.cpp                        |  16 +--
 test/test_starmap.cpp                       |  11 +-
 test/test_takewhile.cpp                     |  12 +-
 test/test_unique_everseen.cpp               |   4 +-
 test/test_unique_justseen.cpp               |   4 +-
 test/test_zip.cpp                           |  12 +-
 test/test_zip_longest.cpp                   |  17 +--
 33 files changed, 221 insertions(+), 201 deletions(-)

diff --git a/test/test_accumulate.cpp b/test/test_accumulate.cpp
index fdab1913..7ba3ba22 100644
--- a/test/test_accumulate.cpp
+++ b/test/test_accumulate.cpp
@@ -1,9 +1,9 @@
 #include <accumulate.hpp>
 #include "helpers.hpp"
 
-#include <vector>
 #include <iterator>
 #include <string>
+#include <vector>
 
 #include "catch.hpp"
 
@@ -102,8 +102,8 @@ TEST_CASE("accumulate: iterator meets requirements", "[accumulate]") {
   REQUIRE(itertest::IsIterator<decltype(std::begin(a))>::value);
 }
 
-TEST_CASE("accumulate: Works with different begin and end types",
-    "[accumulate]") {
+TEST_CASE(
+    "accumulate: Works with different begin and end types", "[accumulate]") {
   CharRange cr{'d'};
   auto a = accumulate(cr);
   Vec v(a.begin(), a.end());
@@ -111,7 +111,6 @@ TEST_CASE("accumulate: Works with different begin and end types",
   REQUIRE(v == vc);
 }
 
-
 template <typename T>
 using ImpT = decltype(accumulate(std::declval<T>()));
 TEST_CASE("accumulate: has correct ctor and assign ops", "[accumulate]") {
diff --git a/test/test_chain.cpp b/test/test_chain.cpp
index c0c6efb7..fbb28cc4 100644
--- a/test/test_chain.cpp
+++ b/test/test_chain.cpp
@@ -1,12 +1,11 @@
-#include "helpers.hpp"
 #include <chain.hpp>
+#include "helpers.hpp"
 
-#include <vector>
+#include <iterator>
 #include <list>
 #include <string>
-#include <vector>
-#include <iterator>
 #include <utility>
+#include <vector>
 
 #include "catch.hpp"
 
@@ -39,8 +38,8 @@ TEST_CASE("chain: with different container types", "[chain]") {
   REQUIRE(v == vc);
 }
 
-TEST_CASE("chain: where one container has different begin and end types",
-    "[chain]") {
+TEST_CASE(
+    "chain: where one container has different begin and end types", "[chain]") {
   std::string s1{"abc"};
   std::list<char> li{'m', 'n', 'o'};
   CharRange cr('e');
diff --git a/test/test_chunked.cpp b/test/test_chunked.cpp
index 2ecfc8c4..533bec05 100644
--- a/test/test_chunked.cpp
+++ b/test/test_chunked.cpp
@@ -1,12 +1,12 @@
 #include <chunked.hpp>
 
-#include <vector>
 #include <array>
 #include <string>
 #include <utility>
+#include <vector>
 
-#include "helpers.hpp"
 #include "catch.hpp"
+#include "helpers.hpp"
 
 using iter::chunked;
 using Vec = std::vector<int>;
@@ -60,8 +60,7 @@ TEST_CASE("chunked: size 0 is empty", "[chunked]") {
   REQUIRE(std::begin(g) == std::end(g));
 }
 
-TEST_CASE("chunked: Works with different begin and end types",
-    "[chunked]") {
+TEST_CASE("chunked: Works with different begin and end types", "[chunked]") {
   CharRange cr{'f'};
   std::vector<std::vector<char>> results;
   for (auto&& g : chunked(cr, 3)) {
diff --git a/test/test_combinations.cpp b/test/test_combinations.cpp
index ef4e4653..974b0798 100644
--- a/test/test_combinations.cpp
+++ b/test/test_combinations.cpp
@@ -6,10 +6,10 @@
 
 #include <combinations.hpp>
 
+#include <iterator>
 #include <set>
-#include <vector>
 #include <string>
-#include <iterator>
+#include <vector>
 
 #include "catch.hpp"
 
diff --git a/test/test_combinations_with_replacement.cpp b/test/test_combinations_with_replacement.cpp
index 9540588d..905450f5 100644
--- a/test/test_combinations_with_replacement.cpp
+++ b/test/test_combinations_with_replacement.cpp
@@ -1,8 +1,8 @@
 #include <combinations_with_replacement.hpp>
 
 #include <iterator>
-#include <string>
 #include <set>
+#include <string>
 #include <vector>
 
 #define CHAR_RANGE_DEFAULT_CONSTRUCTIBLE
@@ -33,7 +33,8 @@ TEST_CASE("combinations_with_replacement: Simple combination",
   REQUIRE(ans == sc);
 }
 
-TEST_CASE("combinations_with_replacement: Works with different begin and end types",
+TEST_CASE(
+    "combinations_with_replacement: Works with different begin and end types",
     "[combinations_with_replacement]") {
   CharRange cr{'d'};
   CharCombSet sc;
diff --git a/test/test_compress.cpp b/test/test_compress.cpp
index 7938b23a..5b13b345 100644
--- a/test/test_compress.cpp
+++ b/test/test_compress.cpp
@@ -1,11 +1,10 @@
-#include "helpers.hpp"
 #include <compress.hpp>
+#include "helpers.hpp"
 
-#include <vector>
-#include <string>
-#include <vector>
 #include <iterator>
+#include <string>
 #include <utility>
+#include <vector>
 
 #include "catch.hpp"
 
@@ -136,8 +135,7 @@ TEST_CASE("compress: iterator meets requirements", "[compress]") {
   REQUIRE(itertest::IsIterator<decltype(std::begin(c))>::value);
 }
 
-TEST_CASE("compress: Works with different begin and end types",
-    "[compress]") {
+TEST_CASE("compress: Works with different begin and end types", "[compress]") {
   CharRange cr{'d'};
   auto c = compress(cr, std::vector<bool>{true, false, true});
   Vec v(c.begin(), c.end());
diff --git a/test/test_count.cpp b/test/test_count.cpp
index 643819ea..d1f0ff65 100644
--- a/test/test_count.cpp
+++ b/test/test_count.cpp
@@ -1,9 +1,9 @@
-#include "helpers.hpp"
 #include <count.hpp>
+#include "helpers.hpp"
 
-#include <vector>
 #include <iterator>
 #include <utility>
+#include <vector>
 
 #include "catch.hpp"
 
diff --git a/test/test_cycle.cpp b/test/test_cycle.cpp
index 3066d00d..39e3bb19 100644
--- a/test/test_cycle.cpp
+++ b/test/test_cycle.cpp
@@ -2,9 +2,9 @@
 
 #include "helpers.hpp"
 
-#include <vector>
-#include <string>
 #include <iterator>
+#include <string>
+#include <vector>
 
 #include "catch.hpp"
 
@@ -17,7 +17,9 @@ TEST_CASE("cycle: iterate twice", "[cycle]") {
   for (auto i : cycle(ns)) {
     v.push_back(i);
     ++count;
-    if (count == ns.size() * 2) { break; }
+    if (count == ns.size() * 2) {
+      break;
+    }
   }
 
   auto vc = ns;
@@ -25,8 +27,7 @@ TEST_CASE("cycle: iterate twice", "[cycle]") {
   REQUIRE(v == vc);
 }
 
-TEST_CASE("cycle: Works with different begin and end types",
-    "[cycle]") {
+TEST_CASE("cycle: Works with different begin and end types", "[cycle]") {
   constexpr auto sz = 'd' - 'a';
   CharRange cr{'d'};
   const std::vector<char> vc{'a', 'b', 'c', 'a', 'b', 'c'};
@@ -35,14 +36,14 @@ TEST_CASE("cycle: Works with different begin and end types",
   for (auto i : cycle(cr)) {
     v.push_back(i);
     ++count;
-    if (count == sz * 2) { break; }
+    if (count == sz * 2) {
+      break;
+    }
   }
 
   REQUIRE(v == vc);
 }
 
-
-
 TEST_CASE("cycle: with pipe", "[cycle]") {
   std::vector<int> ns{2, 4, 6};
   std::vector<int> v;
@@ -50,7 +51,9 @@ TEST_CASE("cycle: with pipe", "[cycle]") {
   for (auto i : ns | cycle) {
     v.push_back(i);
     ++count;
-    if (count == ns.size() * 2) { break; } 
+    if (count == ns.size() * 2) {
+      break;
+    }
   }
 
   auto vc = ns;
diff --git a/test/test_dropwhile.cpp b/test/test_dropwhile.cpp
index aba3ec09..49b4e49a 100644
--- a/test/test_dropwhile.cpp
+++ b/test/test_dropwhile.cpp
@@ -2,9 +2,9 @@
 
 #include "helpers.hpp"
 
-#include <vector>
-#include <string>
 #include <iterator>
+#include <string>
+#include <vector>
 
 #include "catch.hpp"
 
@@ -27,10 +27,10 @@ TEST_CASE("dropwhile: skips initial elements", "[dropwhile]") {
   REQUIRE(v == vc);
 }
 
-TEST_CASE("dropwhile: Works with different begin and end types",
-    "[dropwhile]") {
+TEST_CASE(
+    "dropwhile: Works with different begin and end types", "[dropwhile]") {
   CharRange cr{'f'};
-  auto d = dropwhile([](char c){return c < 'c';}, cr);
+  auto d = dropwhile([](char c) { return c < 'c'; }, cr);
   Vec v(d.begin(), d.end());
   Vec vc{'c', 'd', 'e'};
   REQUIRE(v == vc);
@@ -52,7 +52,7 @@ TEST_CASE("dropwhile: skips all elements when all are true under predicate",
 }
 
 TEST_CASE("dropwhile: identity", "[dropwhile]") {
-  Vec ns {1, 2, 0, 3, 1, 0};
+  Vec ns{1, 2, 0, 3, 1, 0};
   auto d = dropwhile(ns);
   Vec v(std::begin(d), std::end(d));
   Vec vc = {0, 3, 1, 0};
diff --git a/test/test_enumerate.cpp b/test/test_enumerate.cpp
index 3b8f56ac..33666dc6 100644
--- a/test/test_enumerate.cpp
+++ b/test/test_enumerate.cpp
@@ -2,11 +2,11 @@
 
 #include "helpers.hpp"
 
-#include <vector>
-#include <string>
 #include <iterator>
-#include <utility>
 #include <sstream>
+#include <string>
+#include <utility>
+#include <vector>
 
 namespace Catch {
   template <typename A, typename B>
@@ -148,8 +148,8 @@ TEST_CASE("enumerate: works index and pipe", "[enumerate]") {
   REQUIRE(v == vc);
 }
 
-TEST_CASE("enumerate: Works with different begin and end types",
-    "[enumerate]") {
+TEST_CASE(
+    "enumerate: Works with different begin and end types", "[enumerate]") {
   CharRange cr{'d'};
   auto e = enumerate(cr);
   Vec v(e.begin(), e.end());
diff --git a/test/test_filter.cpp b/test/test_filter.cpp
index d5c1aed3..4badfaf1 100644
--- a/test/test_filter.cpp
+++ b/test/test_filter.cpp
@@ -2,9 +2,9 @@
 
 #include "helpers.hpp"
 
-#include <vector>
-#include <string>
 #include <iterator>
+#include <string>
+#include <vector>
 
 #include "catch.hpp"
 
@@ -145,10 +145,9 @@ TEST_CASE("filter: using identity and pipe", "[filter]") {
   REQUIRE(v == vc);
 }
 
-TEST_CASE("filter: Works with different begin and end types",
-    "[filter]") {
+TEST_CASE("filter: Works with different begin and end types", "[filter]") {
   CharRange cr{'d'};
-  auto f = filter([](char c){return c != 'b';}, cr);
+  auto f = filter([](char c) { return c != 'b'; }, cr);
   Vec v(f.begin(), f.end());
   Vec vc{'a', 'c'};
   REQUIRE(v == vc);
diff --git a/test/test_filterfalse.cpp b/test/test_filterfalse.cpp
index dbf826fd..dec5c2eb 100644
--- a/test/test_filterfalse.cpp
+++ b/test/test_filterfalse.cpp
@@ -2,9 +2,9 @@
 
 #include "helpers.hpp"
 
-#include <vector>
-#include <string>
 #include <iterator>
+#include <string>
+#include <vector>
 
 #include "catch.hpp"
 
@@ -60,10 +60,10 @@ TEST_CASE("filterfalse: handles different functor types", "[filterfalse]") {
   }
 }
 
-TEST_CASE("filterfalse: Works with different begin and end types",
-    "[filterfalse]") {
+TEST_CASE(
+    "filterfalse: Works with different begin and end types", "[filterfalse]") {
   CharRange cr{'d'};
-  auto f = filterfalse([](char c){return c == 'b';}, cr);
+  auto f = filterfalse([](char c) { return c == 'b'; }, cr);
   Vec v(f.begin(), f.end());
   Vec vc{'a', 'c'};
   REQUIRE(v == vc);
diff --git a/test/test_groupby.cpp b/test/test_groupby.cpp
index c353b491..cc1b824a 100644
--- a/test/test_groupby.cpp
+++ b/test/test_groupby.cpp
@@ -2,9 +2,9 @@
 
 #include "helpers.hpp"
 
-#include <vector>
-#include <string>
 #include <iterator>
+#include <string>
+#include <vector>
 
 #include "catch.hpp"
 
@@ -69,17 +69,16 @@ TEST_CASE("groupby: works with lambda, callable, and function pointer") {
   REQUIRE(groups == gc);
 }
 
-TEST_CASE("groupby: Works with different begin and end types",
-    "[groupby]") {
+TEST_CASE("groupby: Works with different begin and end types", "[groupby]") {
   CharRange cr{'f'};
   std::vector<bool> keys;
   std::vector<std::vector<char>> groups;
-  for (auto&& gb : groupby(cr, [](char c){return c == 'c';})) {
+  for (auto&& gb : groupby(cr, [](char c) { return c == 'c'; })) {
     keys.push_back(gb.first);
     groups.emplace_back(std::begin(gb.second), std::end(gb.second));
   }
   const std::vector<bool> kc = {false, true, false};
-  const std::vector<std::vector<char>> gc = {{'a' ,'b'}, {'c'}, {'d', 'e'}};
+  const std::vector<std::vector<char>> gc = {{'a', 'b'}, {'c'}, {'d', 'e'}};
   REQUIRE(keys == kc);
   REQUIRE(groups == gc);
 }
diff --git a/test/test_imap.cpp b/test/test_imap.cpp
index 2ab1f5a6..e7c2bcd2 100644
--- a/test/test_imap.cpp
+++ b/test/test_imap.cpp
@@ -2,10 +2,10 @@
 
 #include "helpers.hpp"
 
-#include <vector>
-#include <string>
-#include <iterator>
 #include <cctype>
+#include <iterator>
+#include <string>
+#include <vector>
 
 #include "catch.hpp"
 
@@ -61,10 +61,9 @@ TEST_CASE("imap: works with lambda, callable, and function", "[imap]") {
   REQUIRE(v == vc);
 }
 
-TEST_CASE("imap: Works with different begin and end types",
-    "[imap]") {
+TEST_CASE("imap: Works with different begin and end types", "[imap]") {
   CharRange cr{'d'};
-  auto m = imap([](char c) { return std::toupper(c);}, cr);
+  auto m = imap([](char c) { return std::toupper(c); }, cr);
   Vec v(m.begin(), m.end());
   Vec vc{'A', 'B', 'C'};
   REQUIRE(v == vc);
diff --git a/test/test_iterator_wrapper.cpp b/test/test_iterator_wrapper.cpp
index c133d725..6c79a278 100644
--- a/test/test_iterator_wrapper.cpp
+++ b/test/test_iterator_wrapper.cpp
@@ -1,8 +1,7 @@
 // NOTE this header tests implementation details
 
-#include "internal/iterator_wrapper.hpp"
 #include "catch.hpp"
-
+#include "internal/iterator_wrapper.hpp"
 
 // I'm using a std::vector of 1 int instead of just an int in order to give
 // the iterator types non-trivial constructors, destructors, and assignment.
@@ -10,62 +9,101 @@
 // same begin() and end() types
 struct SameTypes {
   struct iterator {
-    iterator(int) : value_(1) { }
-
-    bool operator!=(const iterator& other) const { return value_ != other.value_; }
-    iterator& operator++() { ++value_.front(); return *this; }
-    const int& operator*() const { return value_.front(); }
-    std::vector<int> value_; // non-trvial operations
+    iterator(int) : value_(1) {}
+
+    bool operator!=(const iterator& other) const {
+      return value_ != other.value_;
+    }
+    iterator& operator++() {
+      ++value_.front();
+      return *this;
+    }
+    const int& operator*() const {
+      return value_.front();
+    }
+    std::vector<int> value_;  // non-trvial operations
   };
 
-  iterator begin() const { return {0}; }
-  iterator end() const { return {0}; }
+  iterator begin() const {
+    return {0};
+  }
+  iterator end() const {
+    return {0};
+  }
 };
 
-
 // different begin() and end() types
 struct DifferentTypes {
   struct iterator;
   struct end_iterator;
   struct iterator {
-    iterator() : value_{} { REQUIRE(false); }
+    iterator() : value_{} {
+      REQUIRE(false);
+    }
     iterator(int i) : value_(1, i) {}
 
-    bool operator!=(const iterator& other) const { return value() != other.value(); }
-    bool operator!=(const end_iterator&) const { return value() != 3; }
-    iterator& operator++() { ++value_.front(); return *this; }
-    const int& operator*() const { return value(); }
-
-    const int& value() const { return value_.front(); }
+    bool operator!=(const iterator& other) const {
+      return value() != other.value();
+    }
+    bool operator!=(const end_iterator&) const {
+      return value() != 3;
+    }
+    iterator& operator++() {
+      ++value_.front();
+      return *this;
+    }
+    const int& operator*() const {
+      return value();
+    }
+
+    const int& value() const {
+      return value_.front();
+    }
     std::vector<int> value_;
   };
 
   struct end_iterator {
-    end_iterator() { REQUIRE(false); }
-    end_iterator(int){}
-
-    bool operator!=(const end_iterator&) const { return false; }
-    bool operator!=(const iterator& other) const { return other.value() != 3; }
-    end_iterator& operator++() { return *this; }
-    const int& operator*() const { assert(false); return value(); }
-
-    const int& value() const { return value_.front(); }
+    end_iterator() {
+      REQUIRE(false);
+    }
+    end_iterator(int) {}
+
+    bool operator!=(const end_iterator&) const {
+      return false;
+    }
+    bool operator!=(const iterator& other) const {
+      return other.value() != 3;
+    }
+    end_iterator& operator++() {
+      return *this;
+    }
+    const int& operator*() const {
+      assert(false);
+      return value();
+    }
+
+    const int& value() const {
+      return value_.front();
+    }
     std::vector<int> value_{};
   };
 
-  iterator begin() const { return {0}; }
-  end_iterator end() const { return {0}; }
+  iterator begin() const {
+    return {0};
+  }
+  end_iterator end() const {
+    return {0};
+  }
 };
 
 // Explicit instatiations, which could cause failures if the implementation
 // details of the implementation details change.
-template class iter::impl::IteratorWrapperImpl<
-iter::impl::iterator_type<DifferentTypes>,
-  iter::impl::iterator_end_type<DifferentTypes>>;
+template class iter::impl::
+    IteratorWrapperImpl<iter::impl::iterator_type<DifferentTypes>,
+        iter::impl::iterator_end_type<DifferentTypes>>;
 
 using iter::impl::IteratorWrapper;
 
-
 TEST_CASE("ensure test type iterators are totally comparable", "[test_util") {
   {
     SameTypes s{};
@@ -84,14 +122,12 @@ TEST_CASE("ensure test type iterators are totally comparable", "[test_util") {
   }
 }
 
-
-TEST_CASE("Operations on IteratorWrappers with SameTypes work",
-    "[base_iterator]") {
+TEST_CASE(
+    "Operations on IteratorWrappers with SameTypes work", "[base_iterator]") {
   SameTypes s;
   IteratorWrapper<SameTypes> it(s.begin());
-  REQUIRE((std::is_same<
-        std::decay_t<decltype(it)>,
-        std::decay_t<decltype(s.begin())>>{}));
+  REQUIRE((std::is_same<std::decay_t<decltype(it)>,
+      std::decay_t<decltype(s.begin())>>{}));
   REQUIRE(*it == 0);
   ++it;
   REQUIRE(*it == 1);
@@ -102,9 +138,8 @@ TEST_CASE("Operations on IteratorWrappers with DifferentTypes work",
   DifferentTypes d;
   using BI = IteratorWrapper<DifferentTypes>;
   BI it(d.begin());
-  REQUIRE((!std::is_same<
-        std::decay_t<decltype(it)>,
-        std::decay_t<decltype(d.begin())>>{}));
+  REQUIRE((!std::is_same<std::decay_t<decltype(it)>,
+           std::decay_t<decltype(d.begin())>>{}));
   REQUIRE(*it == 0);
   ++it;
   REQUIRE(*it == 1);
@@ -128,8 +163,8 @@ TEST_CASE("Operations on IteratorWrappers with DifferentTypes work",
   REQUIRE_FALSE(bend != it);
 }
 
-TEST_CASE("Can copy construct a IteratorWrapper with SameTypes",
-    "[base_iterator]") {
+TEST_CASE(
+    "Can copy construct a IteratorWrapper with SameTypes", "[base_iterator]") {
   SameTypes s;
   using BI = IteratorWrapper<SameTypes>;
   BI it(s.begin());
@@ -139,8 +174,8 @@ TEST_CASE("Can copy construct a IteratorWrapper with SameTypes",
   REQUIRE(it != it2);
 }
 
-
-TEST_CASE("Can copy assign a IteratorWrapper with SameTypes", "[base_iterator]") {
+TEST_CASE(
+    "Can copy assign a IteratorWrapper with SameTypes", "[base_iterator]") {
   SameTypes s;
   using BI = IteratorWrapper<SameTypes>;
   BI it(s.begin());
@@ -183,6 +218,5 @@ TEST_CASE("Can copy construct a IteratorWrapper with DifferenTypes",
     REQUIRE_FALSE(it != it_end);
   }
 }
-  
 
 // TODO test move operations
diff --git a/test/test_iteratoriterator.cpp b/test/test_iteratoriterator.cpp
index c3abd95a..c4442f7a 100644
--- a/test/test_iteratoriterator.cpp
+++ b/test/test_iteratoriterator.cpp
@@ -1,7 +1,7 @@
 #include <internal/iteratoriterator.hpp>
 
-#include <vector>
 #include <string>
+#include <vector>
 
 #include "catch.hpp"
 
diff --git a/test/test_iterbase.cpp b/test/test_iterbase.cpp
index a19247da..59b80066 100644
--- a/test/test_iterbase.cpp
+++ b/test/test_iterbase.cpp
@@ -2,13 +2,13 @@
 // on any of this.  Users of the library must consider all of this undocumented
 //
 
+#include <enumerate.hpp>
 #include <internal/iterbase.hpp>
-#include <type_traits>
-#include <vector>
 #include <iterator>
-#include <string>
 #include <list>
-#include <enumerate.hpp>
+#include <string>
+#include <type_traits>
+#include <vector>
 
 #include "catch.hpp"
 #include "helpers.hpp"
diff --git a/test/test_mixed.cpp b/test/test_mixed.cpp
index cc607e64..ecf65091 100644
--- a/test/test_mixed.cpp
+++ b/test/test_mixed.cpp
@@ -123,7 +123,7 @@ TEST_CASE("takewhile doesn't dereference multiple times", "[imap][takewhile]") {
 }
 
 TEST_CASE("sorted(chain.from_iterable)", "[sorted][chain.from_iterable]") {
-  std::vector<std::vector<int>> v = {{2,4,6}};
+  std::vector<std::vector<int>> v = {{2, 4, 6}};
   auto s = iter::sorted(iter::chain.from_iterable(v));
 }
 
@@ -133,10 +133,11 @@ TEST_CASE("filter into enumerate with pipe", "[filter][enumerate]") {
   using iter::enumerate;
 
   std::array<MyUnMovable, 4> arr = {{{41}, {42}, {43}, {44}}};
-  auto seq = arr
-    | filter([](const MyUnMovable& mv) { return mv.get_val() % 2 == 0; })
-    | enumerate
-    | imap([] (const auto& imv) { return std::make_pair(imv.first, imv.second.get_val());});
+  auto seq =
+      arr | filter([](const MyUnMovable& mv) { return mv.get_val() % 2 == 0; })
+      | enumerate | imap([](const auto& imv) {
+          return std::make_pair(imv.first, imv.second.get_val());
+        });
   using Vec = std::vector<std::pair<std::size_t, int>>;
   const Vec v(std::begin(seq), std::end(seq));
   const Vec vc = {{0, 42}, {1, 44}};
diff --git a/test/test_permutations.cpp b/test/test_permutations.cpp
index a2ab49ee..d07c6ffd 100644
--- a/test/test_permutations.cpp
+++ b/test/test_permutations.cpp
@@ -2,9 +2,9 @@
 
 #include "helpers.hpp"
 
-#include <vector>
-#include <string>
 #include <iterator>
+#include <string>
+#include <vector>
 
 #include "catch.hpp"
 
@@ -39,11 +39,9 @@ TEST_CASE("permutations: Works with different begin and end types",
   for (auto&& v : permutations(cr)) {
     sc.emplace(std::begin(v), std::end(v));
   }
-  const CharPermSet ans = {
-    {'a', 'b', 'c'}, {'a', 'c', 'b'},
-    {'b', 'a', 'c'}, {'b', 'c', 'a'},
-    {'c', 'a', 'b'}, {'c', 'b', 'a'}};
-    
+  const CharPermSet ans = {{'a', 'b', 'c'}, {'a', 'c', 'b'}, {'b', 'a', 'c'},
+      {'b', 'c', 'a'}, {'c', 'a', 'b'}, {'c', 'b', 'a'}};
+
   REQUIRE(ans == sc);
 }
 
diff --git a/test/test_powerset.cpp b/test/test_powerset.cpp
index b8fb388e..cfc8515d 100644
--- a/test/test_powerset.cpp
+++ b/test/test_powerset.cpp
@@ -4,9 +4,9 @@
 #include "helpers.hpp"
 #undef CHAR_RANGE_DEFAULT_CONSTRUCTIBLE
 
-#include <vector>
-#include <string>
 #include <iterator>
+#include <string>
+#include <vector>
 
 #include "catch.hpp"
 
@@ -28,25 +28,20 @@ TEST_CASE("powerset: basic test, [1, 2, 3]", "[powerset]") {
   }
 
   const IntPermSet vc = {
-    std::multiset<int>{}, {1}, {2}, {3},
-      {1, 2}, {1, 3}, {2, 3}, {1, 2, 3}};
+      std::multiset<int>{}, {1}, {2}, {3}, {1, 2}, {1, 3}, {2, 3}, {1, 2, 3}};
   REQUIRE(v == vc);
 }
 
-TEST_CASE("powerset: Works with different begin and end types",
-    "[powerset]") {
+TEST_CASE("powerset: Works with different begin and end types", "[powerset]") {
   CharRange cr{'d'};
   using CharPermSet = std::multiset<std::vector<char>>;
   CharPermSet sc;
   for (auto&& v : powerset(cr)) {
     sc.emplace(std::begin(v), std::end(v));
   }
-  const CharPermSet ans = {
-    {},
-    {'a'}, {'b'}, {'c'},
-    {'a', 'b'}, {'a', 'c'}, {'b', 'c'},
-    {'a', 'b', 'c'}};
-    
+  const CharPermSet ans = {{}, {'a'}, {'b'}, {'c'}, {'a', 'b'}, {'a', 'c'},
+      {'b', 'c'}, {'a', 'b', 'c'}};
+
   REQUIRE(ans == sc);
 }
 
diff --git a/test/test_product.cpp b/test/test_product.cpp
index 4f9f1d2c..f5303e4f 100644
--- a/test/test_product.cpp
+++ b/test/test_product.cpp
@@ -2,9 +2,9 @@
 
 #include "helpers.hpp"
 
-#include <vector>
-#include <string>
 #include <iterator>
+#include <string>
+#include <vector>
 
 #include "catch.hpp"
 
@@ -26,7 +26,8 @@ TEST_CASE("product: basic test, two sequences", "[product]") {
   REQUIRE(v == vc);
 }
 
-TEST_CASE("product: two sequences where one has different begin and end", "[product]") {
+TEST_CASE("product: two sequences where one has different begin and end",
+    "[product]") {
   using TP = std::tuple<int, char>;
   using ResType = std::vector<TP>;
 
diff --git a/test/test_range.cpp b/test/test_range.cpp
index 52482df0..c7705d41 100644
--- a/test/test_range.cpp
+++ b/test/test_range.cpp
@@ -1,11 +1,11 @@
 #include "range.hpp"
 
-#include <vector>
-#include <iterator>
 #include <algorithm>
+#include <iterator>
+#include <vector>
 
-#include "helpers.hpp"
 #include "catch.hpp"
+#include "helpers.hpp"
 
 using Vec = const std::vector<int>;
 using iter::range;
diff --git a/test/test_repeat.cpp b/test/test_repeat.cpp
index 3cd928df..df42c99c 100644
--- a/test/test_repeat.cpp
+++ b/test/test_repeat.cpp
@@ -2,9 +2,9 @@
 
 #include "helpers.hpp"
 
-#include <vector>
-#include <string>
 #include <iterator>
+#include <string>
+#include <vector>
 
 #include "catch.hpp"
 
diff --git a/test/test_reversed.cpp b/test/test_reversed.cpp
index 2ccf5d2f..81ea1d4f 100644
--- a/test/test_reversed.cpp
+++ b/test/test_reversed.cpp
@@ -1,9 +1,9 @@
 #include <reversed.hpp>
 
-#include <vector>
 #include <array>
 #include <string>
 #include <utility>
+#include <vector>
 
 #include "catch.hpp"
 
diff --git a/test/test_slice.cpp b/test/test_slice.cpp
index 8cb3ee66..385e6c12 100644
--- a/test/test_slice.cpp
+++ b/test/test_slice.cpp
@@ -1,11 +1,11 @@
 #include <slice.hpp>
 
-#include <vector>
 #include <string>
 #include <utility>
+#include <vector>
 
-#include "helpers.hpp"
 #include "catch.hpp"
+#include "helpers.hpp"
 
 using iter::slice;
 using Vec = const std::vector<int>;
@@ -44,8 +44,7 @@ TEST_CASE("slice: start and stop", "[slice]") {
   REQUIRE(v == vc);
 }
 
-TEST_CASE("slice: Works with different begin and end types",
-    "[slice]") {
+TEST_CASE("slice: Works with different begin and end types", "[slice]") {
   CharRange cr{'z'};
   auto sl = slice(cr, 2, 5);
   std::vector<char> v(std::begin(sl), std::end(sl));
diff --git a/test/test_sliding_window.cpp b/test/test_sliding_window.cpp
index 8400aedf..21d93679 100644
--- a/test/test_sliding_window.cpp
+++ b/test/test_sliding_window.cpp
@@ -1,12 +1,12 @@
 #include <sliding_window.hpp>
 
-#include <vector>
 #include <array>
 #include <string>
 #include <utility>
+#include <vector>
 
-#include "helpers.hpp"
 #include "catch.hpp"
+#include "helpers.hpp"
 
 using iter::sliding_window;
 using Vec = const std::vector<int>;
@@ -36,9 +36,7 @@ TEST_CASE("sliding_window: Works with different begin and end types",
     results.emplace_back(std::begin(g), std::end(g));
   }
   std::vector<std::vector<char>> rc = {
-    {'a', 'b', 'c'},
-    {'b', 'c', 'd'},
-    {'c', 'd', 'e'}};
+      {'a', 'b', 'c'}, {'b', 'c', 'd'}, {'c', 'd', 'e'}};
   REQUIRE(results == rc);
 }
 
diff --git a/test/test_sorted.cpp b/test/test_sorted.cpp
index 55a0a11c..054b1eda 100644
--- a/test/test_sorted.cpp
+++ b/test/test_sorted.cpp
@@ -1,14 +1,14 @@
 #include <sorted.hpp>
 
-#include <set>
-#include <unordered_set>
-#include <vector>
 #include <array>
+#include <set>
 #include <string>
+#include <unordered_set>
 #include <utility>
+#include <vector>
 
-#include "helpers.hpp"
 #include "catch.hpp"
+#include "helpers.hpp"
 
 using iter::sorted;
 
@@ -42,11 +42,11 @@ char inc_vowels(char c) {
   return c == 'a' || c == 'e' ? c + 10 : c;
 }
 
-TEST_CASE("sorted: Works with different begin and end types",
-    "[sorted]") {
+TEST_CASE("sorted: Works with different begin and end types", "[sorted]") {
   using Vec = std::vector<char>;
   CharRange cr{'g'};
-  auto s = sorted(cr, [](char x, char y){return inc_vowels(x) < inc_vowels(y);});
+  auto s =
+      sorted(cr, [](char x, char y) { return inc_vowels(x) < inc_vowels(y); });
   Vec v(s.begin(), s.end());
   Vec vc{'b', 'c', 'd', 'f', 'a', 'e'};
   REQUIRE(v == vc);
@@ -193,7 +193,7 @@ TEST_CASE("sorted: moves rvalues and binds to lvalues", "[sorted]") {
 TEST_CASE("sorted: doesn't move or copy elements of iterable", "[sorted]") {
   using itertest::SolidInt;
   constexpr SolidInt arr[] = {{6}, {7}, {8}};
-  for (auto &&i : sorted(arr, [](const SolidInt &lhs, const SolidInt &rhs) {
+  for (auto &&i : sorted(arr, [](const SolidInt&lhs, const SolidInt&rhs) {
          return lhs.getint() < rhs.getint();
        })) {
     (void)i;
diff --git a/test/test_starmap.cpp b/test/test_starmap.cpp
index 6f1e7d7b..55e94503 100644
--- a/test/test_starmap.cpp
+++ b/test/test_starmap.cpp
@@ -2,10 +2,10 @@
 
 #include "helpers.hpp"
 
-#include <vector>
+#include <iterator>
 #include <list>
 #include <string>
-#include <iterator>
+#include <vector>
 
 #include "catch.hpp"
 
@@ -57,13 +57,10 @@ TEST_CASE("starmap: works with function pointer and lambda", "[starmap]") {
   REQUIRE(v == vc);
 }
 
-TEST_CASE("starmap: Works with different begin and end types",
-    "[starmap]") {
+TEST_CASE("starmap: Works with different begin and end types", "[starmap]") {
   IntCharPairRange icr{{3, 'd'}};
   using Vec = std::vector<std::string>;
-  auto sm = starmap([](int i, char c) {
-      return std::to_string(i) + c;},
-      icr);
+  auto sm = starmap([](int i, char c) { return std::to_string(i) + c; }, icr);
   Vec v(sm.begin(), sm.end());
   Vec vc{"0a", "1b", "2c"};
   REQUIRE(v == vc);
diff --git a/test/test_takewhile.cpp b/test/test_takewhile.cpp
index 202e99ab..14a739c1 100644
--- a/test/test_takewhile.cpp
+++ b/test/test_takewhile.cpp
@@ -1,12 +1,12 @@
 #include <takewhile.hpp>
 
-#include <vector>
 #include <array>
 #include <string>
 #include <utility>
+#include <vector>
 
-#include "helpers.hpp"
 #include "catch.hpp"
+#include "helpers.hpp"
 
 using iter::takewhile;
 using Vec = const std::vector<int>;
@@ -57,10 +57,10 @@ TEST_CASE("takewhile: works with lambda, callable, and function pointer",
   }
 }
 
-TEST_CASE("takewhile: Works with different begin and end types",
-    "[takewhile]") {
+TEST_CASE(
+    "takewhile: Works with different begin and end types", "[takewhile]") {
   CharRange cr{'f'};
-  auto t = takewhile([](char c){return c < 'd';}, cr);
+  auto t = takewhile([](char c) { return c < 'd'; }, cr);
   Vec v(t.begin(), t.end());
   Vec vc{'a', 'b', 'c'};
   REQUIRE(v == vc);
@@ -77,7 +77,7 @@ TEST_CASE("takewhile: identity", "[takewhile]") {
     auto tw = ns | takewhile;
     v.assign(std::begin(tw), std::end(tw));
   }
-  Vec vc = {1,2,3};
+  Vec vc = {1, 2, 3};
   REQUIRE(v == vc);
 }
 
diff --git a/test/test_unique_everseen.cpp b/test/test_unique_everseen.cpp
index 44380d27..03bc6439 100644
--- a/test/test_unique_everseen.cpp
+++ b/test/test_unique_everseen.cpp
@@ -2,9 +2,9 @@
 
 #include "helpers.hpp"
 
-#include <vector>
-#include <string>
 #include <iterator>
+#include <string>
+#include <vector>
 
 #include "catch.hpp"
 
diff --git a/test/test_unique_justseen.cpp b/test/test_unique_justseen.cpp
index bbfb6a5d..3d7dabc7 100644
--- a/test/test_unique_justseen.cpp
+++ b/test/test_unique_justseen.cpp
@@ -2,9 +2,9 @@
 
 #include "helpers.hpp"
 
-#include <vector>
-#include <string>
 #include <iterator>
+#include <string>
+#include <vector>
 
 #include "catch.hpp"
 
diff --git a/test/test_zip.cpp b/test/test_zip.cpp
index a5e002d8..b0312e1e 100644
--- a/test/test_zip.cpp
+++ b/test/test_zip.cpp
@@ -2,13 +2,12 @@
 
 #include "helpers.hpp"
 
-#include <vector>
-#include <tuple>
-#include <string>
 #include <iterator>
-#include <utility>
 #include <sstream>
-#include <iterator>
+#include <string>
+#include <tuple>
+#include <utility>
+#include <vector>
 
 #include "catch.hpp"
 
@@ -29,7 +28,8 @@ TEST_CASE("zip: Simple case, same length", "[zip]") {
   REQUIRE(v == vc);
 }
 
-TEST_CASE("zip: three sequences, one sequence has different begin and end", "[zip]") {
+TEST_CASE(
+    "zip: three sequences, one sequence has different begin and end", "[zip]") {
   using Tu = std::tuple<int, char, double>;
   using ResVec = const std::vector<Tu>;
   std::vector<int> iv{10, 20, 30};
diff --git a/test/test_zip_longest.cpp b/test/test_zip_longest.cpp
index d7d28b61..85b8ee31 100644
--- a/test/test_zip_longest.cpp
+++ b/test/test_zip_longest.cpp
@@ -2,14 +2,13 @@
 
 #include "helpers.hpp"
 
-#include <vector>
-#include <tuple>
-#include <string>
-#include <iterator>
-#include <utility>
+#include <iostream>
 #include <iterator>
 #include <sstream>
-#include <iostream>
+#include <string>
+#include <tuple>
+#include <utility>
+#include <vector>
 
 #include "catch.hpp"
 
@@ -80,8 +79,10 @@ TEST_CASE(
   }
 }
 
-TEST_CASE("zip_longest: three sequences, one sequence has different begin and end", "[zip_longest]") {
-  //using TP = const_opt_tuple</*int,*/ char>;
+TEST_CASE(
+    "zip_longest: three sequences, one sequence has different begin and end",
+    "[zip_longest]") {
+  // using TP = const_opt_tuple</*int,*/ char>;
   using TP = std::tuple<int, char>;
   using ResVec = std::vector<TP>;
 

From 1330973210bab3eb11e8a15974b12f8ef9ccdabc Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 14:40:01 -0800
Subject: [PATCH 1523/1866] clang-format

---
 accumulate.hpp                    |  12 +-
 chain.hpp                         |  20 +-
 chunked.hpp                       |  10 +-
 combinations.hpp                  |   6 +-
 combinations_with_replacement.hpp |   4 +-
 compress.hpp                      |   5 +-
 cycle.hpp                         |   6 +-
 dropwhile.hpp                     |  10 +-
 enumerate.hpp                     |   6 +-
 filter.hpp                        |  14 +-
 filterfalse.hpp                   |   2 +-
 groupby.hpp                       |  11 +-
 imap.hpp                          |   2 +-
 internal/iter_tuples.hpp          |   2 +-
 internal/iterator_wrapper.hpp     | 298 +++++++++++++++---------------
 internal/iteratoriterator.hpp     |  11 +-
 internal/iterbase.hpp             |  13 +-
 itertools.hpp                     |   4 +-
 permutations.hpp                  |  11 +-
 powerset.hpp                      |   6 +-
 product.hpp                       |   4 +-
 range.hpp                         |  20 +-
 repeat.hpp                        |   2 +-
 slice.hpp                         |   7 +-
 sliding_window.hpp                |  11 +-
 sorted.hpp                        |   7 +-
 starmap.hpp                       |  13 +-
 takewhile.hpp                     |  10 +-
 unique_everseen.hpp               |   8 +-
 unique_justseen.hpp               |  10 +-
 zip.hpp                           |   2 +-
 zip_longest.hpp                   |   2 +-
 32 files changed, 272 insertions(+), 277 deletions(-)
 mode change 100755 => 100644 internal/iterator_wrapper.hpp

diff --git a/accumulate.hpp b/accumulate.hpp
index cad5f29c..875ab8c8 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -1,14 +1,14 @@
 #ifndef ITER_ACCUMULATE_H_
 #define ITER_ACCUMULATE_H_
 
-#include "internal/iterbase.hpp"
 #include "internal/iterator_wrapper.hpp"
+#include "internal/iterbase.hpp"
 
-#include <utility>
-#include <iterator>
 #include <functional>
-#include <type_traits>
+#include <iterator>
 #include <memory>
+#include <type_traits>
+#include <utility>
 
 namespace iter {
   namespace impl {
@@ -46,8 +46,8 @@ class iter::impl::Accumulator {
     std::unique_ptr<AccumVal> acc_val;
 
    public:
-    Iterator(IteratorWrapper<Container>&& iter, IteratorWrapper<Container>&& end,
-        AccumulateFunc& in_accumulate_fun)
+    Iterator(IteratorWrapper<Container>&& iter,
+        IteratorWrapper<Container>&& end, AccumulateFunc& in_accumulate_fun)
         : sub_iter{std::move(iter)},
           sub_end{std::move(end)},
           accumulate_func(&in_accumulate_fun),
diff --git a/chain.hpp b/chain.hpp
index 44e6f94f..99e57cac 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -1,9 +1,9 @@
 #ifndef ITER_CHAIN_HPP_
 #define ITER_CHAIN_HPP_
 
-#include "internal/iterbase.hpp"
-#include "internal/iterator_wrapper.hpp"
 #include "internal/iter_tuples.hpp"
+#include "internal/iterator_wrapper.hpp"
+#include "internal/iterbase.hpp"
 
 #include <array>
 #include <iterator>
@@ -156,19 +156,23 @@ class iter::impl::Chained {
 
 template <typename TupType, std::size_t... Is>
 constexpr std::array<typename iter::impl::Chained<TupType, Is...>::DerefFunc,
-    sizeof...(Is)> iter::impl::Chained<TupType, Is...>::derefers;
+    sizeof...(Is)>
+    iter::impl::Chained<TupType, Is...>::derefers;
 
 template <typename TupType, std::size_t... Is>
 constexpr std::array<typename iter::impl::Chained<TupType, Is...>::ArrowFunc,
-    sizeof...(Is)> iter::impl::Chained<TupType, Is...>::arrowers;
+    sizeof...(Is)>
+    iter::impl::Chained<TupType, Is...>::arrowers;
 
 template <typename TupType, std::size_t... Is>
 constexpr std::array<typename iter::impl::Chained<TupType, Is...>::IncFunc,
-    sizeof...(Is)> iter::impl::Chained<TupType, Is...>::incrementers;
+    sizeof...(Is)>
+    iter::impl::Chained<TupType, Is...>::incrementers;
 
 template <typename TupType, std::size_t... Is>
 constexpr std::array<typename iter::impl::Chained<TupType, Is...>::NeqFunc,
-    sizeof...(Is)> iter::impl::Chained<TupType, Is...>::neq_comparers;
+    sizeof...(Is)>
+    iter::impl::Chained<TupType, Is...>::neq_comparers;
 
 template <typename Container>
 class iter::impl::ChainedFromIterable {
@@ -208,8 +212,8 @@ class iter::impl::ChainedFromIterable {
     }
 
    public:
-    Iterator(
-        IteratorWrapper<Container>&& top_iter, IteratorWrapper<Container>&& top_end)
+    Iterator(IteratorWrapper<Container>&& top_iter,
+        IteratorWrapper<Container>&& top_end)
         : top_level_iter{std::move(top_iter)},
           top_level_end{std::move(top_end)},
           sub_iter_p{!(top_iter != top_end)
diff --git a/chunked.hpp b/chunked.hpp
index a0009896..0b79a80c 100644
--- a/chunked.hpp
+++ b/chunked.hpp
@@ -1,16 +1,16 @@
 #ifndef ITER_CHUNKED_HPP_
 #define ITER_CHUNKED_HPP_
 
-#include "internal/iterbase.hpp"
-#include "internal/iteratoriterator.hpp"
 #include "internal/iterator_wrapper.hpp"
+#include "internal/iteratoriterator.hpp"
+#include "internal/iterbase.hpp"
 
-#include <vector>
 #include <algorithm>
-#include <type_traits>
 #include <functional>
-#include <utility>
 #include <iterator>
+#include <type_traits>
+#include <utility>
+#include <vector>
 
 namespace iter {
   namespace impl {
diff --git a/combinations.hpp b/combinations.hpp
index d90e21c6..e6de19c5 100644
--- a/combinations.hpp
+++ b/combinations.hpp
@@ -1,12 +1,12 @@
 #ifndef ITER_COMBINATIONS_HPP_
 #define ITER_COMBINATIONS_HPP_
 
-#include "internal/iterbase.hpp"
 #include "internal/iteratoriterator.hpp"
+#include "internal/iterbase.hpp"
 
-#include <vector>
-#include <type_traits>
 #include <iterator>
+#include <type_traits>
+#include <vector>
 
 namespace iter {
   namespace impl {
diff --git a/combinations_with_replacement.hpp b/combinations_with_replacement.hpp
index cfc04957..2257543a 100644
--- a/combinations_with_replacement.hpp
+++ b/combinations_with_replacement.hpp
@@ -1,12 +1,12 @@
 #ifndef ITER_COMBINATIONS_WITH_REPLACEMENT_HPP_
 #define ITER_COMBINATIONS_WITH_REPLACEMENT_HPP_
 
-#include "internal/iterbase.hpp"
 #include "internal/iteratoriterator.hpp"
+#include "internal/iterbase.hpp"
 
 #include <iterator>
-#include <vector>
 #include <type_traits>
+#include <vector>
 
 namespace iter {
   namespace impl {
diff --git a/compress.hpp b/compress.hpp
index 0482298d..b1d11f7c 100644
--- a/compress.hpp
+++ b/compress.hpp
@@ -1,11 +1,11 @@
 #ifndef ITER_COMPRESS_H_
 #define ITER_COMPRESS_H_
 
-#include "internal/iterbase.hpp"
 #include "internal/iterator_wrapper.hpp"
+#include "internal/iterbase.hpp"
 
-#include <utility>
 #include <iterator>
+#include <utility>
 
 namespace iter {
   namespace impl {
@@ -15,7 +15,6 @@ namespace iter {
 
   template <typename Container, typename Selector>
   impl::Compressed<Container, Selector> compress(Container&&, Selector&&);
-
 }
 
 template <typename Container, typename Selector>
diff --git a/cycle.hpp b/cycle.hpp
index b416553f..51bed25c 100644
--- a/cycle.hpp
+++ b/cycle.hpp
@@ -1,12 +1,12 @@
 #ifndef ITER_CYCLE_H_
 #define ITER_CYCLE_H_
 
-#include "internal/iterbase.hpp"
 #include "internal/iterator_wrapper.hpp"
+#include "internal/iterbase.hpp"
 
-#include <utility>
-#include <iterator>
 #include <initializer_list>
+#include <iterator>
+#include <utility>
 
 namespace iter {
   namespace impl {
diff --git a/dropwhile.hpp b/dropwhile.hpp
index 1f8c587d..4aceb371 100644
--- a/dropwhile.hpp
+++ b/dropwhile.hpp
@@ -1,12 +1,12 @@
 #ifndef ITER_DROPWHILE_H_
 #define ITER_DROPWHILE_H_
 
-#include "internal/iterbase.hpp"
-#include "internal/iterator_wrapper.hpp"
 #include "filter.hpp"
+#include "internal/iterator_wrapper.hpp"
+#include "internal/iterbase.hpp"
 
-#include <utility>
 #include <iterator>
+#include <utility>
 
 namespace iter {
   namespace impl {
@@ -57,8 +57,8 @@ class iter::impl::Dropper {
     }
 
    public:
-    Iterator(IteratorWrapper<Container>&& iter, IteratorWrapper<Container>&& end,
-        FilterFunc& in_filter_func)
+    Iterator(IteratorWrapper<Container>&& iter,
+        IteratorWrapper<Container>&& end, FilterFunc& in_filter_func)
         : sub_iter{std::move(iter)},
           sub_end{std::move(end)},
           filter_func(&in_filter_func) {
diff --git a/enumerate.hpp b/enumerate.hpp
index 3f4ab47c..02201b90 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -1,14 +1,14 @@
 #ifndef ITER_ENUMERATE_H_
 #define ITER_ENUMERATE_H_
 
-#include "internal/iterbase.hpp"
 #include "internal/iterator_wrapper.hpp"
+#include "internal/iterbase.hpp"
 
-#include <utility>
-#include <iterator>
 #include <functional>
 #include <initializer_list>
+#include <iterator>
 #include <type_traits>
+#include <utility>
 
 namespace iter {
   namespace impl {
diff --git a/filter.hpp b/filter.hpp
index 42ad09bd..69838cbf 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -1,12 +1,12 @@
 #ifndef ITER_FILTER_H_
 #define ITER_FILTER_H_
 
-#include "internal/iterbase.hpp"
 #include "internal/iterator_wrapper.hpp"
+#include "internal/iterbase.hpp"
 
-#include <utility>
-#include <iterator>
 #include <initializer_list>
+#include <iterator>
+#include <utility>
 
 namespace iter {
   namespace impl {
@@ -69,9 +69,11 @@ class iter::impl::Filtered {
     }
 
    public:
-    Iterator(IteratorWrapper<Container>&& iter, IteratorWrapper<Container>&& end,
-        FilterFunc& in_filter_func)
-        : sub_iter{std::move(iter)}, sub_end{std::move(end)}, filter_func(&in_filter_func) {
+    Iterator(IteratorWrapper<Container>&& iter,
+        IteratorWrapper<Container>&& end, FilterFunc& in_filter_func)
+        : sub_iter{std::move(iter)},
+          sub_end{std::move(end)},
+          filter_func(&in_filter_func) {
       if (this->sub_iter != this->sub_end) {
         this->item.reset(*this->sub_iter);
       }
diff --git a/filterfalse.hpp b/filterfalse.hpp
index 513962f7..f46aba2a 100644
--- a/filterfalse.hpp
+++ b/filterfalse.hpp
@@ -1,8 +1,8 @@
 #ifndef ITER_FILTER_FALSE_HPP_
 #define ITER_FILTER_FALSE_HPP_
 
-#include "internal/iterbase.hpp"
 #include "filter.hpp"
+#include "internal/iterbase.hpp"
 
 #include <utility>
 
diff --git a/groupby.hpp b/groupby.hpp
index e0a5f53a..24c8c048 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -3,13 +3,13 @@
 
 // this is easily the most functionally complex itertool
 
-#include "internal/iterbase.hpp"
 #include "internal/iterator_wrapper.hpp"
+#include "internal/iterbase.hpp"
 
-#include <type_traits>
+#include <iterator>
 #include <memory>
+#include <type_traits>
 #include <utility>
-#include <iterator>
 
 namespace iter {
   namespace impl {
@@ -193,9 +193,8 @@ class iter::impl::GroupProducer {
     }
 
     // move-constructible, non-copy-constructible, non-assignable
-    Group(Group&& other) noexcept : owner(other.owner),
-                                    key{other.key},
-                                    completed{other.completed} {
+    Group(Group&& other) noexcept
+        : owner(other.owner), key{other.key}, completed{other.completed} {
       other.completed = true;
     }
 
diff --git a/imap.hpp b/imap.hpp
index 807a2826..f022e6d0 100644
--- a/imap.hpp
+++ b/imap.hpp
@@ -1,8 +1,8 @@
 #ifndef ITER_IMAP_H_
 #define ITER_IMAP_H_
 
-#include "zip.hpp"
 #include "starmap.hpp"
+#include "zip.hpp"
 
 #include <utility>
 
diff --git a/internal/iter_tuples.hpp b/internal/iter_tuples.hpp
index 8e68f16e..cfba2cf3 100644
--- a/internal/iter_tuples.hpp
+++ b/internal/iter_tuples.hpp
@@ -1,8 +1,8 @@
 #ifndef ITERTOOLS_ITER_TUPLES_HPP_
 #define ITERTOOLS_ITER_TUPLES_HPP_
 
-#include "iterbase.hpp"
 #include "iterator_wrapper.hpp"
+#include "iterbase.hpp"
 
 namespace iter {
   namespace impl {
diff --git a/internal/iterator_wrapper.hpp b/internal/iterator_wrapper.hpp
old mode 100755
new mode 100644
index 1f5e5536..a181539f
--- a/internal/iterator_wrapper.hpp
+++ b/internal/iterator_wrapper.hpp
@@ -1,174 +1,170 @@
 #ifndef ITERTOOLS_ITERATOR_WRAPPER_HPP_
 #define ITERTOOLS_ITERATOR_WRAPPER_HPP_
 
-#include "iterbase.hpp"
 #include <cassert>
+#include "iterbase.hpp"
 
 namespace iter {
-namespace impl {
-// iterator_end_type<C> is the type of C's end iterator
-template <typename Container>
-using iterator_end_type = decltype(std::end(std::declval<Container&>()));
-
-template <typename SubIter, typename SubEnd>
-class IteratorWrapperImpl;
-
-
-// If begin and end return the same type, type will be iterator_type<Container>
-// If begin and end return different types, type will be IteratorWrapperImpl
-template <typename Container, bool same_types>
-struct IteratorWrapperImplType;
-
-template <typename Container>
-struct IteratorWrapperImplType<Container, true>
-: type_is<iterator_type<Container>>{};
-
-template <typename Container>
-struct IteratorWrapperImplType<Container, false>
-: type_is<IteratorWrapperImpl<iterator_type<Container>, iterator_end_type<Container>>>{};
-
-template <typename Container>
-using IteratorWrapper = typename IteratorWrapperImplType<Container,
-      std::is_same<impl::iterator_type<Container>,
-                   impl::iterator_end_type<Container>>{}>::type;
-}
+  namespace impl {
+    // iterator_end_type<C> is the type of C's end iterator
+    template <typename Container>
+    using iterator_end_type = decltype(std::end(std::declval<Container&>()));
+
+    template <typename SubIter, typename SubEnd>
+    class IteratorWrapperImpl;
+
+    // If begin and end return the same type, type will be
+    // iterator_type<Container>
+    // If begin and end return different types, type will be IteratorWrapperImpl
+    template <typename Container, bool same_types>
+    struct IteratorWrapperImplType;
+
+    template <typename Container>
+    struct IteratorWrapperImplType<Container, true>
+        : type_is<iterator_type<Container>> {};
+
+    template <typename Container>
+    struct IteratorWrapperImplType<Container, false>
+        : type_is<IteratorWrapperImpl<iterator_type<Container>,
+              iterator_end_type<Container>>> {};
+
+    template <typename Container>
+    using IteratorWrapper = typename IteratorWrapperImplType<Container,
+        std::is_same<impl::iterator_type<Container>,
+            impl::iterator_end_type<Container>>{}>::type;
+  }
 }
 
 template <typename SubIter, typename SubEnd>
 class iter::impl::IteratorWrapperImpl {
-  private:
-    static_assert(
-        !std::is_same<SubIter, SubEnd>{},
-        "");
-    enum class IterState { Normal, End, Uninitialized};
+ private:
+  static_assert(!std::is_same<SubIter, SubEnd>{}, "");
+  enum class IterState { Normal, End, Uninitialized };
+
+  void destroy_sub() {
+    if (state_ == IterState::Normal) {
+      sub_iter_.~SubIter();
+    } else if (state_ == IterState::End) {
+      sub_end_.~SubEnd();
+    }
+    state_ = IterState::Uninitialized;
+  }
 
-    void destroy_sub() {
+  template <typename T>
+  void copy_or_move_sub_from(T&& other) {
+    if (this == &other) {
+      return;
+    }
+    if (state_ == other.state_) {
       if (state_ == IterState::Normal) {
-        sub_iter_.~SubIter();
+        sub_iter_ = std::forward<T>(other).sub_iter_;
       } else if (state_ == IterState::End) {
-        sub_end_.~SubEnd();
+        sub_end_ = std::forward<T>(other).sub_end_;
       }
-      state_ = IterState::Uninitialized;
-    }
-
-    template <typename T>
-    void copy_or_move_sub_from(T&& other) {
-      if (this == &other) { return; }
-      if (state_ == other.state_) {
-        if (state_ == IterState::Normal) {
-          sub_iter_ = std::forward<T>(other).sub_iter_;
-        } else if (state_ == IterState::End) {
-          sub_end_ = std::forward<T>(other).sub_end_;
-        }
-      } else {
-        // state_s are different, must destroy and reconstruct
-        destroy_sub();
-        if (other.state_ == IterState::Normal) {
-          new (&sub_iter_) SubIter(std::forward<T>(other).sub_iter_);
-        } else if (other.state_ == IterState::End) {
-          new (&sub_end_) SubEnd(std::forward<T>(other).sub_end_);
-        }
-        state_ = other.state_;
+    } else {
+      // state_s are different, must destroy and reconstruct
+      destroy_sub();
+      if (other.state_ == IterState::Normal) {
+        new (&sub_iter_) SubIter(std::forward<T>(other).sub_iter_);
+      } else if (other.state_ == IterState::End) {
+        new (&sub_end_) SubEnd(std::forward<T>(other).sub_end_);
       }
+      state_ = other.state_;
     }
-
-
-    void copy_sub_from(const IteratorWrapperImpl& other) {
-      copy_or_move_sub_from(other);
-    }
-
-    void move_sub_from(IteratorWrapperImpl&& other) {
-      copy_or_move_sub_from(std::move(other));
-    }
-
-    // TODO replace with std::variant when C++17 is going strong
-    union {
-      SubIter sub_iter_;
-      SubEnd sub_end_;
-    };
-    IterState state_{IterState::Uninitialized};
-
-  public:
-    IteratorWrapperImpl() : IteratorWrapperImpl(SubIter{}) {}
-
-    IteratorWrapperImpl(const IteratorWrapperImpl& other) {
-      copy_sub_from(other);
-    }
-
-    IteratorWrapperImpl& operator=(const IteratorWrapperImpl& other) {
-      copy_sub_from(other);
-      return *this;
-    }
-
-    IteratorWrapperImpl(IteratorWrapperImpl&& other) {
-      move_sub_from(std::move(other));
-    }
-
-    IteratorWrapperImpl& operator=(IteratorWrapperImpl&& other) {
-      move_sub_from(std::move(other));
-      return *this;
-    }
-
-    IteratorWrapperImpl(SubIter&& it)
-      : sub_iter_{std::move(it)},
-      state_{IterState::Normal} { }
-
-    IteratorWrapperImpl(SubEnd&& it)
-      : sub_end_(std::move(it)),
-      state_{IterState::End} { }
-
-    IteratorWrapperImpl& operator++() {
-      assert(state_ == IterState::Normal); // because ++ing the end is UB
-      ++sub_iter_;
-      return *this;
-    }
-
-    decltype(auto) operator*() {
-      assert(state_ == IterState::Normal); //because *ing the end is UB
-      return *sub_iter_;
-    }
-
-    decltype(auto) operator*() const {
-      assert(state_ == IterState::Normal); //because *ing the end is UB
-      return *sub_iter_;
-    }
-
-    decltype(auto) operator->() {
-      assert(state_ == IterState::Normal);
-      return apply_arrow(sub_iter_);
-    }
-
-    decltype(auto) operator->() const {
-      assert(state_ == IterState::Normal);
-      return apply_arrow(sub_iter_);
-    }
-
-    bool operator!=(const IteratorWrapperImpl& other) const {
-      assert(state_ != IterState::Uninitialized
-          && other.state_ != IterState::Uninitialized);
-      if (state_ == other.state_) {
-        if (state_ == IterState::End) {
-          // NOTE this used to be return sub_end_ != other.sub_end_;
-          // but rangev3 sentinels aren't comparable
-          // https://github.com/ericniebler/range-v3/issues/564
-          return false;
-        } else {
-          return sub_iter_ != other.sub_iter_;
-        }
+  }
+
+  void copy_sub_from(const IteratorWrapperImpl& other) {
+    copy_or_move_sub_from(other);
+  }
+
+  void move_sub_from(IteratorWrapperImpl&& other) {
+    copy_or_move_sub_from(std::move(other));
+  }
+
+  // TODO replace with std::variant when C++17 is going strong
+  union {
+    SubIter sub_iter_;
+    SubEnd sub_end_;
+  };
+  IterState state_{IterState::Uninitialized};
+
+ public:
+  IteratorWrapperImpl() : IteratorWrapperImpl(SubIter{}) {}
+
+  IteratorWrapperImpl(const IteratorWrapperImpl& other) {
+    copy_sub_from(other);
+  }
+
+  IteratorWrapperImpl& operator=(const IteratorWrapperImpl& other) {
+    copy_sub_from(other);
+    return *this;
+  }
+
+  IteratorWrapperImpl(IteratorWrapperImpl&& other) {
+    move_sub_from(std::move(other));
+  }
+
+  IteratorWrapperImpl& operator=(IteratorWrapperImpl&& other) {
+    move_sub_from(std::move(other));
+    return *this;
+  }
+
+  IteratorWrapperImpl(SubIter&& it)
+      : sub_iter_{std::move(it)}, state_{IterState::Normal} {}
+
+  IteratorWrapperImpl(SubEnd&& it)
+      : sub_end_(std::move(it)), state_{IterState::End} {}
+
+  IteratorWrapperImpl& operator++() {
+    assert(state_ == IterState::Normal);  // because ++ing the end is UB
+    ++sub_iter_;
+    return *this;
+  }
+
+  decltype(auto) operator*() {
+    assert(state_ == IterState::Normal);  // because *ing the end is UB
+    return *sub_iter_;
+  }
+
+  decltype(auto) operator*() const {
+    assert(state_ == IterState::Normal);  // because *ing the end is UB
+    return *sub_iter_;
+  }
+
+  decltype(auto) operator-> () {
+    assert(state_ == IterState::Normal);
+    return apply_arrow(sub_iter_);
+  }
+
+  decltype(auto) operator-> () const {
+    assert(state_ == IterState::Normal);
+    return apply_arrow(sub_iter_);
+  }
+
+  bool operator!=(const IteratorWrapperImpl& other) const {
+    assert(state_ != IterState::Uninitialized
+           && other.state_ != IterState::Uninitialized);
+    if (state_ == other.state_) {
+      if (state_ == IterState::End) {
+        // NOTE this used to be return sub_end_ != other.sub_end_;
+        // but rangev3 sentinels aren't comparable
+        // https://github.com/ericniebler/range-v3/issues/564
+        return false;
       } else {
-        if(state_ == IterState::Normal) { // other is End
-          return sub_iter_ != other.sub_end_;
-        } else { // other is Normal
-          return sub_end_ != other.sub_iter_;
-        }
+        return sub_iter_ != other.sub_iter_;
+      }
+    } else {
+      if (state_ == IterState::Normal) {  // other is End
+        return sub_iter_ != other.sub_end_;
+      } else {  // other is Normal
+        return sub_end_ != other.sub_iter_;
       }
     }
+  }
 
-    ~IteratorWrapperImpl() {
-      this->destroy_sub();
-    }
-
+  ~IteratorWrapperImpl() {
+    this->destroy_sub();
+  }
 };
 
-
 #endif
diff --git a/internal/iteratoriterator.hpp b/internal/iteratoriterator.hpp
index a49b4b06..23bde9d5 100644
--- a/internal/iteratoriterator.hpp
+++ b/internal/iteratoriterator.hpp
@@ -1,10 +1,10 @@
 #ifndef ITERATOR_ITERATOR_HPP_
 #define ITERATOR_ITERATOR_HPP_
 
-#include "iterbase.hpp"
 #include <iterator>
 #include <type_traits>
 #include <utility>
+#include "iterbase.hpp"
 
 // IterIterWrapper and IteratorIterator provide a means to have a container
 // of iterators act like a container of the pointed to objects. This is useful
@@ -25,11 +25,12 @@ namespace iter {
     template <typename TopIter>
     class IteratorIterator
         : public std::iterator<std::random_access_iterator_tag,
-                               typename std::remove_reference<decltype(
-                                   **std::declval<TopIter>())>::type> {
+              typename std::remove_reference<decltype(
+                  **std::declval<TopIter>())>::type> {
       using Diff = std::ptrdiff_t;
       static_assert(
-          std::is_same<typename std::iterator_traits<TopIter>::iterator_category,
+          std::is_same<
+              typename std::iterator_traits<TopIter>::iterator_category,
               std::random_access_iterator_tag>::value,
           "IteratorIterator only works with random access iterators");
 
@@ -74,7 +75,7 @@ namespace iter {
         return **this->sub_iter;
       }
 
-      auto operator -> () -> decltype(*sub_iter) {
+      auto operator-> () -> decltype(*sub_iter) {
         return *this->sub_iter;
       }
 
diff --git a/internal/iterbase.hpp b/internal/iterbase.hpp
index 8f73cb0d..032d8e00 100644
--- a/internal/iterbase.hpp
+++ b/internal/iterbase.hpp
@@ -7,13 +7,13 @@
 // also applies to the name of the file.  No user code should include
 // this file directly.
 
-#include <utility>
-#include <tuple>
-#include <iterator>
+#include <cstddef>
 #include <functional>
+#include <iterator>
 #include <memory>
+#include <tuple>
 #include <type_traits>
-#include <cstddef>
+#include <utility>
 
 namespace iter {
   namespace impl {
@@ -178,8 +178,7 @@ namespace iter {
     Distance dumb_size(Container&& container) {
       Distance d{0};
       auto end_it = std::end(container);
-      for (auto it = std::begin(container);
-           it != end_it; ++it) {
+      for (auto it = std::begin(container); it != end_it; ++it) {
         ++d;
       }
       return d;
@@ -335,7 +334,7 @@ namespace iter {
      protected:
       template <typename Container>
       auto operator()(Container&& container, std::false_type) const {
-        return static_cast<const Base&> (*this)(
+        return static_cast<const Base&>(*this)(
             std::forward<Container>(container));
       }
 
diff --git a/itertools.hpp b/itertools.hpp
index 939d6919..7dd9b9a8 100644
--- a/itertools.hpp
+++ b/itertools.hpp
@@ -3,6 +3,7 @@
 
 #include "accumulate.hpp"
 #include "chain.hpp"
+#include "chunked.hpp"
 #include "combinations.hpp"
 #include "combinations_with_replacement.hpp"
 #include "compress.hpp"
@@ -13,9 +14,7 @@
 #include "filter.hpp"
 #include "filterfalse.hpp"
 #include "groupby.hpp"
-#include "chunked.hpp"
 #include "imap.hpp"
-#include "sliding_window.hpp"
 #include "permutations.hpp"
 #include "powerset.hpp"
 #include "product.hpp"
@@ -23,6 +22,7 @@
 #include "repeat.hpp"
 #include "reversed.hpp"
 #include "slice.hpp"
+#include "sliding_window.hpp"
 #include "sorted.hpp"
 #include "starmap.hpp"
 #include "takewhile.hpp"
diff --git a/permutations.hpp b/permutations.hpp
index 0e6c3aa5..4d895fa1 100644
--- a/permutations.hpp
+++ b/permutations.hpp
@@ -1,15 +1,15 @@
 #ifndef ITER_PERMUTATIONS_HPP_
 #define ITER_PERMUTATIONS_HPP_
 
-#include "internal/iterbase.hpp"
-#include "internal/iteratoriterator.hpp"
 #include "internal/iterator_wrapper.hpp"
+#include "internal/iteratoriterator.hpp"
+#include "internal/iterbase.hpp"
 
 #include <algorithm>
 #include <initializer_list>
-#include <vector>
-#include <utility>
 #include <iterator>
+#include <utility>
+#include <vector>
 
 namespace iter {
   namespace impl {
@@ -47,8 +47,7 @@ class iter::impl::Permuter {
     int steps{};
 
    public:
-    Iterator(
-        IteratorWrapper<Container>&& sub_iter,
+    Iterator(IteratorWrapper<Container>&& sub_iter,
         IteratorWrapper<Container>&& sub_end)
         : steps{sub_iter != sub_end ? 0 : COMPLETE} {
       // done like this instead of using vector ctor with
diff --git a/powerset.hpp b/powerset.hpp
index c0ea0ade..68aab5f8 100644
--- a/powerset.hpp
+++ b/powerset.hpp
@@ -1,15 +1,15 @@
 #ifndef ITER_POWERSET_HPP_
 #define ITER_POWERSET_HPP_
 
-#include "internal/iterbase.hpp"
 #include "combinations.hpp"
+#include "internal/iterbase.hpp"
 
 #include <cassert>
-#include <memory>
 #include <initializer_list>
-#include <utility>
 #include <iterator>
+#include <memory>
 #include <type_traits>
+#include <utility>
 
 namespace iter {
   namespace impl {
diff --git a/product.hpp b/product.hpp
index 3b1b5572..31eb9555 100644
--- a/product.hpp
+++ b/product.hpp
@@ -1,13 +1,13 @@
 #ifndef ITER_PRODUCT_HPP_
 #define ITER_PRODUCT_HPP_
 
-#include "internal/iterbase.hpp"
 #include "internal/iterator_wrapper.hpp"
+#include "internal/iterbase.hpp"
 
+#include <array>
 #include <iterator>
 #include <tuple>
 #include <utility>
-#include <array>
 
 namespace iter {
   namespace impl {
diff --git a/range.hpp b/range.hpp
index 67a0c267..0aafa7de 100644
--- a/range.hpp
+++ b/range.hpp
@@ -3,10 +3,10 @@
 
 #include "internal/iterbase.hpp"
 
+#include <cassert>
 #include <exception>
-#include <type_traits>
 #include <iterator>
-#include <cassert>
+#include <type_traits>
 
 namespace iter {
   namespace impl {
@@ -37,8 +37,7 @@ namespace iter {
      public:
       constexpr RangeIterData() noexcept = default;
       constexpr RangeIterData(T in_value, T in_step) noexcept
-          : value_{in_value},
-            step_{in_step} {}
+          : value_{in_value}, step_{in_step} {}
 
       constexpr T value() const noexcept {
         return this->value_;
@@ -73,9 +72,7 @@ namespace iter {
      public:
       constexpr RangeIterData() noexcept = default;
       constexpr RangeIterData(T in_start, T in_step) noexcept
-          : start_{in_start},
-            value_{in_start},
-            step_{in_step} {}
+          : start_{in_start}, value_{in_start}, step_{in_step} {}
 
       constexpr T value() const noexcept {
         return this->value_;
@@ -124,9 +121,7 @@ class iter::impl::Range {
   constexpr Range(T in_stop) noexcept : start{0}, stop{in_stop}, step{1} {}
 
   constexpr Range(T in_start, T in_stop, T in_step = 1) noexcept
-      : start{in_start},
-        stop{in_stop},
-        step{in_step} {}
+      : start{in_start}, stop{in_stop}, step{in_step} {}
 
  public:
   // the reference type here is T, which doesn't strictly follow all
@@ -170,8 +165,7 @@ class iter::impl::Range {
     constexpr Iterator() noexcept = default;
 
     constexpr Iterator(T in_value, T in_step, bool in_is_end) noexcept
-        : data(in_value, in_step),
-          is_end{in_is_end} {}
+        : data(in_value, in_step), is_end{in_is_end} {}
 
     constexpr T operator*() const noexcept {
       return this->data.value();
@@ -186,7 +180,7 @@ class iter::impl::Range {
       return *this;
     }
 
-    Iterator operator++(int) noexcept {
+    Iterator operator++(int)noexcept {
       auto ret = *this;
       ++*this;
       return ret;
diff --git a/repeat.hpp b/repeat.hpp
index c33d40c5..0dd8cf91 100644
--- a/repeat.hpp
+++ b/repeat.hpp
@@ -119,7 +119,7 @@ class iter::impl::Repeater {
       return *this;
     }
 
-    constexpr Iterator operator++(int) const {
+    constexpr Iterator operator++(int)const {
       return *this;
     }
 
diff --git a/slice.hpp b/slice.hpp
index df2ce0a2..c1d21e3a 100644
--- a/slice.hpp
+++ b/slice.hpp
@@ -1,8 +1,8 @@
 #ifndef ITER_SLICE_HPP_
 #define ITER_SLICE_HPP_
 
-#include "internal/iterbase.hpp"
 #include "internal/iterator_wrapper.hpp"
+#include "internal/iterbase.hpp"
 
 #include <iterator>
 #include <type_traits>
@@ -111,9 +111,8 @@ struct iter::impl::SliceFn {
    private:
     friend SliceFn;
     constexpr FnPartial(DifferenceType in_start, DifferenceType in_stop,
-        DifferenceType in_step) noexcept : start{in_start},
-                                           stop{in_stop},
-                                           step{in_step} {}
+        DifferenceType in_step) noexcept
+        : start{in_start}, stop{in_stop}, step{in_step} {}
     DifferenceType start;
     DifferenceType stop;
     DifferenceType step;
diff --git a/sliding_window.hpp b/sliding_window.hpp
index 6a68faaa..2dc6e81d 100644
--- a/sliding_window.hpp
+++ b/sliding_window.hpp
@@ -1,13 +1,13 @@
 #ifndef ITER_SLIDING_WINDOW_HPP_
 #define ITER_SLIDING_WINDOW_HPP_
 
-#include "internal/iterbase.hpp"
 #include "internal/iterator_wrapper.hpp"
 #include "internal/iteratoriterator.hpp"
+#include "internal/iterbase.hpp"
 
 #include <deque>
-#include <utility>
 #include <iterator>
+#include <utility>
 
 namespace iter {
   namespace impl {
@@ -41,7 +41,7 @@ class iter::impl::WindowSlider {
 
    public:
     Iterator(IteratorWrapper<Container>&& in_iter,
-         IteratorWrapper<Container>&& in_end, std::size_t window_sz)
+        IteratorWrapper<Container>&& in_end, std::size_t window_sz)
         : sub_iter(std::move(in_iter)) {
       std::size_t i{0};
       while (i < window_sz && this->sub_iter != in_end) {
@@ -84,8 +84,9 @@ class iter::impl::WindowSlider {
   };
 
   Iterator begin() {
-    return {(this->window_size != 0 ? IteratorWrapper<Container>{std::begin(this->container)}
-                                    : IteratorWrapper<Container>{std::end(this->container)}),
+    return {(this->window_size != 0
+                    ? IteratorWrapper<Container>{std::begin(this->container)}
+                    : IteratorWrapper<Container>{std::end(this->container)}),
         std::end(this->container), this->window_size};
   }
 
diff --git a/sorted.hpp b/sorted.hpp
index 529b8dcc..5393d3a7 100644
--- a/sorted.hpp
+++ b/sorted.hpp
@@ -1,11 +1,11 @@
 #ifndef ITER_SORTED_HPP_
 #define ITER_SORTED_HPP_
 
-#include "internal/iterbase.hpp"
 #include "internal/iteratoriterator.hpp"
+#include "internal/iterbase.hpp"
 
-#include <iterator>
 #include <algorithm>
+#include <iterator>
 #include <vector>
 
 namespace iter {
@@ -38,8 +38,7 @@ class iter::impl::SortedView {
     }
 
     // sort by comparing the elements that the iterators point to
-    std::sort(
-        std::begin(sorted_iters.get()), std::end(sorted_iters.get()),
+    std::sort(std::begin(sorted_iters.get()), std::end(sorted_iters.get()),
         [compare_func](iterator_type<Container> it1,
             iterator_type<Container> it2) { return compare_func(*it1, *it2); });
   }
diff --git a/starmap.hpp b/starmap.hpp
index 7570e03e..1521b5a4 100644
--- a/starmap.hpp
+++ b/starmap.hpp
@@ -1,15 +1,15 @@
 #ifndef ITER_STARMAP_H_
 #define ITER_STARMAP_H_
 
-#include "internal/iterbase.hpp"
 #include "internal/iterator_wrapper.hpp"
+#include "internal/iterbase.hpp"
 
-#include <utility>
-#include <iterator>
-#include <type_traits>
 #include <array>
 #include <cassert>
+#include <iterator>
 #include <memory>
+#include <type_traits>
+#include <utility>
 
 namespace iter {
   namespace impl {
@@ -169,7 +169,8 @@ class iter::impl::TupleStarMapper {
 template <typename Func, typename TupType, std::size_t... Is>
 constexpr std::array<
     typename iter::impl::TupleStarMapper<Func, TupType, Is...>::CallerFunc,
-    sizeof...(Is)> iter::impl::TupleStarMapper<Func, TupType, Is...>::callers;
+    sizeof...(Is)>
+    iter::impl::TupleStarMapper<Func, TupType, Is...>::callers;
 
 struct iter::impl::StarMapFn : PipeableAndBindFirst<StarMapFn> {
  private:
@@ -184,7 +185,7 @@ struct iter::impl::StarMapFn : PipeableAndBindFirst<StarMapFn> {
   auto helper(Func func, TupType&& tup, std::true_type) const {
     return helper_with_tuples(std::move(func), std::forward<TupType>(tup),
         std::make_index_sequence<std::tuple_size<std::decay_t<TupType>>::
-                                      value>{});
+                value>{});
   }
 
   // handles everything else
diff --git a/takewhile.hpp b/takewhile.hpp
index f05828dd..53df6a2a 100644
--- a/takewhile.hpp
+++ b/takewhile.hpp
@@ -1,12 +1,12 @@
 #ifndef ITER_TAKEWHILE_H_
 #define ITER_TAKEWHILE_H_
 
-#include "internal/iterbase.hpp"
-#include "internal/iterator_wrapper.hpp"
 #include "filter.hpp"
+#include "internal/iterator_wrapper.hpp"
+#include "internal/iterbase.hpp"
 
-#include <utility>
 #include <iterator>
+#include <utility>
 
 namespace iter {
   namespace impl {
@@ -57,8 +57,8 @@ class iter::impl::Taker {
     }
 
    public:
-    Iterator(IteratorWrapper<Container>&& iter, IteratorWrapper<Container>&& end,
-        FilterFunc& in_filter_func)
+    Iterator(IteratorWrapper<Container>&& iter,
+        IteratorWrapper<Container>&& end, FilterFunc& in_filter_func)
         : sub_iter{std::move(iter)},
           sub_end{std::move(end)},
           filter_func(&in_filter_func) {
diff --git a/unique_everseen.hpp b/unique_everseen.hpp
index 21b15d21..3db10b99 100644
--- a/unique_everseen.hpp
+++ b/unique_everseen.hpp
@@ -1,14 +1,14 @@
 #ifndef ITER_UNIQUE_EVERSEEN_HPP_
 #define ITER_UNIQUE_EVERSEEN_HPP_
 
-#include "internal/iterbase.hpp"
 #include "filter.hpp"
+#include "internal/iterbase.hpp"
 
-#include <type_traits>
 #include <functional>
-#include <utility>
-#include <unordered_set>
 #include <iterator>
+#include <type_traits>
+#include <unordered_set>
+#include <utility>
 
 namespace iter {
   namespace impl {
diff --git a/unique_justseen.hpp b/unique_justseen.hpp
index caad5076..c7fd2462 100644
--- a/unique_justseen.hpp
+++ b/unique_justseen.hpp
@@ -4,8 +4,8 @@
 #include "groupby.hpp"
 #include "imap.hpp"
 
-#include <utility>
 #include <iterator>
+#include <utility>
 
 namespace iter {
   namespace impl {
@@ -13,9 +13,11 @@ namespace iter {
       template <typename Container>
       auto operator()(Container&& container) const {
         // explicit return type in lambda so reference types are preserved
-        return imap([](auto&& group) -> impl::iterator_deref<Container> {
-          return *std::begin(group.second);
-        }, groupby(std::forward<Container>(container)));
+        return imap(
+            [](auto&& group) -> impl::iterator_deref<Container> {
+              return *std::begin(group.second);
+            },
+            groupby(std::forward<Container>(container)));
       }
     };
   }
diff --git a/zip.hpp b/zip.hpp
index b02c71c5..75bdba1d 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -4,10 +4,10 @@
 #include "internal/iter_tuples.hpp"
 #include "internal/iterbase.hpp"
 
+#include <algorithm>
 #include <iterator>
 #include <tuple>
 #include <utility>
-#include <algorithm>
 
 namespace iter {
   namespace impl {
diff --git a/zip_longest.hpp b/zip_longest.hpp
index dfbcf5c1..f20ba869 100644
--- a/zip_longest.hpp
+++ b/zip_longest.hpp
@@ -1,8 +1,8 @@
 #ifndef ITER_ZIP_LONGEST_HPP_
 #define ITER_ZIP_LONGEST_HPP_
 
-#include "internal/iterbase.hpp"
 #include "internal/iter_tuples.hpp"
+#include "internal/iterbase.hpp"
 
 #include <boost/optional.hpp>
 #include <iterator>

From 3e2a51c559a2971b84ae0df71f718f6ea70a625a Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 14:45:19 -0800
Subject: [PATCH 1524/1866] Adds missig include

clang-format must have reordered things to expose this mistake. Cool
---
 starmap.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/starmap.hpp b/starmap.hpp
index 1521b5a4..f71aaf6c 100644
--- a/starmap.hpp
+++ b/starmap.hpp
@@ -1,6 +1,7 @@
 #ifndef ITER_STARMAP_H_
 #define ITER_STARMAP_H_
 
+#include "internal/iter_tuples.hpp"
 #include "internal/iterator_wrapper.hpp"
 #include "internal/iterbase.hpp"
 

From d7c54e35b1b4796e78c55dbe8806488650828b65 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 17:26:41 -0800
Subject: [PATCH 1525/1866] trailing _ on data members

---
 accumulate.hpp | 66 ++++++++++++++++++++++++--------------------------
 1 file changed, 32 insertions(+), 34 deletions(-)

diff --git a/accumulate.hpp b/accumulate.hpp
index 875ab8c8..64e3dd44 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -23,52 +23,52 @@ namespace iter {
 template <typename Container, typename AccumulateFunc>
 class iter::impl::Accumulator {
  private:
-  Container container;
-  AccumulateFunc accumulate_func;
+  Container container_;
+  AccumulateFunc accumulate_func_;
 
   friend AccumulateFn;
 
   using AccumVal = std::remove_reference_t<std::result_of_t<AccumulateFunc(
       iterator_deref<Container>, iterator_deref<Container>)>>;
 
-  Accumulator(Container&& in_container, AccumulateFunc in_accumulate_func)
-      : container(std::forward<Container>(in_container)),
-        accumulate_func(in_accumulate_func) {}
+  Accumulator(Container&& container, AccumulateFunc accumulate_func)
+      : container_(std::forward<Container>(container)),
+        accumulate_func_(accumulate_func) {}
 
  public:
   Accumulator(Accumulator&&) = default;
 
   class Iterator : public std::iterator<std::input_iterator_tag, AccumVal> {
    private:
-    IteratorWrapper<Container> sub_iter;
-    IteratorWrapper<Container> sub_end;
-    AccumulateFunc* accumulate_func;
-    std::unique_ptr<AccumVal> acc_val;
+    IteratorWrapper<Container> sub_iter_;
+    IteratorWrapper<Container> sub_end_;
+    AccumulateFunc* accumulate_func_;
+    std::unique_ptr<AccumVal> acc_val_;
 
    public:
-    Iterator(IteratorWrapper<Container>&& iter,
-        IteratorWrapper<Container>&& end, AccumulateFunc& in_accumulate_fun)
-        : sub_iter{std::move(iter)},
-          sub_end{std::move(end)},
-          accumulate_func(&in_accumulate_fun),
+    Iterator(IteratorWrapper<Container>&& sub_iter,
+        IteratorWrapper<Container>&& sub_end, AccumulateFunc& accumulate_fun)
+        : sub_iter_{std::move(sub_iter)},
+          sub_end_{std::move(sub_end)},
+          accumulate_func_(&accumulate_fun),
           // only get first value if not an end iterator
-          acc_val{!(iter != end) ? nullptr : new AccumVal(*iter)} {}
+          acc_val_{
+              !(sub_iter_ != sub_end_) ? nullptr : new AccumVal(*sub_iter_)} {}
 
     Iterator(const Iterator& other)
-        : sub_iter{other.sub_iter},
-          sub_end{other.sub_end},
-          accumulate_func{other.accumulate_func},
-          acc_val{other.acc_val ? new AccumVal(*other.acc_val) : nullptr} {}
+        : sub_iter_{other.sub_iter_},
+          sub_end_{other.sub_end_},
+          accumulate_func_{other.accumulate_func_},
+          acc_val_{other.acc_val_ ? new AccumVal(*other.acc_val_) : nullptr} {}
 
     Iterator& operator=(const Iterator& other) {
       if (this == &other) {
         return *this;
       }
-      this->sub_iter = other.sub_iter;
-      this->sub_end = other.sub_end;
-      this->accumulate_func = other.accumulate_func;
-      this->acc_val.reset(
-          other.acc_val ? new AccumVal(*other.acc_val) : nullptr);
+      sub_iter_ = other.sub_iter_;
+      sub_end_ = other.sub_end_;
+      accumulate_func_ = other.accumulate_func_;
+      acc_val_.reset(other.acc_val_ ? new AccumVal(*other.acc_val_) : nullptr);
       return *this;
     }
 
@@ -76,17 +76,17 @@ class iter::impl::Accumulator {
     Iterator& operator=(Iterator&&) = default;
 
     const AccumVal& operator*() const {
-      return *this->acc_val;
+      return *acc_val_;
     }
 
     const AccumVal* operator->() const {
-      return this->acc_val.get();
+      return acc_val_.get();
     }
 
     Iterator& operator++() {
-      ++this->sub_iter;
-      if (this->sub_iter != this->sub_end) {
-        *this->acc_val = (*accumulate_func)(*this->acc_val, *this->sub_iter);
+      ++sub_iter_;
+      if (sub_iter_ != sub_end_) {
+        *acc_val_ = (*accumulate_func_)(*acc_val_, *sub_iter_);
       }
       return *this;
     }
@@ -98,7 +98,7 @@ class iter::impl::Accumulator {
     }
 
     bool operator!=(const Iterator& other) const {
-      return this->sub_iter != other.sub_iter;
+      return sub_iter_ != other.sub_iter_;
     }
 
     bool operator==(const Iterator& other) const {
@@ -107,13 +107,11 @@ class iter::impl::Accumulator {
   };
 
   Iterator begin() {
-    return {std::begin(this->container), std::end(this->container),
-        this->accumulate_func};
+    return {std::begin(container_), std::end(container_), accumulate_func_};
   }
 
   Iterator end() {
-    return {std::end(this->container), std::end(this->container),
-        this->accumulate_func};
+    return {std::end(container_), std::end(container_), accumulate_func_};
   }
 };
 

From 75958bbbab3c690a4589b8f2d1fc2ea020d3267c Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 17:26:57 -0800
Subject: [PATCH 1526/1866] trailing _ on data members

---
 chain.hpp | 132 +++++++++++++++++++++++++++---------------------------
 1 file changed, 65 insertions(+), 67 deletions(-)

diff --git a/chain.hpp b/chain.hpp
index 99e57cac..7abb9f2a 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -87,42 +87,42 @@ class iter::impl::Chained {
   using TraitsValue = iterator_traits_deref<std::tuple_element_t<0, TupType>>;
 
  private:
-  Chained(TupType&& t) : tup(std::move(t)) {}
-  TupType tup;
+  Chained(TupType&& t) : tup_(std::move(t)) {}
+  TupType tup_;
 
  public:
   Chained(Chained&&) = default;
 
   class Iterator : public std::iterator<std::input_iterator_tag, TraitsValue> {
    private:
-    std::size_t index;
-    IterTupType iters;
-    IterTupType ends;
+    std::size_t index_;
+    IterTupType iters_;
+    IterTupType ends_;
 
     void check_for_end_and_adjust() {
-      while (this->index < sizeof...(Is)
-             && !(neq_comparers[this->index](this->iters, this->ends))) {
-        ++this->index;
+      while (
+          index_ < sizeof...(Is) && !(neq_comparers[index_](iters_, ends_))) {
+        ++index_;
       }
     }
 
    public:
-    Iterator(std::size_t i, IterTupType&& in_iters, IterTupType&& in_ends)
-        : index{i}, iters(in_iters), ends(in_ends) {
-      this->check_for_end_and_adjust();
+    Iterator(std::size_t i, IterTupType&& iters, IterTupType&& ends)
+        : index_{i}, iters_(std::move(iters)), ends_(std::move(ends)) {
+      check_for_end_and_adjust();
     }
 
     decltype(auto) operator*() {
-      return derefers[this->index](this->iters);
+      return derefers[index_](iters_);
     }
 
     decltype(auto) operator-> () {
-      return arrowers[this->index](this->iters);
+      return arrowers[index_](iters_);
     }
 
     Iterator& operator++() {
-      incrementers[this->index](this->iters);
-      this->check_for_end_and_adjust();
+      incrementers[index_](iters_);
+      check_for_end_and_adjust();
       return *this;
     }
 
@@ -133,9 +133,9 @@ class iter::impl::Chained {
     }
 
     bool operator!=(const Iterator& other) const {
-      return this->index != other.index
-             || (this->index != sizeof...(Is)
-                    && neq_comparers[this->index](this->iters, other.iters));
+      return index_ != other.index_
+             || (index_ != sizeof...(Is)
+                    && neq_comparers[index_](iters_, other.iters_));
     }
 
     bool operator==(const Iterator& other) const {
@@ -144,13 +144,13 @@ class iter::impl::Chained {
   };
 
   Iterator begin() {
-    return {0, IterTupType{std::begin(std::get<Is>(this->tup))...},
-        IterTupType{std::end(std::get<Is>(this->tup))...}};
+    return {0, IterTupType{std::begin(std::get<Is>(tup_))...},
+        IterTupType{std::end(std::get<Is>(tup_))...}};
   }
 
   Iterator end() {
-    return {sizeof...(Is), IterTupType{std::end(std::get<Is>(this->tup))...},
-        IterTupType{std::end(std::get<Is>(this->tup))...}};
+    return {sizeof...(Is), IterTupType{std::end(std::get<Is>(tup_))...},
+        IterTupType{std::end(std::get<Is>(tup_))...}};
   }
 };
 
@@ -178,9 +178,9 @@ template <typename Container>
 class iter::impl::ChainedFromIterable {
  private:
   friend ChainFromIterableFn;
-  Container container;
-  ChainedFromIterable(Container&& in_container)
-      : container(std::forward<Container>(in_container)) {}
+  Container container_;
+  ChainedFromIterable(Container&& container)
+      : container_(std::forward<Container>(container)) {}
 
  public:
   ChainedFromIterable(ChainedFromIterable&&) = default;
@@ -190,56 +190,56 @@ class iter::impl::ChainedFromIterable {
     using SubContainer = iterator_deref<Container>;
     using SubIter = IteratorWrapper<SubContainer>;
 
-    IteratorWrapper<Container> top_level_iter;
-    IteratorWrapper<Container> top_level_end;
-    std::unique_ptr<SubIter> sub_iter_p;
-    std::unique_ptr<SubIter> sub_end_p;
+    IteratorWrapper<Container> top_level_iter_;
+    IteratorWrapper<Container> top_level_end_;
+    std::unique_ptr<SubIter> sub_iter_p_;
+    std::unique_ptr<SubIter> sub_end_p_;
 
     static std::unique_ptr<SubIter> clone_sub_pointer(const SubIter* sub_iter) {
       return sub_iter ? std::make_unique<SubIter>(*sub_iter) : nullptr;
     }
 
     bool sub_iters_differ(const Iterator& other) const {
-      if (this->sub_iter_p == other.sub_iter_p) {
+      if (sub_iter_p_ == other.sub_iter_p_) {
         return false;
       }
-      if (this->sub_iter_p == nullptr || other.sub_iter_p == nullptr) {
+      if (sub_iter_p_ == nullptr || other.sub_iter_p_ == nullptr) {
         // since the first check tests if they're the same,
         // this will return if only one is nullptr
         return true;
       }
-      return *this->sub_iter_p != *other.sub_iter_p;
+      return *sub_iter_p_ != *other.sub_iter_p_;
     }
 
    public:
     Iterator(IteratorWrapper<Container>&& top_iter,
         IteratorWrapper<Container>&& top_end)
-        : top_level_iter{std::move(top_iter)},
-          top_level_end{std::move(top_end)},
-          sub_iter_p{!(top_iter != top_end)
+        : top_level_iter_{std::move(top_iter)},
+          top_level_end_{std::move(top_end)},
+          sub_iter_p_{!(top_iter != top_end)
+                          ?  // iter == end ?
+                          nullptr
+                          : std::make_unique<SubIter>(std::begin(*top_iter))},
+          sub_end_p_{!(top_iter != top_end)
                          ?  // iter == end ?
                          nullptr
-                         : std::make_unique<SubIter>(std::begin(*top_iter))},
-          sub_end_p{!(top_iter != top_end)
-                        ?  // iter == end ?
-                        nullptr
-                        : std::make_unique<SubIter>(std::end(*top_iter))} {}
+                         : std::make_unique<SubIter>(std::end(*top_iter))} {}
 
     Iterator(const Iterator& other)
-        : top_level_iter{other.top_level_iter},
-          top_level_end{other.top_level_end},
-          sub_iter_p{clone_sub_pointer(other.sub_iter_p.get())},
-          sub_end_p{clone_sub_pointer(other.sub_end_p.get())} {}
+        : top_level_iter_{other.top_level_iter_},
+          top_level_end_{other.top_level_end_},
+          sub_iter_p_{clone_sub_pointer(other.sub_iter_p_.get())},
+          sub_end_p_{clone_sub_pointer(other.sub_end_p_.get())} {}
 
     Iterator& operator=(const Iterator& other) {
       if (this == &other) {
         return *this;
       }
 
-      this->top_level_iter = other.top_level_iter;
-      this->top_level_end = other.top_level_end;
-      this->sub_iter_p = clone_sub_pointer(other.sub_iter_p.get());
-      this->sub_end_p = clone_sub_pointer(other.sub_end_p.get());
+      top_level_iter_ = other.top_level_iter_;
+      top_level_end_ = other.top_level_end_;
+      sub_iter_p_ = clone_sub_pointer(other.sub_iter_p_.get());
+      sub_end_p_ = clone_sub_pointer(other.sub_end_p_.get());
 
       return *this;
     }
@@ -249,17 +249,15 @@ class iter::impl::ChainedFromIterable {
     ~Iterator() = default;
 
     Iterator& operator++() {
-      ++*this->sub_iter_p;
-      if (!(*this->sub_iter_p != *this->sub_end_p)) {
-        ++this->top_level_iter;
-        if (this->top_level_iter != this->top_level_end) {
-          sub_iter_p =
-              std::make_unique<SubIter>(std::begin(*this->top_level_iter));
-          sub_end_p =
-              std::make_unique<SubIter>(std::end(*this->top_level_iter));
+      ++*sub_iter_p_;
+      if (!(*sub_iter_p_ != *sub_end_p_)) {
+        ++top_level_iter_;
+        if (top_level_iter_ != top_level_end_) {
+          sub_iter_p_ = std::make_unique<SubIter>(std::begin(*top_level_iter_));
+          sub_end_p_ = std::make_unique<SubIter>(std::end(*top_level_iter_));
         } else {
-          sub_iter_p.reset();
-          sub_end_p.reset();
+          sub_iter_p_.reset();
+          sub_end_p_.reset();
         }
       }
       return *this;
@@ -272,8 +270,8 @@ class iter::impl::ChainedFromIterable {
     }
 
     bool operator!=(const Iterator& other) const {
-      return this->top_level_iter != other.top_level_iter
-             || this->sub_iters_differ(other);
+      return top_level_iter_ != other.top_level_iter_
+             || sub_iters_differ(other);
     }
 
     bool operator==(const Iterator& other) const {
@@ -281,20 +279,20 @@ class iter::impl::ChainedFromIterable {
     }
 
     iterator_deref<iterator_deref<Container>> operator*() {
-      return **this->sub_iter_p;
+      return **sub_iter_p_;
     }
 
     iterator_arrow<iterator_deref<Container>> operator->() {
-      return apply_arrow(*this->sub_iter_p);
+      return apply_arrow(*sub_iter_p_);
     }
   };
 
   Iterator begin() {
-    return {std::begin(this->container), std::end(this->container)};
+    return {std::begin(container_), std::end(container_)};
   }
 
   Iterator end() {
-    return {std::end(this->container), std::end(this->container)};
+    return {std::end(container_), std::end(container_)};
   }
 };
 
@@ -302,15 +300,15 @@ class iter::impl::ChainMaker {
  private:
   template <typename TupleType, std::size_t... Is>
   Chained<TupleType, Is...> chain_impl(
-      TupleType&& in_containers, std::index_sequence<Is...>) const {
-    return {std::move(in_containers)};
+      TupleType&& containers, std::index_sequence<Is...>) const {
+    return {std::move(containers)};
   }
 
  public:
   // expose regular call operator to provide usual chain()
   template <typename... Containers>
   auto operator()(Containers&&... cs) const {
-    return this->chain_impl(
+    return chain_impl(
         std::tuple<Containers...>{std::forward<Containers>(cs)...},
         std::index_sequence_for<Containers...>{});
   }

From 685de0fb027289a86e38accb833818773bfbb0ec Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 17:27:04 -0800
Subject: [PATCH 1527/1866] trailing _ on data members

---
 chunked.hpp | 54 ++++++++++++++++++++++++++---------------------------
 1 file changed, 27 insertions(+), 27 deletions(-)

diff --git a/chunked.hpp b/chunked.hpp
index 0b79a80c..6dcb8917 100644
--- a/chunked.hpp
+++ b/chunked.hpp
@@ -25,11 +25,11 @@ namespace iter {
 template <typename Container>
 class iter::impl::Chunker {
  private:
-  Container container;
-  std::size_t chunk_size;
+  Container container_;
+  std::size_t chunk_size_;
 
-  Chunker(Container&& c, std::size_t sz)
-      : container(std::forward<Container>(c)), chunk_size{sz} {}
+  Chunker(Container&& container, std::size_t sz)
+      : container_(std::forward<Container>(container)), chunk_size_{sz} {}
 
   friend ChunkedFn;
 
@@ -40,37 +40,37 @@ class iter::impl::Chunker {
   Chunker(Chunker&&) = default;
   class Iterator : public std::iterator<std::input_iterator_tag, DerefVec> {
    private:
-    IteratorWrapper<Container> sub_iter;
-    IteratorWrapper<Container> sub_end;
-    DerefVec chunk;
-    std::size_t chunk_size = 0;
+    IteratorWrapper<Container> sub_iter_;
+    IteratorWrapper<Container> sub_end_;
+    DerefVec chunk_;
+    std::size_t chunk_size_ = 0;
 
     bool done() const {
-      return this->chunk.empty();
+      return chunk_.empty();
     }
 
     void refill_chunk() {
-      this->chunk.get().clear();
+      chunk_.get().clear();
       std::size_t i{0};
-      while (i < chunk_size && this->sub_iter != this->sub_end) {
-        chunk.get().push_back(this->sub_iter);
-        ++this->sub_iter;
+      while (i < chunk_size_ && sub_iter_ != sub_end_) {
+        chunk_.get().push_back(sub_iter_);
+        ++sub_iter_;
         ++i;
       }
     }
 
    public:
-    Iterator(IteratorWrapper<Container>&& in_iter,
-        IteratorWrapper<Container>&& in_end, std::size_t s)
-        : sub_iter{std::move(in_iter)},
-          sub_end{std::move(in_end)},
-          chunk_size{s} {
-      this->chunk.get().reserve(this->chunk_size);
-      this->refill_chunk();
+    Iterator(IteratorWrapper<Container>&& sub_iter,
+        IteratorWrapper<Container>&& sub_end, std::size_t s)
+        : sub_iter_{std::move(sub_iter)},
+          sub_end_{std::move(sub_end)},
+          chunk_size_{s} {
+      chunk_.get().reserve(chunk_size_);
+      refill_chunk();
     }
 
     Iterator& operator++() {
-      this->refill_chunk();
+      refill_chunk();
       return *this;
     }
 
@@ -85,25 +85,25 @@ class iter::impl::Chunker {
     }
 
     bool operator==(const Iterator& other) const {
-      return this->done() == other.done()
-             && (this->done() || !(this->sub_iter != other.sub_iter));
+      return done() == other.done()
+             && (done() || !(sub_iter_ != other.sub_iter_));
     }
 
     DerefVec& operator*() {
-      return this->chunk;
+      return chunk_;
     }
 
     DerefVec* operator->() {
-      return &this->chunk;
+      return &chunk_;
     }
   };
 
   Iterator begin() {
-    return {std::begin(this->container), std::end(this->container), chunk_size};
+    return {std::begin(container_), std::end(container_), chunk_size_};
   }
 
   Iterator end() {
-    return {std::end(this->container), std::end(this->container), chunk_size};
+    return {std::end(container_), std::end(container_), chunk_size_};
   }
 };
 

From 717857a76d338f8ea98914d93a1c07f4ea80171e Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 17:27:19 -0800
Subject: [PATCH 1528/1866] trailing _ on data members

---
 combinations.hpp | 59 ++++++++++++++++++++++++------------------------
 1 file changed, 30 insertions(+), 29 deletions(-)

diff --git a/combinations.hpp b/combinations.hpp
index e6de19c5..71660512 100644
--- a/combinations.hpp
+++ b/combinations.hpp
@@ -21,13 +21,13 @@ namespace iter {
 template <typename Container>
 class iter::impl::Combinator {
  private:
-  Container container;
-  std::size_t length;
+  Container container_;
+  std::size_t length_;
 
   friend CombinationsFn;
 
-  Combinator(Container&& in_container, std::size_t in_length)
-      : container(std::forward<Container>(in_container)), length{in_length} {}
+  Combinator(Container&& container, std::size_t length)
+      : container_(std::forward<Container>(container)), length_{length} {}
 
   using IndexVector = std::vector<iterator_type<Container>>;
   using CombIteratorDeref = IterIterWrapper<IndexVector>;
@@ -38,58 +38,59 @@ class iter::impl::Combinator {
       : public std::iterator<std::input_iterator_tag, CombIteratorDeref> {
    private:
     constexpr static const int COMPLETE = -1;
-    std::remove_reference_t<Container>* container_p;
-    CombIteratorDeref indices;
-    int steps{};
+    std::remove_reference_t<Container>* container_p_;
+    CombIteratorDeref indices_;
+    int steps_{};
 
    public:
-    Iterator(Container& in_container, std::size_t n)
-        : container_p{&in_container}, indices{n} {
+    Iterator(Container& container, std::size_t n)
+        : container_p_{&container}, indices_{n} {
       if (n == 0) {
-        this->steps = COMPLETE;
+        steps_ = COMPLETE;
         return;
       }
       size_t inc = 0;
-      for (auto& iter : this->indices.get()) {
-        auto it = std::begin(*this->container_p);
-        dumb_advance(it, std::end(*this->container_p), inc);
-        if (it != std::end(*this->container_p)) {
+      for (auto& iter : indices_.get()) {
+        auto it = std::begin(*container_p_);
+        dumb_advance(it, std::end(*container_p_), inc);
+        if (it != std::end(*container_p_)) {
           iter = it;
           ++inc;
         } else {
-          this->steps = COMPLETE;
+          steps_ = COMPLETE;
           break;
         }
       }
     }
 
     CombIteratorDeref& operator*() {
-      return this->indices;
+      return indices_;
     }
 
     CombIteratorDeref* operator->() {
-      return &this->indices;
+      return &indices_;
     }
 
     Iterator& operator++() {
-      for (auto iter = indices.get().rbegin(); iter != indices.get().rend();
+      for (auto iter = indices_.get().rbegin(); iter != indices_.get().rend();
            ++iter) {
         ++(*iter);
 
         // what we have to check here is if the distance between
-        // the index and the end of indices is >= the distance
+        // the index and the end of indices_ is >= the distance
         // between the item and end of item
-        auto dist = std::distance(this->indices.get().rbegin(), iter);
+        auto dist = std::distance(indices_.get().rbegin(), iter);
 
-        if (!(dumb_next(*iter, dist) != std::end(*this->container_p))) {
-          if ((iter + 1) != indices.get().rend()) {
+        if (!(dumb_next(*iter, dist) != std::end(*container_p_))) {
+          if ((iter + 1) != indices_.get().rend()) {
             size_t inc = 1;
-            for (auto down = iter; down != indices.get().rbegin() - 1; --down) {
+            for (auto down = iter; down != indices_.get().rbegin() - 1;
+                 --down) {
               (*down) = dumb_next(*(iter + 1), 1 + inc);
               ++inc;
             }
           } else {
-            this->steps = COMPLETE;
+            steps_ = COMPLETE;
             break;
           }
         } else {
@@ -98,8 +99,8 @@ class iter::impl::Combinator {
         // we break because none of the rest of the items need
         // to be incremented
       }
-      if (this->steps != COMPLETE) {
-        ++this->steps;
+      if (steps_ != COMPLETE) {
+        ++steps_;
       }
       return *this;
     }
@@ -115,16 +116,16 @@ class iter::impl::Combinator {
     }
 
     bool operator==(const Iterator& other) const {
-      return this->steps == other.steps;
+      return steps_ == other.steps_;
     }
   };
 
   Iterator begin() {
-    return {this->container, this->length};
+    return {container_, length_};
   }
 
   Iterator end() {
-    return {this->container, 0};
+    return {container_, 0};
   }
 };
 

From c5d4b2427019ce0cb179457d33962b52fc1c72b5 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 17:27:25 -0800
Subject: [PATCH 1529/1866] trailing _ on data members

---
 combinations_with_replacement.hpp | 49 ++++++++++++++++---------------
 1 file changed, 25 insertions(+), 24 deletions(-)

diff --git a/combinations_with_replacement.hpp b/combinations_with_replacement.hpp
index 2257543a..2fa33bd8 100644
--- a/combinations_with_replacement.hpp
+++ b/combinations_with_replacement.hpp
@@ -21,13 +21,13 @@ namespace iter {
 template <typename Container>
 class iter::impl::CombinatorWithReplacement {
  private:
-  Container container;
-  std::size_t length;
+  Container container_;
+  std::size_t length_;
 
   friend CombinationsWithReplacementFn;
 
-  CombinatorWithReplacement(Container&& in_container, std::size_t n)
-      : container(std::forward<Container>(in_container)), length{n} {}
+  CombinatorWithReplacement(Container&& container, std::size_t n)
+      : container_(std::forward<Container>(container)), length_{n} {}
 
   using IndexVector = std::vector<iterator_type<Container>>;
   using CombIteratorDeref = IterIterWrapper<IndexVector>;
@@ -38,37 +38,38 @@ class iter::impl::CombinatorWithReplacement {
       : public std::iterator<std::input_iterator_tag, CombIteratorDeref> {
    private:
     constexpr static const int COMPLETE = -1;
-    std::remove_reference_t<Container>* container_p;
-    CombIteratorDeref indices;
-    int steps;
+    std::remove_reference_t<Container>* container_p_;
+    CombIteratorDeref indices_;
+    int steps_;
 
    public:
     Iterator(Container& in_container, std::size_t n)
-        : container_p{&in_container},
-          indices(n, std::begin(in_container)),
-          steps{(std::begin(in_container) != std::end(in_container) && n)
-                    ? 0
-                    : COMPLETE} {}
+        : container_p_{&in_container},
+          indices_(n, std::begin(in_container)),
+          steps_{(std::begin(in_container) != std::end(in_container) && n)
+                     ? 0
+                     : COMPLETE} {}
 
     CombIteratorDeref& operator*() {
-      return this->indices;
+      return indices_;
     }
 
     CombIteratorDeref* operator->() {
-      return &this->indices;
+      return &indices_;
     }
 
     Iterator& operator++() {
-      for (auto iter = indices.get().rbegin(); iter != indices.get().rend();
+      for (auto iter = indices_.get().rbegin(); iter != indices_.get().rend();
            ++iter) {
         ++(*iter);
-        if (!(*iter != std::end(*this->container_p))) {
-          if ((iter + 1) != indices.get().rend()) {
-            for (auto down = iter; down != indices.get().rbegin() - 1; --down) {
+        if (!(*iter != std::end(*container_p_))) {
+          if ((iter + 1) != indices_.get().rend()) {
+            for (auto down = iter; down != indices_.get().rbegin() - 1;
+                 --down) {
               (*down) = dumb_next(*(iter + 1));
             }
           } else {
-            this->steps = COMPLETE;
+            steps_ = COMPLETE;
             break;
           }
         } else {
@@ -77,8 +78,8 @@ class iter::impl::CombinatorWithReplacement {
           break;
         }
       }
-      if (this->steps != COMPLETE) {
-        ++this->steps;
+      if (steps_ != COMPLETE) {
+        ++steps_;
       }
       return *this;
     }
@@ -94,16 +95,16 @@ class iter::impl::CombinatorWithReplacement {
     }
 
     bool operator==(const Iterator& other) const {
-      return this->steps == other.steps;
+      return steps_ == other.steps_;
     }
   };
 
   Iterator begin() {
-    return {this->container, this->length};
+    return {container_, length_};
   }
 
   Iterator end() {
-    return {this->container, 0};
+    return {container_, 0};
   }
 };
 

From 3fa07d1441f871d668ddb442d332a5a25abbcbc2 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 17:27:42 -0800
Subject: [PATCH 1530/1866] trailing _ on data members

---
 compress.hpp | 63 ++++++++++++++++++++++++++--------------------------
 1 file changed, 31 insertions(+), 32 deletions(-)

diff --git a/compress.hpp b/compress.hpp
index b1d11f7c..ede8e934 100644
--- a/compress.hpp
+++ b/compress.hpp
@@ -20,40 +20,39 @@ namespace iter {
 template <typename Container, typename Selector>
 class iter::impl::Compressed {
  private:
-  Container container;
-  Selector selectors;
+  Container container_;
+  Selector selectors_;
 
   friend Compressed iter::compress<Container, Selector>(
       Container&&, Selector&&);
 
   // Selector::Iterator type
-  using selector_iter_type = decltype(std::begin(selectors));
+  using selector_iter_type = decltype(std::begin(selectors_));
 
   Compressed(Container&& in_container, Selector&& in_selectors)
-      : container(std::forward<Container>(in_container)),
-        selectors(std::forward<Selector>(in_selectors)) {}
+      : container_(std::forward<Container>(in_container)),
+        selectors_(std::forward<Selector>(in_selectors)) {}
 
  public:
   Compressed(Compressed&&) = default;
   class Iterator : public std::iterator<std::input_iterator_tag,
                        iterator_traits_deref<Container>> {
    private:
-    IteratorWrapper<Container> sub_iter;
-    IteratorWrapper<Container> sub_end;
+    IteratorWrapper<Container> sub_iter_;
+    IteratorWrapper<Container> sub_end_;
 
-    selector_iter_type selector_iter;
-    selector_iter_type selector_end;
+    selector_iter_type selector_iter_;
+    selector_iter_type selector_end_;
 
     void increment_iterators() {
-      ++this->sub_iter;
-      ++this->selector_iter;
+      ++sub_iter_;
+      ++selector_iter_;
     }
 
     void skip_failures() {
-      while (this->sub_iter != this->sub_end
-             && this->selector_iter != this->selector_end
-             && !*this->selector_iter) {
-        this->increment_iterators();
+      while (sub_iter_ != sub_end_ && selector_iter_ != selector_end_
+             && !*selector_iter_) {
+        increment_iterators();
       }
     }
 
@@ -61,24 +60,24 @@ class iter::impl::Compressed {
     Iterator(IteratorWrapper<Container>&& cont_iter,
         IteratorWrapper<Container>&& cont_end, selector_iter_type&& sel_iter,
         selector_iter_type&& sel_end)
-        : sub_iter{std::move(cont_iter)},
-          sub_end{std::move(cont_end)},
-          selector_iter{std::move(sel_iter)},
-          selector_end{std::move(sel_end)} {
-      this->skip_failures();
+        : sub_iter_{std::move(cont_iter)},
+          sub_end_{std::move(cont_end)},
+          selector_iter_{std::move(sel_iter)},
+          selector_end_{std::move(sel_end)} {
+      skip_failures();
     }
 
     iterator_deref<Container> operator*() {
-      return *this->sub_iter;
+      return *sub_iter_;
     }
 
     iterator_arrow<Container> operator->() {
-      return apply_arrow(this->sub_iter);
+      return apply_arrow(sub_iter_);
     }
 
     Iterator& operator++() {
-      this->increment_iterators();
-      this->skip_failures();
+      increment_iterators();
+      skip_failures();
       return *this;
     }
 
@@ -89,8 +88,8 @@ class iter::impl::Compressed {
     }
 
     bool operator!=(const Iterator& other) const {
-      return this->sub_iter != other.sub_iter
-             && this->selector_iter != other.selector_iter;
+      return sub_iter_ != other.sub_iter_
+             && selector_iter_ != other.selector_iter_;
     }
 
     bool operator==(const Iterator& other) const {
@@ -99,21 +98,21 @@ class iter::impl::Compressed {
   };
 
   Iterator begin() {
-    return {std::begin(this->container), std::end(this->container),
-        std::begin(this->selectors), std::end(this->selectors)};
+    return {std::begin(container_), std::end(container_),
+        std::begin(selectors_), std::end(selectors_)};
   }
 
   Iterator end() {
-    return {std::end(this->container), std::end(this->container),
-        std::end(this->selectors), std::end(this->selectors)};
+    return {std::end(container_), std::end(container_), std::end(selectors_),
+        std::end(selectors_)};
   }
 };
 
 template <typename Container, typename Selector>
 iter::impl::Compressed<Container, Selector> iter::compress(
-    Container&& container, Selector&& selectors) {
+    Container&& container_, Selector&& selectors_) {
   return {
-      std::forward<Container>(container), std::forward<Selector>(selectors)};
+      std::forward<Container>(container_), std::forward<Selector>(selectors_)};
 }
 
 #endif

From 200302984b576c1bb309399b1377dd2c2af1c87e Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 17:27:47 -0800
Subject: [PATCH 1531/1866] trailing _ on data members

---
 cycle.hpp | 38 ++++++++++++++++++++------------------
 1 file changed, 20 insertions(+), 18 deletions(-)

diff --git a/cycle.hpp b/cycle.hpp
index 51bed25c..24396e7e 100644
--- a/cycle.hpp
+++ b/cycle.hpp
@@ -23,38 +23,40 @@ class iter::impl::Cycler {
  private:
   friend CycleFn;
 
-  Container container;
+  Container container_;
 
-  Cycler(Container&& in_container)
-      : container(std::forward<Container>(in_container)) {}
+  Cycler(Container&& container)
+      : container_(std::forward<Container>(container)) {}
 
  public:
   Cycler(Cycler&&) = default;
   class Iterator : public std::iterator<std::input_iterator_tag,
                        iterator_traits_deref<Container>> {
    private:
-    IteratorWrapper<Container> sub_iter;
-    IteratorWrapper<Container> begin;
-    IteratorWrapper<Container> end;
+    IteratorWrapper<Container> sub_iter_;
+    IteratorWrapper<Container> sub_begin_;
+    IteratorWrapper<Container> sub_end_;
 
    public:
-    Iterator(
-        IteratorWrapper<Container>&& iter, IteratorWrapper<Container>&& in_end)
-        : sub_iter{iter}, begin{iter}, end{std::move(in_end)} {}
+    Iterator(IteratorWrapper<Container>&& sub_iter,
+        IteratorWrapper<Container>&& sub_end)
+        : sub_iter_{sub_iter},
+          sub_begin_{sub_iter},
+          sub_end_{std::move(sub_end)} {}
 
     iterator_deref<Container> operator*() {
-      return *this->sub_iter;
+      return *sub_iter_;
     }
 
     iterator_arrow<Container> operator->() {
-      return apply_arrow(this->sub_iter);
+      return apply_arrow(sub_iter_);
     }
 
     Iterator& operator++() {
-      ++this->sub_iter;
-      // reset to beginning upon reaching the end
-      if (!(this->sub_iter != this->end)) {
-        this->sub_iter = this->begin;
+      ++sub_iter_;
+      // reset to beginning upon reaching the sub_end_
+      if (!(sub_iter_ != sub_end_)) {
+        sub_iter_ = sub_begin_;
       }
       return *this;
     }
@@ -66,7 +68,7 @@ class iter::impl::Cycler {
     }
 
     bool operator!=(const Iterator& other) const {
-      return this->sub_iter != other.sub_iter;
+      return sub_iter_ != other.sub_iter_;
     }
 
     bool operator==(const Iterator& other) const {
@@ -75,11 +77,11 @@ class iter::impl::Cycler {
   };
 
   Iterator begin() {
-    return {std::begin(this->container), std::end(this->container)};
+    return {std::begin(container_), std::end(container_)};
   }
 
   Iterator end() {
-    return {std::end(this->container), std::end(this->container)};
+    return {std::end(container_), std::end(container_)};
   }
 };
 

From 8dcad3aa4ca7c6bff8b542b542e42693eba8b442 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 17:27:54 -0800
Subject: [PATCH 1532/1866] trailing _ on data members

---
 dropwhile.hpp | 59 ++++++++++++++++++++++++---------------------------
 1 file changed, 28 insertions(+), 31 deletions(-)

diff --git a/dropwhile.hpp b/dropwhile.hpp
index 4aceb371..1f544137 100644
--- a/dropwhile.hpp
+++ b/dropwhile.hpp
@@ -21,14 +21,14 @@ namespace iter {
 template <typename FilterFunc, typename Container>
 class iter::impl::Dropper {
  private:
-  Container container;
-  FilterFunc filter_func;
+  Container container_;
+  FilterFunc filter_func_;
 
   friend DropWhileFn;
 
-  Dropper(FilterFunc in_filter_func, Container&& in_container)
-      : container(std::forward<Container>(in_container)),
-        filter_func(in_filter_func) {}
+  Dropper(FilterFunc filter_func, Container&& container)
+      : container_(std::forward<Container>(container)),
+        filter_func_(filter_func) {}
 
  public:
   Dropper(Dropper&&) = default;
@@ -36,48 +36,47 @@ class iter::impl::Dropper {
                        iterator_traits_deref<Container>> {
    private:
     using Holder = DerefHolder<iterator_deref<Container>>;
-    IteratorWrapper<Container> sub_iter;
-    IteratorWrapper<Container> sub_end;
-    Holder item;
-    FilterFunc* filter_func;
+    IteratorWrapper<Container> sub_iter_;
+    IteratorWrapper<Container> sub_end_;
+    Holder item_;
+    FilterFunc* filter_func_;
 
     void inc_sub_iter() {
-      ++this->sub_iter;
-      if (this->sub_iter != this->sub_end) {
-        this->item.reset(*this->sub_iter);
+      ++sub_iter_;
+      if (sub_iter_ != sub_end_) {
+        item_.reset(*sub_iter_);
       }
     }
 
     // skip all values for which the predicate is true
     void skip_passes() {
-      while (this->sub_iter != this->sub_end
-             && (*this->filter_func)(this->item.get())) {
-        this->inc_sub_iter();
+      while (sub_iter_ != sub_end_ && (*filter_func_)(item_.get())) {
+        inc_sub_iter();
       }
     }
 
    public:
-    Iterator(IteratorWrapper<Container>&& iter,
-        IteratorWrapper<Container>&& end, FilterFunc& in_filter_func)
-        : sub_iter{std::move(iter)},
-          sub_end{std::move(end)},
-          filter_func(&in_filter_func) {
-      if (this->sub_iter != this->sub_end) {
-        this->item.reset(*this->sub_iter);
+    Iterator(IteratorWrapper<Container>&& sub_iter,
+        IteratorWrapper<Container>&& sub_end, FilterFunc& filter_func)
+        : sub_iter_{std::move(sub_iter)},
+          sub_end_{std::move(sub_end)},
+          filter_func_(&filter_func) {
+      if (sub_iter_ != sub_end_) {
+        item_.reset(*sub_iter_);
       }
-      this->skip_passes();
+      skip_passes();
     }
 
     typename Holder::reference operator*() {
-      return this->item.get();
+      return item_.get();
     }
 
     typename Holder::pointer operator->() {
-      return this->item.get_ptr();
+      return item_.get_ptr();
     }
 
     Iterator& operator++() {
-      this->inc_sub_iter();
+      inc_sub_iter();
       return *this;
     }
 
@@ -88,7 +87,7 @@ class iter::impl::Dropper {
     }
 
     bool operator!=(const Iterator& other) const {
-      return this->sub_iter != other.sub_iter;
+      return sub_iter_ != other.sub_iter_;
     }
 
     bool operator==(const Iterator& other) const {
@@ -97,13 +96,11 @@ class iter::impl::Dropper {
   };
 
   Iterator begin() {
-    return {std::begin(this->container), std::end(this->container),
-        this->filter_func};
+    return {std::begin(container_), std::end(container_), filter_func_};
   }
 
   Iterator end() {
-    return {std::end(this->container), std::end(this->container),
-        this->filter_func};
+    return {std::end(container_), std::end(container_), filter_func_};
   }
 };
 

From 2efe1da2382f60bc0aa064c240affcbfa5ad2fec Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 17:28:17 -0800
Subject: [PATCH 1533/1866] trailing _ on data members

---
 enumerate.hpp | 30 +++++++++++++++---------------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index 02201b90..9331b139 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -23,8 +23,8 @@ namespace iter {
 template <typename Container, typename Index>
 class iter::impl::Enumerable {
  private:
-  Container container;
-  const Index start;
+  Container container_;
+  const Index start_;
 
   friend EnumerateFn;
 
@@ -32,8 +32,8 @@ class iter::impl::Enumerable {
   using BasePair = std::pair<Index, iterator_deref<Container>>;
 
   // Value constructor for use only in the enumerate function
-  Enumerable(Container&& in_container, Index in_start)
-      : container(std::forward<Container>(in_container)), start{in_start} {}
+  Enumerable(Container&& container, Index start)
+      : container_(std::forward<Container>(container)), start_{start} {}
 
  public:
   Enumerable(Enumerable&&) = default;
@@ -48,19 +48,19 @@ class iter::impl::Enumerable {
   };
 
   //  Holds an iterator of the contained type and an Index for the
-  //  index.  Each call to ++ increments both of these data members.
+  //  index_.  Each call to ++ increments both of these data members.
   //  Each dereference returns an IterYield.
   class Iterator : public std::iterator<std::input_iterator_tag, IterYield> {
    private:
-    IteratorWrapper<Container> sub_iter;
-    Index index;
+    IteratorWrapper<Container> sub_iter_;
+    Index index_;
 
    public:
-    Iterator(IteratorWrapper<Container>&& si, Index start)
-        : sub_iter{std::move(si)}, index{start} {}
+    Iterator(IteratorWrapper<Container>&& sub_iter, Index start)
+        : sub_iter_{std::move(sub_iter)}, index_{start} {}
 
     IterYield operator*() {
-      return {this->index, *this->sub_iter};
+      return {index_, *sub_iter_};
     }
 
     ArrowProxy<IterYield> operator->() {
@@ -68,8 +68,8 @@ class iter::impl::Enumerable {
     }
 
     Iterator& operator++() {
-      ++this->sub_iter;
-      ++this->index;
+      ++sub_iter_;
+      ++index_;
       return *this;
     }
 
@@ -80,7 +80,7 @@ class iter::impl::Enumerable {
     }
 
     bool operator!=(const Iterator& other) const {
-      return this->sub_iter != other.sub_iter;
+      return sub_iter_ != other.sub_iter_;
     }
 
     bool operator==(const Iterator& other) const {
@@ -89,11 +89,11 @@ class iter::impl::Enumerable {
   };
 
   Iterator begin() {
-    return {std::begin(this->container), start};
+    return {std::begin(container_), start_};
   }
 
   Iterator end() {
-    return {std::end(this->container), start};
+    return {std::end(container_), start_};
   }
 };
 

From 5e99c34e85d220d28495955bac6078a3c24248f4 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 17:28:22 -0800
Subject: [PATCH 1534/1866] trailing _ on data members

---
 filter.hpp | 65 ++++++++++++++++++++++++++----------------------------
 1 file changed, 31 insertions(+), 34 deletions(-)

diff --git a/filter.hpp b/filter.hpp
index 69838cbf..1c118407 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -15,8 +15,8 @@ namespace iter {
 
     struct BoolTester {
       template <typename T>
-      constexpr bool operator()(const T& item) const {
-        return bool(item);
+      constexpr bool operator()(const T& item_) const {
+        return bool(item_);
       }
     };
 
@@ -29,16 +29,16 @@ namespace iter {
 template <typename FilterFunc, typename Container>
 class iter::impl::Filtered {
  private:
-  Container container;
-  FilterFunc filter_func;
+  Container container_;
+  FilterFunc filter_func_;
 
   friend FilterFn;
 
  protected:
   // Value constructor for use only in the filter function
-  Filtered(FilterFunc in_filter_func, Container&& in_container)
-      : container(std::forward<Container>(in_container)),
-        filter_func(in_filter_func) {}
+  Filtered(FilterFunc filter_func, Container&& container)
+      : container_(std::forward<Container>(container)),
+        filter_func_(filter_func) {}
 
  public:
   Filtered(Filtered&&) = default;
@@ -47,50 +47,49 @@ class iter::impl::Filtered {
                        iterator_traits_deref<Container>> {
    protected:
     using Holder = DerefHolder<iterator_deref<Container>>;
-    IteratorWrapper<Container> sub_iter;
-    IteratorWrapper<Container> sub_end;
-    Holder item;
-    FilterFunc* filter_func;
+    IteratorWrapper<Container> sub_iter_;
+    IteratorWrapper<Container> sub_end_;
+    Holder item_;
+    FilterFunc* filter_func_;
 
     void inc_sub_iter() {
-      ++this->sub_iter;
-      if (this->sub_iter != this->sub_end) {
-        this->item.reset(*this->sub_iter);
+      ++sub_iter_;
+      if (sub_iter_ != sub_end_) {
+        item_.reset(*sub_iter_);
       }
     }
 
     // increment until the iterator points to is true on the
     // predicate.  Called by constructor and operator++
     void skip_failures() {
-      while (this->sub_iter != this->sub_end
-             && !(*this->filter_func)(this->item.get())) {
-        this->inc_sub_iter();
+      while (sub_iter_ != sub_end_ && !(*filter_func_)(item_.get())) {
+        inc_sub_iter();
       }
     }
 
    public:
-    Iterator(IteratorWrapper<Container>&& iter,
-        IteratorWrapper<Container>&& end, FilterFunc& in_filter_func)
-        : sub_iter{std::move(iter)},
-          sub_end{std::move(end)},
-          filter_func(&in_filter_func) {
-      if (this->sub_iter != this->sub_end) {
-        this->item.reset(*this->sub_iter);
+    Iterator(IteratorWrapper<Container>&& sub_iter,
+        IteratorWrapper<Container>&& sub_end, FilterFunc& filter_func)
+        : sub_iter_{std::move(sub_iter)},
+          sub_end_{std::move(sub_end)},
+          filter_func_(&filter_func) {
+      if (sub_iter_ != sub_end_) {
+        item_.reset(*sub_iter_);
       }
-      this->skip_failures();
+      skip_failures();
     }
 
     typename Holder::reference operator*() {
-      return this->item.get();
+      return item_.get();
     }
 
     typename Holder::pointer operator->() {
-      return this->item.get_ptr();
+      return item_.get_ptr();
     }
 
     Iterator& operator++() {
-      this->inc_sub_iter();
-      this->skip_failures();
+      inc_sub_iter();
+      skip_failures();
       return *this;
     }
 
@@ -101,7 +100,7 @@ class iter::impl::Filtered {
     }
 
     bool operator!=(const Iterator& other) const {
-      return this->sub_iter != other.sub_iter;
+      return sub_iter_ != other.sub_iter_;
     }
 
     bool operator==(const Iterator& other) const {
@@ -110,13 +109,11 @@ class iter::impl::Filtered {
   };
 
   Iterator begin() {
-    return {std::begin(this->container), std::end(this->container),
-        this->filter_func};
+    return {std::begin(container_), std::end(container_), filter_func_};
   }
 
   Iterator end() {
-    return {std::end(this->container), std::end(this->container),
-        this->filter_func};
+    return {std::end(container_), std::end(container_), filter_func_};
   }
 };
 

From 5d81d3ced3d58d1d252c4c06a6a1117737e49432 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 17:28:28 -0800
Subject: [PATCH 1535/1866] trailing _ on data members

---
 filterfalse.hpp | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/filterfalse.hpp b/filterfalse.hpp
index f46aba2a..9de7a3df 100644
--- a/filterfalse.hpp
+++ b/filterfalse.hpp
@@ -13,22 +13,22 @@ namespace iter {
     template <typename FilterFunc>
     class PredicateFlipper {
      private:
-      FilterFunc filter_func;
+      FilterFunc filter_func_;
 
      public:
-      PredicateFlipper(FilterFunc in_filter_func)
-          : filter_func(std::move(in_filter_func)) {}
+      PredicateFlipper(FilterFunc filter_func)
+          : filter_func_(std::move(filter_func)) {}
 
-      // Calls the filter_func
+      // Calls the filter_func_
       template <typename T>
       bool operator()(const T& item) const {
-        return !bool(filter_func(item));
+        return !bool(filter_func_(item));
       }
 
       // with non-const incase FilterFunc::operator() is non-const
       template <typename T>
       bool operator()(const T& item) {
-        return !bool(filter_func(item));
+        return !bool(filter_func_(item));
       }
     };
 

From 780e64d08345653bd87a18754240b68ff85b6980 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 17:28:35 -0800
Subject: [PATCH 1536/1866] trailing _ on data members

---
 groupby.hpp | 137 +++++++++++++++++++++++++---------------------------
 1 file changed, 65 insertions(+), 72 deletions(-)

diff --git a/groupby.hpp b/groupby.hpp
index 24c8c048..a4074b5b 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -31,16 +31,15 @@ namespace iter {
 template <typename Container, typename KeyFunc>
 class iter::impl::GroupProducer {
  private:
-  Container container;
-  KeyFunc key_func;
+  Container container_;
+  KeyFunc key_func_;
 
   friend GroupByFn;
 
   using key_func_ret = std::result_of_t<KeyFunc(iterator_deref<Container>)>;
 
-  GroupProducer(Container&& in_container, KeyFunc in_key_func)
-      : container(std::forward<Container>(in_container)),
-        key_func(in_key_func) {}
+  GroupProducer(Container&& container, KeyFunc key_func)
+      : container_(std::forward<Container>(container)), key_func_(key_func) {}
 
  public:
   GroupProducer(GroupProducer&&) = default;
@@ -55,39 +54,38 @@ class iter::impl::GroupProducer {
  public:
   class Iterator : public std::iterator<std::input_iterator_tag, KeyGroupPair> {
    private:
-    IteratorWrapper<Container> sub_iter;
-    IteratorWrapper<Container> sub_end;
-    Holder item;
-    KeyFunc* key_func;
-
-    std::unique_ptr<KeyGroupPair> current_key_group_pair;
+    IteratorWrapper<Container> sub_iter_;
+    IteratorWrapper<Container> sub_end_;
+    Holder item_;
+    KeyFunc* key_func_;
+    std::unique_ptr<KeyGroupPair> current_key_group_pair_;
 
    public:
-    Iterator(IteratorWrapper<Container>&& si, IteratorWrapper<Container>&& end,
-        KeyFunc& in_key_func)
-        : sub_iter{std::move(si)},
-          sub_end{std::move(end)},
-          key_func(&in_key_func) {
-      if (this->sub_iter != this->sub_end) {
-        this->item.reset(*this->sub_iter);
+    Iterator(IteratorWrapper<Container>&& sub_iter,
+        IteratorWrapper<Container>&& sub_end, KeyFunc& key_func)
+        : sub_iter_{std::move(sub_iter)},
+          sub_end_{std::move(sub_end)},
+          key_func_(&key_func) {
+      if (sub_iter_ != sub_end_) {
+        item_.reset(*sub_iter_);
       }
     }
 
     Iterator(const Iterator& other)
-        : sub_iter{other.sub_iter},
-          sub_end{other.sub_end},
-          item{other.item},
-          key_func{other.key_func} {}
+        : sub_iter_{other.sub_iter_},
+          sub_end_{other.sub_end_},
+          item_{other.item_},
+          key_func_{other.key_func_} {}
 
     Iterator& operator=(const Iterator& other) {
       if (this == &other) {
         return *this;
       }
-      this->sub_iter = other.sub_iter;
-      this->sub_end = other.sub_end;
-      this->item = other.item;
-      this->key_func = other.key_func;
-      this->current_key_group_pair.reset();
+      sub_iter_ = other.sub_iter_;
+      sub_end_ = other.sub_end_;
+      item_ = other.item_;
+      key_func_ = other.key_func_;
+      current_key_group_pair_.reset();
       return *this;
     }
 
@@ -98,19 +96,19 @@ class iter::impl::GroupProducer {
 
     KeyGroupPair& operator*() {
       set_key_group_pair();
-      return *this->current_key_group_pair;
+      return *current_key_group_pair_;
     }
 
     KeyGroupPair* operator->() {
       set_key_group_pair();
-      return this->current_key_group_pair.get();
+      return current_key_group_pair_.get();
     }
 
     Iterator& operator++() {
-      if (!this->current_key_group_pair) {
-        this->set_key_group_pair();
+      if (!current_key_group_pair_) {
+        set_key_group_pair();
       }
-      this->current_key_group_pair.reset();
+      current_key_group_pair_.reset();
       return *this;
     }
 
@@ -121,7 +119,7 @@ class iter::impl::GroupProducer {
     }
 
     bool operator!=(const Iterator& other) const {
-      return this->sub_iter != other.sub_iter;
+      return sub_iter_ != other.sub_iter_;
     }
 
     bool operator==(const Iterator& other) const {
@@ -129,35 +127,34 @@ class iter::impl::GroupProducer {
     }
 
     void increment_iterator() {
-      if (this->sub_iter != this->sub_end) {
-        ++this->sub_iter;
-        if (this->sub_iter != this->sub_end) {
-          this->item.reset(*this->sub_iter);
+      if (sub_iter_ != sub_end_) {
+        ++sub_iter_;
+        if (sub_iter_ != sub_end_) {
+          item_.reset(*sub_iter_);
         }
       }
     }
 
     bool exhausted() const {
-      return !(this->sub_iter != this->sub_end);
+      return !(sub_iter_ != sub_end_);
     }
 
     typename Holder::reference get() {
-      return this->item.get();
+      return item_.get();
     }
 
     typename Holder::pointer get_ptr() {
-      return this->item.get_ptr();
+      return item_.get_ptr();
     }
 
     key_func_ret next_key() {
-      return (*this->key_func)(this->item.get());
+      return (*key_func_)(item_.get());
     }
 
     void set_key_group_pair() {
-      if (!this->current_key_group_pair) {
-        this->current_key_group_pair =
-            std::make_unique<KeyGroupPair>((*this->key_func)(this->item.get()),
-                Group{*this, this->next_key()});
+      if (!current_key_group_pair_) {
+        current_key_group_pair_ = std::make_unique<KeyGroupPair>(
+            (*key_func_)(item_.get()), Group{*this, next_key()});
       }
     }
   };
@@ -166,8 +163,8 @@ class iter::impl::GroupProducer {
    private:
     friend Iterator;
     friend class GroupIterator;
-    Iterator& owner;
-    key_func_ret key;
+    Iterator& owner_;
+    key_func_ret key_;
 
     // completed is set if a Group is iterated through
     // completely.  It is checked in the destructor, and
@@ -180,52 +177,50 @@ class iter::impl::GroupProducer {
     // when called.
     bool completed = false;
 
-    Group(Iterator& in_owner, key_func_ret in_key)
-        : owner(in_owner), key(in_key) {}
+    Group(Iterator& owner, key_func_ret key) : owner_(owner), key_(key) {}
 
    public:
     ~Group() {
-      if (!this->completed) {
-        for (auto iter = this->begin(), end = this->end(); iter != end;
-             ++iter) {
+      if (!completed) {
+        for (auto iter = begin(), end_it = end(); iter != end_it; ++iter) {
         }
       }
     }
 
     // move-constructible, non-copy-constructible, non-assignable
     Group(Group&& other) noexcept
-        : owner(other.owner), key{other.key}, completed{other.completed} {
+        : owner_(other.owner_), key_{other.key_}, completed{other.completed} {
       other.completed = true;
     }
 
     class GroupIterator : public std::iterator<std::input_iterator_tag,
                               iterator_traits_deref<Container>> {
      private:
-      std::remove_reference_t<key_func_ret>* key;
-      Group* group_p;
+      std::remove_reference_t<key_func_ret>* key_;
+      Group* group_p_;
 
       bool not_at_end() {
-        return !this->group_p->owner.exhausted()
-               && this->group_p->owner.next_key() == *this->key;
+        return !group_p_->owner_.exhausted()
+               && group_p_->owner_.next_key() == *key_;
       }
 
      public:
-      GroupIterator(Group* in_group_p, key_func_ret& in_key)
-          : key{&in_key}, group_p{in_group_p} {}
+      GroupIterator(Group* group_p, key_func_ret& key)
+          : key_{&key}, group_p_{group_p} {}
 
       bool operator!=(const GroupIterator& other) const {
         return !(*this == other);
       }
 
       bool operator==(const GroupIterator& other) const {
-        return this->group_p == other.group_p;
+        return group_p_ == other.group_p_;
       }
 
       GroupIterator& operator++() {
-        this->group_p->owner.increment_iterator();
-        if (!this->not_at_end()) {
-          this->group_p->completed = true;
-          this->group_p = nullptr;
+        group_p_->owner_.increment_iterator();
+        if (!not_at_end()) {
+          group_p_->completed = true;
+          group_p_ = nullptr;
         }
         return *this;
       }
@@ -237,31 +232,29 @@ class iter::impl::GroupProducer {
       }
 
       iterator_deref<Container> operator*() {
-        return this->group_p->owner.get();
+        return group_p_->owner_.get();
       }
 
       typename Holder::pointer operator->() {
-        return this->group_p->owner.get_ptr();
+        return group_p_->owner_.get_ptr();
       }
     };
 
     GroupIterator begin() {
-      return {this, key};
+      return {this, key_};
     }
 
     GroupIterator end() {
-      return {nullptr, key};
+      return {nullptr, key_};
     }
   };
 
   Iterator begin() {
-    return {
-        std::begin(this->container), std::end(this->container), this->key_func};
+    return {std::begin(container_), std::end(container_), key_func_};
   }
 
   Iterator end() {
-    return {
-        std::end(this->container), std::end(this->container), this->key_func};
+    return {std::end(container_), std::end(container_), key_func_};
   }
 };
 

From 1d248dc8fb8a473f9db1970a05f835d6f9794e0e Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 17:28:40 -0800
Subject: [PATCH 1537/1866] trailing _ on data members

---
 permutations.hpp | 34 +++++++++++++++++-----------------
 1 file changed, 17 insertions(+), 17 deletions(-)

diff --git a/permutations.hpp b/permutations.hpp
index 4d895fa1..a522a980 100644
--- a/permutations.hpp
+++ b/permutations.hpp
@@ -24,13 +24,13 @@ template <typename Container>
 class iter::impl::Permuter {
  private:
   friend PermutationsFn;
-  Container container;
+  Container container_;
 
   using IndexVector = std::vector<IteratorWrapper<Container>>;
   using Permutable = IterIterWrapper<IndexVector>;
 
-  Permuter(Container&& in_container)
-      : container(std::forward<Container>(in_container)) {}
+  Permuter(Container&& container)
+      : container_(std::forward<Container>(container)) {}
 
  public:
   Permuter(Permuter&&) = default;
@@ -43,37 +43,37 @@ class iter::impl::Permuter {
       return *lhs < *rhs;
     }
 
-    Permutable working_set;
-    int steps{};
+    Permutable working_set_;
+    int steps_{};
 
    public:
     Iterator(IteratorWrapper<Container>&& sub_iter,
         IteratorWrapper<Container>&& sub_end)
-        : steps{sub_iter != sub_end ? 0 : COMPLETE} {
+        : steps_{sub_iter != sub_end ? 0 : COMPLETE} {
       // done like this instead of using vector ctor with
       // two iterators because that causes a substitution
       // failure when the iterator is minimal
       while (sub_iter != sub_end) {
-        this->working_set.get().push_back(sub_iter);
+        working_set_.get().push_back(sub_iter);
         ++sub_iter;
       }
-      std::sort(std::begin(working_set.get()), std::end(working_set.get()),
+      std::sort(std::begin(working_set_.get()), std::end(working_set_.get()),
           cmp_iters);
     }
 
     Permutable& operator*() {
-      return this->working_set;
+      return working_set_;
     }
 
     Permutable* operator->() {
-      return &this->working_set;
+      return &working_set_;
     }
 
     Iterator& operator++() {
-      ++this->steps;
-      if (!std::next_permutation(std::begin(working_set.get()),
-              std::end(working_set.get()), cmp_iters)) {
-        this->steps = COMPLETE;
+      ++steps_;
+      if (!std::next_permutation(std::begin(working_set_.get()),
+              std::end(working_set_.get()), cmp_iters)) {
+        steps_ = COMPLETE;
       }
       return *this;
     }
@@ -89,16 +89,16 @@ class iter::impl::Permuter {
     }
 
     bool operator==(const Iterator& other) const {
-      return this->steps == other.steps;
+      return steps_ == other.steps_;
     }
   };
 
   Iterator begin() {
-    return {std::begin(this->container), std::end(this->container)};
+    return {std::begin(container_), std::end(container_)};
   }
 
   Iterator end() {
-    return {std::end(this->container), std::end(this->container)};
+    return {std::end(container_), std::end(container_)};
   }
 };
 

From 50fe35e841d3e8fdff87773e9cd8d7a196666454 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 17:28:52 -0800
Subject: [PATCH 1538/1866] trailing _ on data members

---
 powerset.hpp | 56 +++++++++++++++++++++++++---------------------------
 1 file changed, 27 insertions(+), 29 deletions(-)

diff --git a/powerset.hpp b/powerset.hpp
index 68aab5f8..2cbad540 100644
--- a/powerset.hpp
+++ b/powerset.hpp
@@ -24,13 +24,13 @@ namespace iter {
 template <typename Container>
 class iter::impl::Powersetter {
  private:
-  Container container;
+  Container container_;
   using CombinatorType = decltype(combinations(std::declval<Container&>(), 0));
 
   friend PowersetFn;
 
-  Powersetter(Container&& in_container)
-      : container(std::forward<Container>(in_container)) {}
+  Powersetter(Container&& container)
+      : container_(std::forward<Container>(container)) {}
 
  public:
   Powersetter(Powersetter&&) = default;
@@ -38,30 +38,29 @@ class iter::impl::Powersetter {
   class Iterator
       : public std::iterator<std::input_iterator_tag, CombinatorType> {
    private:
-    std::remove_reference_t<Container>* container_p;
-    std::size_t set_size;
-    std::shared_ptr<CombinatorType> comb;
-    iterator_type<CombinatorType> comb_iter;
-    iterator_type<CombinatorType> comb_end;
+    std::remove_reference_t<Container>* container_p_;
+    std::size_t set_size_{};
+    std::shared_ptr<CombinatorType> comb_;
+    iterator_type<CombinatorType> comb_iter_;
+    iterator_type<CombinatorType> comb_end_;
 
    public:
-    Iterator(Container& in_container, std::size_t sz)
-        : container_p{&in_container},
-          set_size{sz},
-          comb{
-              std::make_shared<CombinatorType>(combinations(in_container, sz))},
-          comb_iter{std::begin(*comb)},
-          comb_end{std::end(*comb)} {}
+    Iterator(Container& container, std::size_t sz)
+        : container_p_{&container},
+          set_size_{sz},
+          comb_{std::make_shared<CombinatorType>(combinations(container, sz))},
+          comb_iter_{std::begin(*comb_)},
+          comb_end_{std::end(*comb_)} {}
 
     Iterator& operator++() {
-      ++this->comb_iter;
-      if (this->comb_iter == this->comb_end) {
-        ++this->set_size;
-        this->comb = std::make_shared<CombinatorType>(
-            combinations(*this->container_p, this->set_size));
-
-        this->comb_iter = std::begin(*this->comb);
-        this->comb_end = std::end(*this->comb);
+      ++comb_iter_;
+      if (comb_iter_ == comb_end_) {
+        ++set_size_;
+        comb_ = std::make_shared<CombinatorType>(
+            combinations(*container_p_, set_size_));
+
+        comb_iter_ = std::begin(*comb_);
+        comb_end_ = std::end(*comb_);
       }
       return *this;
     }
@@ -73,11 +72,11 @@ class iter::impl::Powersetter {
     }
 
     iterator_deref<CombinatorType> operator*() {
-      return *this->comb_iter;
+      return *comb_iter_;
     }
 
     iterator_arrow<CombinatorType> operator->() {
-      apply_arrow(this->comb_iter);
+      apply_arrow(comb_iter_);
     }
 
     bool operator!=(const Iterator& other) const {
@@ -85,17 +84,16 @@ class iter::impl::Powersetter {
     }
 
     bool operator==(const Iterator& other) const {
-      return this->set_size == other.set_size
-             && this->comb_iter == other.comb_iter;
+      return set_size_ == other.set_size_ && comb_iter_ == other.comb_iter_;
     }
   };
 
   Iterator begin() {
-    return {this->container, 0};
+    return {container_, 0};
   }
 
   Iterator end() {
-    return {this->container, dumb_size(this->container) + 1};
+    return {container_, dumb_size(container_) + 1};
   }
 };
 

From 751db3a85deb544f03587a601af90336744550b9 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 17:29:00 -0800
Subject: [PATCH 1539/1866] trailing _ on data members

---
 product.hpp | 51 +++++++++++++++++++++++++++------------------------
 1 file changed, 27 insertions(+), 24 deletions(-)

diff --git a/product.hpp b/product.hpp
index 31eb9555..e7e06f26 100644
--- a/product.hpp
+++ b/product.hpp
@@ -38,11 +38,11 @@ class iter::impl::Productor<Container, RestContainers...> {
       std::tuple<iterator_deref<Container>, iterator_deref<RestContainers>...>;
 
  private:
-  Container container;
-  Productor<RestContainers...> rest_products;
-  Productor(Container&& in_container, RestContainers&&... rest)
-      : container(std::forward<Container>(in_container)),
-        rest_products{std::forward<RestContainers>(rest)...} {}
+  Container container_;
+  Productor<RestContainers...> rest_products_;
+  Productor(Container&& container, RestContainers&&... rest)
+      : container_(std::forward<Container>(container)),
+        rest_products_{std::forward<RestContainers>(rest)...} {}
 
  public:
   Productor(Productor&&) = default;
@@ -51,27 +51,30 @@ class iter::impl::Productor<Container, RestContainers...> {
    private:
     using RestIter = typename Productor<RestContainers...>::Iterator;
 
-    IteratorWrapper<Container> iter;
-    IteratorWrapper<Container> begin;
+    IteratorWrapper<Container> sub_iter_;
+    IteratorWrapper<Container> sub_begin_;
 
-    RestIter rest_iter;
-    RestIter rest_end;
+    RestIter rest_iter_;
+    RestIter rest_end_;
 
    public:
     constexpr static const bool is_base_iter = false;
-    Iterator(IteratorWrapper<Container>&& it, RestIter&& rest,
-        RestIter&& in_rest_end)
-        : iter{it}, begin{it}, rest_iter{rest}, rest_end{in_rest_end} {}
+    Iterator(IteratorWrapper<Container>&& sub_iter, RestIter&& rest_iter,
+        RestIter&& rest_end)
+        : sub_iter_{sub_iter},
+          sub_begin_{sub_iter},
+          rest_iter_{rest_iter},
+          rest_end_{rest_end} {}
 
     void reset() {
-      this->iter = this->begin;
+      sub_iter_ = sub_begin_;
     }
 
     Iterator& operator++() {
-      ++this->rest_iter;
-      if (!(this->rest_iter != this->rest_end)) {
-        this->rest_iter.reset();
-        ++this->iter;
+      ++rest_iter_;
+      if (!(rest_iter_ != rest_end_)) {
+        rest_iter_.reset();
+        ++sub_iter_;
       }
       return *this;
     }
@@ -83,8 +86,8 @@ class iter::impl::Productor<Container, RestContainers...> {
     }
 
     bool operator!=(const Iterator& other) const {
-      return this->iter != other.iter
-             && (RestIter::is_base_iter || this->rest_iter != other.rest_iter);
+      return sub_iter_ != other.sub_iter_
+             && (RestIter::is_base_iter || rest_iter_ != other.rest_iter_);
     }
 
     bool operator==(const Iterator& other) const {
@@ -93,7 +96,7 @@ class iter::impl::Productor<Container, RestContainers...> {
 
     ProdIterDeref operator*() {
       return std::tuple_cat(
-          std::tuple<iterator_deref<Container>>{*this->iter}, *this->rest_iter);
+          std::tuple<iterator_deref<Container>>{*sub_iter_}, *rest_iter_);
     }
 
     ArrowProxy<ProdIterDeref> operator->() {
@@ -102,13 +105,13 @@ class iter::impl::Productor<Container, RestContainers...> {
   };
 
   Iterator begin() {
-    return {std::begin(this->container), std::begin(this->rest_products),
-        std::end(this->rest_products)};
+    return {std::begin(container_), std::begin(rest_products_),
+        std::end(rest_products_)};
   }
 
   Iterator end() {
-    return {std::end(this->container), std::end(this->rest_products),
-        std::end(this->rest_products)};
+    return {std::end(container_), std::end(rest_products_),
+        std::end(rest_products_)};
   }
 };
 

From 9e00b9428701780731fdde7ba482611940a5fc30 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 17:29:06 -0800
Subject: [PATCH 1540/1866] trailing _ on data members

---
 range.hpp | 70 ++++++++++++++++++++++++++++---------------------------
 1 file changed, 36 insertions(+), 34 deletions(-)

diff --git a/range.hpp b/range.hpp
index 0aafa7de..3d2df9b8 100644
--- a/range.hpp
+++ b/range.hpp
@@ -40,19 +40,19 @@ namespace iter {
           : value_{in_value}, step_{in_step} {}
 
       constexpr T value() const noexcept {
-        return this->value_;
+        return value_;
       }
 
       constexpr T step() const noexcept {
-        return this->step_;
+        return step_;
       }
 
       void inc() noexcept {
-        this->value_ += step_;
+        value_ += step_;
       }
 
       constexpr bool operator==(const RangeIterData& other) const noexcept {
-        return this->value_ == other.value_;
+        return value_ == other.value_;
       }
 
       constexpr bool operator!=(const RangeIterData& other) const noexcept {
@@ -67,7 +67,7 @@ namespace iter {
       T start_{};
       T value_{};
       T step_{};
-      std::size_t steps_taken{};
+      std::size_t steps_taken_{};
 
      public:
       constexpr RangeIterData() noexcept = default;
@@ -75,24 +75,24 @@ namespace iter {
           : start_{in_start}, value_{in_start}, step_{in_step} {}
 
       constexpr T value() const noexcept {
-        return this->value_;
+        return value_;
       }
 
       constexpr T step() const noexcept {
-        return this->step_;
+        return step_;
       }
 
       void inc() noexcept {
-        ++this->steps_taken;
-        value_ = this->start_ + (this->step_ * this->steps_taken);
+        ++steps_taken_;
+        value_ = start_ + (step_ * steps_taken_);
       }
 
       constexpr bool operator==(const RangeIterData& other) const noexcept {
         // if the difference between the two values is less than the
-        // step size, they are considered equal
-        return (this->value_ < other.value_ ? other.value_ - this->value_
-                                            : this->value_ - other.value_)
-               < this->step_;
+        // step_ size, they are considered equal
+        return (value_ < other.value_ ? other.value_ - value_
+                                      : value_ - other.value_)
+               < step_;
       }
 
       constexpr bool operator!=(const RangeIterData& other) const noexcept {
@@ -114,14 +114,14 @@ class iter::impl::Range {
   friend constexpr Range<U> iter::range(U, U, U) noexcept;
 
  private:
-  const T start;
-  const T stop;
-  const T step;
+  const T start_;
+  const T stop_;
+  const T step_;
 
-  constexpr Range(T in_stop) noexcept : start{0}, stop{in_stop}, step{1} {}
+  constexpr Range(T stop) noexcept : start_{0}, stop_{stop}, step_{1} {}
 
-  constexpr Range(T in_start, T in_stop, T in_step = 1) noexcept
-      : start{in_start}, stop{in_stop}, step{in_step} {}
+  constexpr Range(T start, T stop, T step = 1) noexcept
+      : start_{start}, stop_{stop}, step_{step} {}
 
  public:
   // the reference type here is T, which doesn't strictly follow all
@@ -168,7 +168,7 @@ class iter::impl::Range {
         : data(in_value, in_step), is_end{in_is_end} {}
 
     constexpr T operator*() const noexcept {
-      return this->data.value();
+      return data.value();
     }
 
     constexpr ArrowProxy<T> operator->() const noexcept {
@@ -176,7 +176,7 @@ class iter::impl::Range {
     }
 
     Iterator& operator++() noexcept {
-      this->data.inc();
+      data.inc();
       return *this;
     }
 
@@ -196,9 +196,9 @@ class iter::impl::Range {
     // infinitely (theoretically).  If this occurs, the Range
     // will instead effectively be empty
     //
-    // 2) (stop - start) % step != 0.  For
+    // 2) (stop_ - start_) % step_ != 0.  For
     // example Range(1, 10, 2).  The iterator will never be
-    // exactly equal to the stop value.
+    // exactly equal to the stop_ value.
     //
     // Another way to think about it is that the "end"
     // iterator represents the range of values that are invalid
@@ -208,12 +208,12 @@ class iter::impl::Range {
     //
     // Two non-end iterators will compare by their stored values
     bool operator!=(const Iterator& other) const noexcept {
-      if (this->is_end && other.is_end) {
+      if (is_end && other.is_end) {
         return false;
       }
 
-      if (!this->is_end && !other.is_end) {
-        return this->data != other.data;
+      if (!is_end && !other.is_end) {
+        return data != other.data;
       }
       return not_equal_to_end(*this, other);
     }
@@ -224,27 +224,29 @@ class iter::impl::Range {
   };
 
   constexpr Iterator begin() const noexcept {
-    return {start, step, false};
+    return {start_, step_, false};
   }
 
   constexpr Iterator end() const noexcept {
-    return {stop, step, true};
+    return {stop_, step_, true};
   }
 };
 
 template <typename T>
-constexpr iter::impl::Range<T> iter::range(T stop) noexcept {
-  return {stop};
+constexpr iter::impl::Range<T> iter::range(T stop_) noexcept {
+  return {stop_};
 }
 
 template <typename T>
-constexpr iter::impl::Range<T> iter::range(T start, T stop) noexcept {
-  return {start, stop};
+constexpr iter::impl::Range<T> iter::range(T start_, T stop_) noexcept {
+  return {start_, stop_};
 }
 
 template <typename T>
-constexpr iter::impl::Range<T> iter::range(T start, T stop, T step) noexcept {
-  return step == T(0) ? impl::Range<T>{0} : impl::Range<T>{start, stop, step};
+constexpr iter::impl::Range<T> iter::range(
+    T start_, T stop_, T step_) noexcept {
+  return step_ == T(0) ? impl::Range<T>{0}
+                       : impl::Range<T>{start_, stop_, step_};
 }
 
 #endif

From f547dfa85d0273d8fae21fa82917c5333c584a8f Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 17:29:12 -0800
Subject: [PATCH 1541/1866] trailing _ on data members

---
 repeat.hpp | 42 +++++++++++++++++++++---------------------
 1 file changed, 21 insertions(+), 21 deletions(-)

diff --git a/repeat.hpp b/repeat.hpp
index 0dd8cf91..1073d750 100644
--- a/repeat.hpp
+++ b/repeat.hpp
@@ -23,11 +23,11 @@ class iter::impl::RepeaterWithCount {
   friend constexpr RepeaterWithCount<U> iter::repeat(U&&, int);
 
  private:
-  T elem;
-  int count;
+  T elem_;
+  int count_;
 
   constexpr RepeaterWithCount(T e, int c)
-      : elem(std::forward<T>(e)), count{c} {}
+      : elem_(std::forward<T>(e)), count_{c} {}
 
   using TPlain = typename std::remove_reference<T>::type;
 
@@ -36,14 +36,14 @@ class iter::impl::RepeaterWithCount {
 
   class Iterator : public std::iterator<std::input_iterator_tag, const TPlain> {
    private:
-    const TPlain* elem;
-    int count;
+    const TPlain* elem_;
+    int count_;
 
    public:
-    constexpr Iterator(const TPlain* e, int c) : elem{e}, count{c} {}
+    constexpr Iterator(const TPlain* e, int c) : elem_{e}, count_{c} {}
 
     Iterator& operator++() {
-      --this->count;
+      --this->count_;
       return *this;
     }
 
@@ -58,30 +58,30 @@ class iter::impl::RepeaterWithCount {
     }
 
     constexpr bool operator==(const Iterator& other) const {
-      return this->count == other.count;
+      return this->count_ == other.count_;
     }
 
     constexpr const TPlain& operator*() const {
-      return *this->elem;
+      return *this->elem_;
     }
 
     constexpr const TPlain* operator->() const {
-      return this->elem;
+      return this->elem_;
     }
   };
 
   constexpr Iterator begin() const {
-    return {&this->elem, this->count};
+    return {&this->elem_, this->count_};
   }
 
   constexpr Iterator end() const {
-    return {&this->elem, 0};
+    return {&this->elem_, 0};
   }
 };
 
 template <typename T>
-constexpr iter::impl::RepeaterWithCount<T> iter::repeat(T&& e, int count) {
-  return {std::forward<T>(e), count < 0 ? 0 : count};
+constexpr iter::impl::RepeaterWithCount<T> iter::repeat(T&& e, int count_) {
+  return {std::forward<T>(e), count_ < 0 ? 0 : count_};
 }
 
 namespace iter {
@@ -101,19 +101,19 @@ class iter::impl::Repeater {
 
  private:
   using TPlain = typename std::remove_reference<T>::type;
-  T elem;
+  T elem_;
 
-  constexpr Repeater(T e) : elem(std::forward<T>(e)) {}
+  constexpr Repeater(T e) : elem_(std::forward<T>(e)) {}
 
  public:
   Repeater(Repeater&&) = default;
 
   class Iterator : public std::iterator<std::input_iterator_tag, const TPlain> {
    private:
-    const TPlain* elem;
+    const TPlain* elem_;
 
    public:
-    constexpr Iterator(const TPlain* e) : elem{e} {}
+    constexpr Iterator(const TPlain* e) : elem_{e} {}
 
     constexpr const Iterator& operator++() const {
       return *this;
@@ -132,16 +132,16 @@ class iter::impl::Repeater {
     }
 
     constexpr const TPlain& operator*() const {
-      return *this->elem;
+      return *this->elem_;
     }
 
     constexpr const TPlain* operator->() const {
-      return this->elem;
+      return this->elem_;
     }
   };
 
   constexpr Iterator begin() const {
-    return {&this->elem};
+    return {&this->elem_};
   }
 
   constexpr Iterator end() const {

From 0382c985126d2018f931925632c715f88f72ec8c Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 17:29:18 -0800
Subject: [PATCH 1542/1866] trailing _ on data members

---
 reversed.hpp | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/reversed.hpp b/reversed.hpp
index b17457c3..987b0cd5 100644
--- a/reversed.hpp
+++ b/reversed.hpp
@@ -49,11 +49,11 @@ namespace iter {
 template <typename Container>
 class iter::impl::Reverser {
  private:
-  Container container;
+  Container container_;
   friend ReversedFn;
 
-  Reverser(Container&& in_container)
-      : container(std::forward<Container>(in_container)) {}
+  Reverser(Container&& container)
+      : container_(std::forward<Container>(container)) {}
 
   using reverse_iterator_deref =
       decltype(*std::declval<reverse_iterator_type<Container>&>());
@@ -69,22 +69,22 @@ class iter::impl::Reverser {
   class Iterator : public std::iterator<std::input_iterator_tag,
                        reverse_iterator_traits_deref> {
    private:
-    ReverseIteratorWrapper<Container> sub_iter;
+    ReverseIteratorWrapper<Container> sub_iter_;
 
    public:
-    Iterator(ReverseIteratorWrapper<Container>&& iter)
-        : sub_iter{std::move(iter)} {}
+    Iterator(ReverseIteratorWrapper<Container>&& sub_iter)
+        : sub_iter_{std::move(sub_iter)} {}
 
     reverse_iterator_deref operator*() {
-      return *this->sub_iter;
+      return *sub_iter_;
     }
 
     reverse_iterator_arrow operator->() {
-      return apply_arrow(this->sub_iter);
+      return apply_arrow(sub_iter_);
     }
 
     Iterator& operator++() {
-      ++this->sub_iter;
+      ++sub_iter_;
       return *this;
     }
 
@@ -95,7 +95,7 @@ class iter::impl::Reverser {
     }
 
     bool operator!=(const Iterator& other) const {
-      return this->sub_iter != other.sub_iter;
+      return sub_iter_ != other.sub_iter_;
     }
 
     bool operator==(const Iterator& other) const {
@@ -104,11 +104,11 @@ class iter::impl::Reverser {
   };
 
   Iterator begin() {
-    return {std::rbegin(this->container)};
+    return {std::rbegin(container_)};
   }
 
   Iterator end() {
-    return {std::rend(this->container)};
+    return {std::rend(container_)};
   }
 };
 

From 36e7ac929ed9bedba3561ed9ca849b01a554ef92 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 17:29:25 -0800
Subject: [PATCH 1543/1866] trailing _ on data members

---
 slice.hpp | 85 +++++++++++++++++++++++++++----------------------------
 1 file changed, 42 insertions(+), 43 deletions(-)

diff --git a/slice.hpp b/slice.hpp
index c1d21e3a..ff4979a5 100644
--- a/slice.hpp
+++ b/slice.hpp
@@ -19,53 +19,54 @@ namespace iter {
 template <typename Container, typename DifferenceType>
 class iter::impl::Sliced {
  private:
-  Container container;
-  DifferenceType start;
-  DifferenceType stop;
-  DifferenceType step;
+  Container container_;
+  DifferenceType start_;
+  DifferenceType stop_;
+  DifferenceType step_;
 
   friend SliceFn;
 
-  Sliced(Container&& in_container, DifferenceType in_start,
-      DifferenceType in_stop, DifferenceType in_step)
-      : container(std::forward<Container>(in_container)),
-        start{in_start < in_stop && in_step > 0 ? in_start : in_stop},
-        stop{in_stop},
-        step{in_step} {}
+  Sliced(Container&& container, DifferenceType start, DifferenceType stop,
+      DifferenceType step)
+      : container_(std::forward<Container>(container)),
+        start_{start < stop && step > 0 ? start : stop},
+        stop_{stop},
+        step_{step} {}
 
  public:
   Sliced(Sliced&&) = default;
   class Iterator : public std::iterator<std::input_iterator_tag,
                        iterator_traits_deref<Container>> {
    private:
-    IteratorWrapper<Container> sub_iter;
-    IteratorWrapper<Container> sub_end;
-    DifferenceType current;
-    DifferenceType stop;
-    DifferenceType step;
+    IteratorWrapper<Container> sub_iter_;
+    IteratorWrapper<Container> sub_end_;
+    DifferenceType current_;
+    DifferenceType stop_;
+    DifferenceType step_;
 
    public:
-    Iterator(IteratorWrapper<Container>&& si, IteratorWrapper<Container>&& se,
-        DifferenceType in_start, DifferenceType in_stop, DifferenceType in_step)
-        : sub_iter{std::move(si)},
-          sub_end{std::move(se)},
-          current{in_start},
-          stop{in_stop},
-          step{in_step} {}
+    Iterator(IteratorWrapper<Container>&& sub_iter,
+        IteratorWrapper<Container>&& sub_end, DifferenceType start,
+        DifferenceType stop, DifferenceType step)
+        : sub_iter_{std::move(sub_iter)},
+          sub_end_{std::move(sub_end)},
+          current_{start},
+          stop_{stop},
+          step_{step} {}
 
     iterator_deref<Container> operator*() {
-      return *this->sub_iter;
+      return *sub_iter_;
     }
 
     iterator_arrow<Container> operator->() {
-      return apply_arrow(this->sub_iter);
+      return apply_arrow(sub_iter_);
     }
 
     Iterator& operator++() {
-      dumb_advance(this->sub_iter, this->sub_end, this->step);
-      this->current += this->step;
-      if (this->stop < this->current) {
-        this->current = this->stop;
+      dumb_advance(sub_iter_, sub_end_, step_);
+      current_ += step_;
+      if (stop_ < current_) {
+        current_ = stop_;
       }
       return *this;
     }
@@ -77,7 +78,7 @@ class iter::impl::Sliced {
     }
 
     bool operator!=(const Iterator& other) const {
-      return this->sub_iter != other.sub_iter && this->current != other.current;
+      return sub_iter_ != other.sub_iter_ && current_ != other.current_;
     }
 
     bool operator==(const Iterator& other) const {
@@ -86,15 +87,13 @@ class iter::impl::Sliced {
   };
 
   Iterator begin() {
-    auto it = std::begin(this->container);
-    dumb_advance(it, std::end(this->container), this->start);
-    return {std::move(it), std::end(this->container), this->start, this->stop,
-        this->step};
+    auto it = std::begin(container_);
+    dumb_advance(it, std::end(container_), start_);
+    return {std::move(it), std::end(container_), start_, stop_, step_};
   }
 
   Iterator end() {
-    return {std::end(this->container), std::end(this->container), this->stop,
-        this->stop, this->step};
+    return {std::end(container_), std::end(container_), stop_, stop_, step_};
   }
 };
 
@@ -105,17 +104,17 @@ struct iter::impl::SliceFn {
    public:
     template <typename Container>
     Sliced<Container, DifferenceType> operator()(Container&& container) const {
-      return {std::forward<Container>(container), start, stop, step};
+      return {std::forward<Container>(container), start_, stop_, step_};
     }
 
    private:
     friend SliceFn;
-    constexpr FnPartial(DifferenceType in_start, DifferenceType in_stop,
-        DifferenceType in_step) noexcept
-        : start{in_start}, stop{in_stop}, step{in_step} {}
-    DifferenceType start;
-    DifferenceType stop;
-    DifferenceType step;
+    constexpr FnPartial(
+        DifferenceType start, DifferenceType stop, DifferenceType step) noexcept
+        : start_{start}, stop_{stop}, step_{step} {}
+    DifferenceType start_;
+    DifferenceType stop_;
+    DifferenceType step_;
   };
 
  public:
@@ -127,7 +126,7 @@ struct iter::impl::SliceFn {
     return {std::forward<Container>(container), start, stop, step};
   }
 
-  // only given the end, assume step is 1 and begin is 0
+  // only given the end, assume step_ is 1 and begin is 0
   template <typename Container, typename DifferenceType,
       typename = std::enable_if_t<is_iterable<Container>>>
   iter::impl::Sliced<Container, DifferenceType> operator()(

From 29c669c9462cdc268d999ec28385f6b5bfa1d605 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 17:29:32 -0800
Subject: [PATCH 1544/1866] trailing _ on data members

---
 sliding_window.hpp | 47 +++++++++++++++++++++++-----------------------
 1 file changed, 23 insertions(+), 24 deletions(-)

diff --git a/sliding_window.hpp b/sliding_window.hpp
index 2dc6e81d..27539c87 100644
--- a/sliding_window.hpp
+++ b/sliding_window.hpp
@@ -21,13 +21,13 @@ namespace iter {
 template <typename Container>
 class iter::impl::WindowSlider {
  private:
-  Container container;
-  std::size_t window_size;
+  Container container_;
+  std::size_t window_size_;
 
   friend SlidingWindowFn;
 
-  WindowSlider(Container&& in_container, std::size_t win_sz)
-      : container(std::forward<Container>(in_container)), window_size{win_sz} {}
+  WindowSlider(Container&& container, std::size_t win_sz)
+      : container_(std::forward<Container>(container)), window_size_{win_sz} {}
 
   using IndexVector = std::deque<IteratorWrapper<Container>>;
   using DerefVec = IterIterWrapper<IndexVector>;
@@ -36,25 +36,25 @@ class iter::impl::WindowSlider {
   WindowSlider(WindowSlider&&) = default;
   class Iterator : public std::iterator<std::input_iterator_tag, DerefVec> {
    private:
-    IteratorWrapper<Container> sub_iter;
-    DerefVec window;
+    IteratorWrapper<Container> sub_iter_;
+    DerefVec window_;
 
    public:
-    Iterator(IteratorWrapper<Container>&& in_iter,
-        IteratorWrapper<Container>&& in_end, std::size_t window_sz)
-        : sub_iter(std::move(in_iter)) {
+    Iterator(IteratorWrapper<Container>&& sub_iter,
+        IteratorWrapper<Container>&& sub_end, std::size_t window_sz)
+        : sub_iter_(std::move(sub_iter)) {
       std::size_t i{0};
-      while (i < window_sz && this->sub_iter != in_end) {
-        this->window.get().push_back(this->sub_iter);
+      while (i < window_sz && sub_iter_ != sub_end) {
+        window_.get().push_back(sub_iter_);
         ++i;
         if (i != window_sz) {
-          ++this->sub_iter;
+          ++sub_iter_;
         }
       }
     }
 
     bool operator!=(const Iterator& other) const {
-      return this->sub_iter != other.sub_iter;
+      return sub_iter_ != other.sub_iter_;
     }
 
     bool operator==(const Iterator& other) const {
@@ -62,17 +62,17 @@ class iter::impl::WindowSlider {
     }
 
     DerefVec& operator*() {
-      return this->window;
+      return window_;
     }
 
     DerefVec* operator->() {
-      return this->window;
+      return window_;
     }
 
     Iterator& operator++() {
-      ++this->sub_iter;
-      this->window.get().pop_front();
-      this->window.get().push_back(this->sub_iter);
+      ++sub_iter_;
+      window_.get().pop_front();
+      window_.get().push_back(sub_iter_);
       return *this;
     }
 
@@ -84,15 +84,14 @@ class iter::impl::WindowSlider {
   };
 
   Iterator begin() {
-    return {(this->window_size != 0
-                    ? IteratorWrapper<Container>{std::begin(this->container)}
-                    : IteratorWrapper<Container>{std::end(this->container)}),
-        std::end(this->container), this->window_size};
+    return {
+        (window_size_ != 0 ? IteratorWrapper<Container>{std::begin(container_)}
+                           : IteratorWrapper<Container>{std::end(container_)}),
+        std::end(container_), window_size_};
   }
 
   Iterator end() {
-    return {std::end(this->container), std::end(this->container),
-        this->window_size};
+    return {std::end(container_), std::end(container_), window_size_};
   }
 };
 

From cdcf2aeb58b55b1d25239d00565cd083c6d56a82 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 17:29:37 -0800
Subject: [PATCH 1545/1866] trailing _ on data members

---
 sorted.hpp | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/sorted.hpp b/sorted.hpp
index 5393d3a7..4caf35e0 100644
--- a/sorted.hpp
+++ b/sorted.hpp
@@ -25,20 +25,20 @@ class iter::impl::SortedView {
 
   friend SortedFn;
 
-  Container container;
-  IterIterWrap sorted_iters;
-
-  SortedView(Container&& in_container, CompareFunc compare_func)
-      : container(std::forward<Container>(in_container)) {
-    // Fill the sorted_iters vector with an iterator to each
-    // element in the container
-    for (auto iter = std::begin(this->container);
-         iter != std::end(this->container); ++iter) {
-      this->sorted_iters.get().push_back(iter);
+  Container container_;
+  IterIterWrap sorted_iters_;
+
+  SortedView(Container&& container, CompareFunc compare_func)
+      : container_(std::forward<Container>(container)) {
+    // Fill the sorted_iters_ vector with an iterator to each
+    // element in the container_
+    for (auto iter = std::begin(container_); iter != std::end(container_);
+         ++iter) {
+      sorted_iters_.get().push_back(iter);
     }
 
     // sort by comparing the elements that the iterators point to
-    std::sort(std::begin(sorted_iters.get()), std::end(sorted_iters.get()),
+    std::sort(std::begin(sorted_iters_.get()), std::end(sorted_iters_.get()),
         [compare_func](iterator_type<Container> it1,
             iterator_type<Container> it2) { return compare_func(*it1, *it2); });
   }
@@ -47,11 +47,11 @@ class iter::impl::SortedView {
   SortedView(SortedView&&) = default;
 
   ItIt begin() {
-    return std::begin(sorted_iters);
+    return std::begin(sorted_iters_);
   }
 
   ItIt end() {
-    return std::end(sorted_iters);
+    return std::end(sorted_iters_);
   }
 };
 

From d36b6b13687a9149bafe6994406c67b89773e079 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 17:29:42 -0800
Subject: [PATCH 1546/1866] trailing _ on data members

---
 starmap.hpp | 56 ++++++++++++++++++++++++++---------------------------
 1 file changed, 28 insertions(+), 28 deletions(-)

diff --git a/starmap.hpp b/starmap.hpp
index f71aaf6c..84cb2da9 100644
--- a/starmap.hpp
+++ b/starmap.hpp
@@ -24,21 +24,21 @@ namespace iter {
   }
 }
 
-// NOTE I don't know why, but clang gets very confused by having this-> in the
+// NOTE I don't know why, but clang gets very confused by having  in the
 // Iterators' member functions for these classes
 
-// starmap with a container<T> where T is one of tuple, pair, array
+// starmap with a container_<T> where T is one of tuple, pair, array
 template <typename Func, typename Container>
 class iter::impl::StarMapper {
  private:
-  Func func;
-  Container container;
+  Func func_;
+  Container container_;
 
   using StarIterDeref = std::remove_reference_t<decltype(
-      call_with_tuple(func, std::declval<iterator_deref<Container>>()))>;
+      call_with_tuple(func_, std::declval<iterator_deref<Container>>()))>;
 
   StarMapper(Func f, Container&& c)
-      : func(std::move(f)), container(std::forward<Container>(c)) {}
+      : func_(std::move(f)), container_(std::forward<Container>(c)) {}
 
   friend StarMapFn;
 
@@ -46,15 +46,15 @@ class iter::impl::StarMapper {
   class Iterator
       : public std::iterator<std::input_iterator_tag, StarIterDeref> {
    private:
-    Func* func;
-    IteratorWrapper<Container> sub_iter;
+    Func* func_;
+    IteratorWrapper<Container> sub_iter_;
 
    public:
-    Iterator(Func& f, IteratorWrapper<Container>&& iter)
-        : func(&f), sub_iter(std::move(iter)) {}
+    Iterator(Func& f, IteratorWrapper<Container>&& sub_iter)
+        : func_(&f), sub_iter_(std::move(sub_iter)) {}
 
     bool operator!=(const Iterator& other) const {
-      return this->sub_iter != other.sub_iter;
+      return sub_iter_ != other.sub_iter_;
     }
 
     bool operator==(const Iterator& other) const {
@@ -62,7 +62,7 @@ class iter::impl::StarMapper {
     }
 
     Iterator& operator++() {
-      ++this->sub_iter;
+      ++sub_iter_;
       return *this;
     }
 
@@ -73,7 +73,7 @@ class iter::impl::StarMapper {
     }
 
     decltype(auto) operator*() {
-      return call_with_tuple(*func, *sub_iter);
+      return call_with_tuple(*func_, *sub_iter_);
     }
 
     auto operator-> () -> ArrowProxy<decltype(**this)> {
@@ -82,11 +82,11 @@ class iter::impl::StarMapper {
   };
 
   Iterator begin() {
-    return {this->func, std::begin(this->container)};
+    return {func_, std::begin(container_)};
   }
 
   Iterator end() {
-    return {this->func, std::end(this->container)};
+    return {func_, std::end(container_)};
   }
 };
 
@@ -94,8 +94,8 @@ class iter::impl::StarMapper {
 template <typename Func, typename TupType, std::size_t... Is>
 class iter::impl::TupleStarMapper {
  private:
-  Func func;
-  TupType tup;
+  Func func_;
+  TupType tup_;
 
  private:
   static_assert(sizeof...(Is) == std::tuple_size<std::decay_t<TupType>>::value,
@@ -108,7 +108,7 @@ class iter::impl::TupleStarMapper {
     return call_with_tuple(f, std::get<Idx>(t));
   }
 
-  using ResultType = decltype(get_and_call_with_tuple<0>(func, tup));
+  using ResultType = decltype(get_and_call_with_tuple<0>(func_, tup_));
   using CallerFunc = ResultType (*)(Func&, TupType&);
 
   constexpr static std::array<CallerFunc, sizeof...(Is)> callers{
@@ -117,21 +117,21 @@ class iter::impl::TupleStarMapper {
   using TraitsValue = std::remove_reference_t<ResultType>;
 
   TupleStarMapper(Func f, TupType t)
-      : func(std::move(f)), tup(std::forward<TupType>(t)) {}
+      : func_(std::move(f)), tup_(std::forward<TupType>(t)) {}
 
  public:
   class Iterator : public std::iterator<std::input_iterator_tag, TraitsValue> {
    private:
-    Func* func;
-    std::remove_reference_t<TupType>* tup;
-    std::size_t index;
+    Func* func_;
+    std::remove_reference_t<TupType>* tup_;
+    std::size_t index_;
 
    public:
     Iterator(Func& f, TupType& t, std::size_t i)
-        : func{&f}, tup{&t}, index{i} {}
+        : func_{&f}, tup_{&t}, index_{i} {}
 
     decltype(auto) operator*() {
-      return callers[index](*func, *tup);
+      return callers[index_](*func_, *tup_);
     }
 
     auto operator-> () -> ArrowProxy<decltype(**this)> {
@@ -139,7 +139,7 @@ class iter::impl::TupleStarMapper {
     }
 
     Iterator& operator++() {
-      ++index;
+      ++index_;
       return *this;
     }
 
@@ -150,7 +150,7 @@ class iter::impl::TupleStarMapper {
     }
 
     bool operator!=(const Iterator& other) const {
-      return index != other.index;
+      return index_ != other.index_;
     }
 
     bool operator==(const Iterator& other) const {
@@ -159,11 +159,11 @@ class iter::impl::TupleStarMapper {
   };
 
   Iterator begin() {
-    return {this->func, this->tup, 0};
+    return {func_, tup_, 0};
   }
 
   Iterator end() {
-    return {this->func, this->tup, sizeof...(Is)};
+    return {func_, tup_, sizeof...(Is)};
   }
 };
 

From 3f4a694980d340dc06ba9903247cd1715516b2fc Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 17:29:49 -0800
Subject: [PATCH 1547/1866] trailing _ on data members

---
 takewhile.hpp | 61 ++++++++++++++++++++++++---------------------------
 1 file changed, 29 insertions(+), 32 deletions(-)

diff --git a/takewhile.hpp b/takewhile.hpp
index 53df6a2a..e180acd1 100644
--- a/takewhile.hpp
+++ b/takewhile.hpp
@@ -21,14 +21,14 @@ namespace iter {
 template <typename FilterFunc, typename Container>
 class iter::impl::Taker {
  private:
-  Container container;
-  FilterFunc filter_func;
+  Container container_;
+  FilterFunc filter_func_;
 
   friend TakeWhileFn;
 
-  Taker(FilterFunc in_filter_func, Container&& in_container)
-      : container(std::forward<Container>(in_container)),
-        filter_func(in_filter_func) {}
+  Taker(FilterFunc filter_func, Container&& container)
+      : container_(std::forward<Container>(container)),
+        filter_func_(filter_func) {}
 
  public:
   Taker(Taker&&) = default;
@@ -37,48 +37,47 @@ class iter::impl::Taker {
                        iterator_traits_deref<Container>> {
    private:
     using Holder = DerefHolder<iterator_deref<Container>>;
-    IteratorWrapper<Container> sub_iter;
-    IteratorWrapper<Container> sub_end;
-    Holder item;
-    FilterFunc* filter_func;
+    IteratorWrapper<Container> sub_iter_;
+    IteratorWrapper<Container> sub_end_;
+    Holder item_;
+    FilterFunc* filter_func_;
 
     void inc_sub_iter() {
-      ++this->sub_iter;
-      if (this->sub_iter != this->sub_end) {
-        this->item.reset(*this->sub_iter);
+      ++sub_iter_;
+      if (sub_iter_ != sub_end_) {
+        item_.reset(*sub_iter_);
       }
     }
 
     void check_current() {
-      if (this->sub_iter != this->sub_end
-          && !(*this->filter_func)(this->item.get())) {
-        this->sub_iter = this->sub_end;
+      if (sub_iter_ != sub_end_ && !(*filter_func_)(item_.get())) {
+        sub_iter_ = sub_end_;
       }
     }
 
    public:
-    Iterator(IteratorWrapper<Container>&& iter,
-        IteratorWrapper<Container>&& end, FilterFunc& in_filter_func)
-        : sub_iter{std::move(iter)},
-          sub_end{std::move(end)},
-          filter_func(&in_filter_func) {
-      if (this->sub_iter != this->sub_end) {
-        this->item.reset(*this->sub_iter);
+    Iterator(IteratorWrapper<Container>&& sub_iter,
+        IteratorWrapper<Container>&& sub_end, FilterFunc& filter_func)
+        : sub_iter_{std::move(sub_iter)},
+          sub_end_{std::move(sub_end)},
+          filter_func_(&filter_func) {
+      if (sub_iter_ != sub_end_) {
+        item_.reset(*sub_iter_);
       }
-      this->check_current();
+      check_current();
     }
 
     typename Holder::reference operator*() {
-      return this->item.get();
+      return item_.get();
     }
 
     typename Holder::pointer operator->() {
-      return this->item.get_ptr();
+      return item_.get_ptr();
     }
 
     Iterator& operator++() {
-      this->inc_sub_iter();
-      this->check_current();
+      inc_sub_iter();
+      check_current();
       return *this;
     }
 
@@ -89,7 +88,7 @@ class iter::impl::Taker {
     }
 
     bool operator!=(const Iterator& other) const {
-      return this->sub_iter != other.sub_iter;
+      return sub_iter_ != other.sub_iter_;
     }
 
     bool operator==(const Iterator& other) const {
@@ -98,13 +97,11 @@ class iter::impl::Taker {
   };
 
   Iterator begin() {
-    return {std::begin(this->container), std::end(this->container),
-        this->filter_func};
+    return {std::begin(container_), std::end(container_), filter_func_};
   }
 
   Iterator end() {
-    return {std::end(this->container), std::end(this->container),
-        this->filter_func};
+    return {std::end(container_), std::end(container_), filter_func_};
   }
 };
 

From ca3ae7a9755969401859c9f17d9d660478343dd4 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 17:29:53 -0800
Subject: [PATCH 1548/1866] trailing _ on data members

---
 zip.hpp | 25 +++++++++++++------------
 1 file changed, 13 insertions(+), 12 deletions(-)

diff --git a/zip.hpp b/zip.hpp
index 75bdba1d..89182fe6 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -25,25 +25,26 @@ namespace iter {
 template <typename TupleType, std::size_t... Is>
 class iter::impl::Zipped {
  private:
-  TupleType containers;
+  TupleType containers_;
   friend Zipped iter::impl::zip_impl<TupleType, Is...>(
       TupleType&&, std::index_sequence<Is...>);
 
   using ZipIterDeref = iterator_deref_tuple<TupleType>;
 
-  Zipped(TupleType&& in_containers) : containers(std::move(in_containers)) {}
+  Zipped(TupleType&& containers) : containers_(std::move(containers)) {}
 
  public:
   Zipped(Zipped&&) = default;
   class Iterator : public std::iterator<std::input_iterator_tag, ZipIterDeref> {
    private:
-    iterator_tuple_type<TupleType> iters;
+    iterator_tuple_type<TupleType> iters_;
 
    public:
-    Iterator(iterator_tuple_type<TupleType>&& its) : iters(std::move(its)) {}
+    Iterator(iterator_tuple_type<TupleType>&& iters)
+        : iters_(std::move(iters)) {}
 
     Iterator& operator++() {
-      absorb(++std::get<Is>(this->iters)...);
+      absorb(++std::get<Is>(iters_)...);
       return *this;
     }
 
@@ -57,7 +58,7 @@ class iter::impl::Zipped {
       if (sizeof...(Is) == 0) return false;
 
       bool results[] = {
-          true, (std::get<Is>(this->iters) != std::get<Is>(other.iters))...};
+          true, (std::get<Is>(iters_) != std::get<Is>(other.iters_))...};
       return std::all_of(
           std::begin(results), std::end(results), [](bool b) { return b; });
     }
@@ -67,7 +68,7 @@ class iter::impl::Zipped {
     }
 
     ZipIterDeref operator*() {
-      return ZipIterDeref{(*std::get<Is>(this->iters))...};
+      return ZipIterDeref{(*std::get<Is>(iters_))...};
     }
 
     auto operator-> () -> ArrowProxy<decltype(**this)> {
@@ -77,19 +78,19 @@ class iter::impl::Zipped {
 
   Iterator begin() {
     return {iterator_tuple_type<TupleType>{
-        std::begin(std::get<Is>(this->containers))...}};
+        std::begin(std::get<Is>(containers_))...}};
   }
 
   Iterator end() {
-    return {iterator_tuple_type<TupleType>{
-        std::end(std::get<Is>(this->containers))...}};
+    return {
+        iterator_tuple_type<TupleType>{std::end(std::get<Is>(containers_))...}};
   }
 };
 
 template <typename TupleType, std::size_t... Is>
 iter::impl::Zipped<TupleType, Is...> iter::impl::zip_impl(
-    TupleType&& in_containers, std::index_sequence<Is...>) {
-  return {std::move(in_containers)};
+    TupleType&& containers, std::index_sequence<Is...>) {
+  return {std::move(containers)};
 }
 
 template <typename... Containers>

From a7ada5d14f259a7426292535ef1df444363cca37 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 17:30:00 -0800
Subject: [PATCH 1549/1866] trailing _ on data members

---
 zip_longest.hpp | 44 ++++++++++++++++++++------------------------
 1 file changed, 20 insertions(+), 24 deletions(-)

diff --git a/zip_longest.hpp b/zip_longest.hpp
index f20ba869..b72aa5c7 100644
--- a/zip_longest.hpp
+++ b/zip_longest.hpp
@@ -26,7 +26,7 @@ namespace iter {
 template <typename TupleType, std::size_t... Is>
 class iter::impl::ZippedLongest {
  private:
-  TupleType containers;
+  TupleType containers_;
   friend ZippedLongest zip_longest_impl<TupleType, Is...>(
       TupleType&&, std::index_sequence<Is...>);
 
@@ -36,26 +36,25 @@ class iter::impl::ZippedLongest {
 
   using ZipIterDeref = std::tuple<OptType<Is>...>;
 
-  ZippedLongest(TupleType&& in_containers)
-      : containers(std::move(in_containers)) {}
+  ZippedLongest(TupleType&& containers) : containers_(std::move(containers)) {}
 
  public:
   ZippedLongest(ZippedLongest&&) = default;
   class Iterator : public std::iterator<std::input_iterator_tag, ZipIterDeref> {
    private:
-    iterator_tuple_type<TupleType> iters;
-    iterator_tuple_type<TupleType> ends;
+    iterator_tuple_type<TupleType> iters_;
+    iterator_tuple_type<TupleType> ends_;
 
    public:
-    Iterator(iterator_tuple_type<TupleType>&& in_iters,
-        iterator_tuple_type<TupleType>&& in_ends)
-        : iters(std::move(in_iters)), ends(std::move(in_ends)) {}
+    Iterator(iterator_tuple_type<TupleType>&& iters,
+        iterator_tuple_type<TupleType>&& ends)
+        : iters_(std::move(iters)), ends_(std::move(ends)) {}
 
     Iterator& operator++() {
       // increment every iterator that's not already at
       // the end
-      absorb(((std::get<Is>(this->iters) != std::get<Is>(this->ends))
-                  ? (++std::get<Is>(this->iters), 0)
+      absorb(((std::get<Is>(iters_) != std::get<Is>(ends_))
+                  ? (++std::get<Is>(iters_), 0)
                   : 0)...);
       return *this;
     }
@@ -70,7 +69,7 @@ class iter::impl::ZippedLongest {
       if (sizeof...(Is) == 0) return false;
 
       bool results[] = {
-          false, (std::get<Is>(this->iters) != std::get<Is>(other.iters))...};
+          false, (std::get<Is>(iters_) != std::get<Is>(other.iters_))...};
       return std::any_of(
           std::begin(results), std::end(results), [](bool b) { return b; });
     }
@@ -80,10 +79,9 @@ class iter::impl::ZippedLongest {
     }
 
     ZipIterDeref operator*() {
-      return ZipIterDeref{
-          ((std::get<Is>(this->iters) != std::get<Is>(this->ends))
-                  ? OptType<Is>{*std::get<Is>(this->iters)}
-                  : OptType<Is>{})...};
+      return ZipIterDeref{((std::get<Is>(iters_) != std::get<Is>(ends_))
+                               ? OptType<Is>{*std::get<Is>(iters_)}
+                               : OptType<Is>{})...};
     }
 
     auto operator-> () -> ArrowProxy<decltype(**this)> {
@@ -93,23 +91,21 @@ class iter::impl::ZippedLongest {
 
   Iterator begin() {
     return {iterator_tuple_type<TupleType>{
-                std::begin(std::get<Is>(this->containers))...},
-        iterator_tuple_type<TupleType>{
-            std::end(std::get<Is>(this->containers))...}};
+                std::begin(std::get<Is>(containers_))...},
+        iterator_tuple_type<TupleType>{std::end(std::get<Is>(containers_))...}};
   }
 
   Iterator end() {
-    return {iterator_tuple_type<TupleType>{
-                std::end(std::get<Is>(this->containers))...},
-        iterator_tuple_type<TupleType>{
-            std::end(std::get<Is>(this->containers))...}};
+    return {
+        iterator_tuple_type<TupleType>{std::end(std::get<Is>(containers_))...},
+        iterator_tuple_type<TupleType>{std::end(std::get<Is>(containers_))...}};
   }
 };
 
 template <typename TupleType, std::size_t... Is>
 iter::impl::ZippedLongest<TupleType, Is...> iter::impl::zip_longest_impl(
-    TupleType&& in_containers, std::index_sequence<Is...>) {
-  return {std::move(in_containers)};
+    TupleType&& containers, std::index_sequence<Is...>) {
+  return {std::move(containers)};
 }
 
 template <typename... Containers>

From c5c53ea6580bbb3f1add09046f3620e422cc9afa Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 17:31:55 -0800
Subject: [PATCH 1550/1866] s/functor/callable

---
 test/test_filter.cpp      | 2 +-
 test/test_filterfalse.cpp | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/test_filter.cpp b/test/test_filter.cpp
index 4badfaf1..bb29ee90 100644
--- a/test/test_filter.cpp
+++ b/test/test_filter.cpp
@@ -30,7 +30,7 @@ namespace {
   };
 }
 
-TEST_CASE("filter: handles different functor types", "[filter]") {
+TEST_CASE("filter: handles different callable types", "[filter]") {
   Vec ns = {1, 2, 5, 6, 3, 1, 7, -1, 5};
   Vec vc = {1, 2, 3, 1, -1};
   SECTION("with function pointer") {
diff --git a/test/test_filterfalse.cpp b/test/test_filterfalse.cpp
index dec5c2eb..07726cf8 100644
--- a/test/test_filterfalse.cpp
+++ b/test/test_filterfalse.cpp
@@ -30,7 +30,7 @@ namespace {
   };
 }
 
-TEST_CASE("filterfalse: handles different functor types", "[filterfalse]") {
+TEST_CASE("filterfalse: handles different callable types", "[filterfalse]") {
   Vec ns = {1, 2, 5, 6, 3, 1, 7, -1, 5};
   Vec vc = {5, 6, 7, 5};
   SECTION("with function pointer") {

From bdd8a054cd304bbeb69ac8e181a71c5897d4a1ae Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 17:33:07 -0800
Subject: [PATCH 1551/1866] Fixes init list example

Dropped support for that a while ago.
---
 examples/sliding_window_examples.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/sliding_window_examples.cpp b/examples/sliding_window_examples.cpp
index 3c0d39dd..ff286202 100644
--- a/examples/sliding_window_examples.cpp
+++ b/examples/sliding_window_examples.cpp
@@ -13,7 +13,7 @@ int main() {
     }
 
     std::cout << "Empty when window size is > length\n";
-    for (auto&& sec : iter::sliding_window({1,2,3}, 10)) {
+    for (auto&& sec : iter::sliding_window(std::vector<int>{1,2,3}, 10)) {
         for (auto&& i : sec) {
             std::cout << i << ' ';
         }

From c1ac1d743d4b67d1cdcb9e37f80efab21dcf6cab Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 17:48:18 -0800
Subject: [PATCH 1552/1866] Switches to C++17!

---
 test/SConstruct | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/SConstruct b/test/SConstruct
index d2198470..5c4bc272 100644
--- a/test/SConstruct
+++ b/test/SConstruct
@@ -3,7 +3,7 @@ import os
 env = Environment(
     ENV = os.environ,
     CXXFLAGS= ['-g', '-Wall', '-Wextra',
-               '-pedantic', '-std=c++14',
+               '-pedantic', '-std=c++17',
                '-I/usr/local/include', '-I.'],
     CPPPATH='..',
     LINKFLAGS=['-L/usr/local/lib'])

From 965b8b6e8e54f6af399326fa799dbfba576dbfef Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 20 Feb 2017 23:53:22 -0800
Subject: [PATCH 1553/1866] Rewrite of iterator_wrapper with std::variant

So much code deleted. So much nicer now. The future looks bright.
---
 internal/iterator_wrapper.hpp | 123 +++++++---------------------------
 1 file changed, 26 insertions(+), 97 deletions(-)

diff --git a/internal/iterator_wrapper.hpp b/internal/iterator_wrapper.hpp
index a181539f..9a94e89a 100644
--- a/internal/iterator_wrapper.hpp
+++ b/internal/iterator_wrapper.hpp
@@ -2,6 +2,8 @@
 #define ITERTOOLS_ITERATOR_WRAPPER_HPP_
 
 #include <cassert>
+#include <functional>
+#include <variant>
 #include "iterbase.hpp"
 
 namespace iter {
@@ -38,132 +40,59 @@ namespace iter {
 template <typename SubIter, typename SubEnd>
 class iter::impl::IteratorWrapperImpl {
  private:
-  static_assert(!std::is_same<SubIter, SubEnd>{}, "");
-  enum class IterState { Normal, End, Uninitialized };
-
-  void destroy_sub() {
-    if (state_ == IterState::Normal) {
-      sub_iter_.~SubIter();
-    } else if (state_ == IterState::End) {
-      sub_end_.~SubEnd();
-    }
-    state_ = IterState::Uninitialized;
+  static_assert(!std::is_same<SubIter, SubEnd>{});
+  SubIter& sub_iter() {
+    auto* sub = std::get_if<SubIter>(&sub_iter_or_end_);
+    assert(sub);
+    return *sub;
   }
 
-  template <typename T>
-  void copy_or_move_sub_from(T&& other) {
-    if (this == &other) {
-      return;
-    }
-    if (state_ == other.state_) {
-      if (state_ == IterState::Normal) {
-        sub_iter_ = std::forward<T>(other).sub_iter_;
-      } else if (state_ == IterState::End) {
-        sub_end_ = std::forward<T>(other).sub_end_;
-      }
-    } else {
-      // state_s are different, must destroy and reconstruct
-      destroy_sub();
-      if (other.state_ == IterState::Normal) {
-        new (&sub_iter_) SubIter(std::forward<T>(other).sub_iter_);
-      } else if (other.state_ == IterState::End) {
-        new (&sub_end_) SubEnd(std::forward<T>(other).sub_end_);
-      }
-      state_ = other.state_;
-    }
-  }
-
-  void copy_sub_from(const IteratorWrapperImpl& other) {
-    copy_or_move_sub_from(other);
-  }
-
-  void move_sub_from(IteratorWrapperImpl&& other) {
-    copy_or_move_sub_from(std::move(other));
+  const SubIter& sub_iter() const {
+    auto* sub = std::get_if<SubIter>(&sub_iter_or_end_);
+    assert(sub);
+    return *sub;
   }
 
-  // TODO replace with std::variant when C++17 is going strong
-  union {
-    SubIter sub_iter_;
-    SubEnd sub_end_;
-  };
-  IterState state_{IterState::Uninitialized};
+  std::variant<SubIter, SubEnd> sub_iter_or_end_;
 
  public:
   IteratorWrapperImpl() : IteratorWrapperImpl(SubIter{}) {}
 
-  IteratorWrapperImpl(const IteratorWrapperImpl& other) {
-    copy_sub_from(other);
-  }
+  IteratorWrapperImpl(SubIter&& it) : sub_iter_or_end_{std::move(it)} {}
 
-  IteratorWrapperImpl& operator=(const IteratorWrapperImpl& other) {
-    copy_sub_from(other);
-    return *this;
-  }
-
-  IteratorWrapperImpl(IteratorWrapperImpl&& other) {
-    move_sub_from(std::move(other));
-  }
-
-  IteratorWrapperImpl& operator=(IteratorWrapperImpl&& other) {
-    move_sub_from(std::move(other));
-    return *this;
-  }
-
-  IteratorWrapperImpl(SubIter&& it)
-      : sub_iter_{std::move(it)}, state_{IterState::Normal} {}
-
-  IteratorWrapperImpl(SubEnd&& it)
-      : sub_end_(std::move(it)), state_{IterState::End} {}
+  IteratorWrapperImpl(SubEnd&& it) : sub_iter_or_end_(std::move(it)) {}
 
   IteratorWrapperImpl& operator++() {
-    assert(state_ == IterState::Normal);  // because ++ing the end is UB
-    ++sub_iter_;
+    ++sub_iter();
     return *this;
   }
 
   decltype(auto) operator*() {
-    assert(state_ == IterState::Normal);  // because *ing the end is UB
-    return *sub_iter_;
+    return *sub_iter();
   }
 
   decltype(auto) operator*() const {
-    assert(state_ == IterState::Normal);  // because *ing the end is UB
-    return *sub_iter_;
+    return *sub_iter();
   }
 
   decltype(auto) operator-> () {
-    assert(state_ == IterState::Normal);
-    return apply_arrow(sub_iter_);
+    return apply_arrow(sub_iter());
   }
 
   decltype(auto) operator-> () const {
-    assert(state_ == IterState::Normal);
-    return apply_arrow(sub_iter_);
+    return apply_arrow(sub_iter());
   }
 
   bool operator!=(const IteratorWrapperImpl& other) const {
-    assert(state_ != IterState::Uninitialized
-           && other.state_ != IterState::Uninitialized);
-    if (state_ == other.state_) {
-      if (state_ == IterState::End) {
-        // NOTE this used to be return sub_end_ != other.sub_end_;
-        // but rangev3 sentinels aren't comparable
-        // https://github.com/ericniebler/range-v3/issues/564
+    constexpr static struct : std::not_equal_to<void> {
+      // specially compare Ends because rangev3 sentinels are not equality
+      // comparable
+      bool operator()(const SubEnd&, const SubEnd&) const {
         return false;
-      } else {
-        return sub_iter_ != other.sub_iter_;
-      }
-    } else {
-      if (state_ == IterState::Normal) {  // other is End
-        return sub_iter_ != other.sub_end_;
-      } else {  // other is Normal
-        return sub_end_ != other.sub_iter_;
       }
-    }
-  }
-
-  ~IteratorWrapperImpl() {
-    this->destroy_sub();
+      using std::not_equal_to<void>::operator();
+    } not_equal;
+    return std::visit(not_equal, sub_iter_or_end_, other.sub_iter_or_end_);
   }
 };
 

From ccb84810169ce699e9060c613b690a9526189044 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 23 Feb 2017 12:03:24 -0800
Subject: [PATCH 1554/1866] uses structured bindings in zip_examples

---
 examples/zip_examples.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/examples/zip_examples.cpp b/examples/zip_examples.cpp
index 0b7f347a..d35dd0cf 100644
--- a/examples/zip_examples.cpp
+++ b/examples/zip_examples.cpp
@@ -10,8 +10,8 @@ int main() {
 
     // zip terminates on the shortest sequence, and is variadic
     std::cout << "zipping a vector of ints and a vector of strings\n";
-    for (auto&& e : iter::zip(ivec, svec)) {
-        std::cout << '(' << std::get<0>(e) << ", " << std::get<1>(e) << ")\n";
+    for (auto&& [i, s] : iter::zip(ivec, svec)) {
+        std::cout << '(' << i << ", " << s << ")\n";
     }
 }
 

From 49a9a85522ed1b8c62291a87bd4e4a11619c6d6b Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 23 Feb 2017 12:04:15 -0800
Subject: [PATCH 1555/1866] uses structured bindings in zip_longest_examples

---
 examples/zip_longest_examples.cpp | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/examples/zip_longest_examples.cpp b/examples/zip_longest_examples.cpp
index 1bbffbf8..5f8dc9e7 100644
--- a/examples/zip_longest_examples.cpp
+++ b/examples/zip_longest_examples.cpp
@@ -22,8 +22,7 @@ int main() {
     std::vector<std::string> svec = {"hello", "good day", "goodbye"};
 
     std::cout << "zipping a vector of strings with a vector of ints:\n";
-    for (auto&& e : iter::zip_longest(ivec, svec)) {
-        std::cout << '(' << std::get<0>(e) << ", "
-            << std::get<1>(e)  << ")\n";
+    for (auto&& [i, s] : iter::zip_longest(ivec, svec)) {
+        std::cout << '(' << i << ", " << s  << ")\n";
     }
 }

From f42a27d912c7e04d7139991d7737feb500adecf6 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 23 Feb 2017 12:05:27 -0800
Subject: [PATCH 1556/1866] uses structured bindings in product example

---
 examples/combinatoric_examples.cpp | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/examples/combinatoric_examples.cpp b/examples/combinatoric_examples.cpp
index d7111a56..653d428c 100644
--- a/examples/combinatoric_examples.cpp
+++ b/examples/combinatoric_examples.cpp
@@ -45,11 +45,8 @@ int main() {
 
     std::vector<std::string> v3 = {"abc", "def"};
     std::cout << "product of three vectors (int, int, string):\n";
-    for (auto&& t : iter::product(v1,v2,v3)) {
-        std::cout << "{ "
-            << std::get<0>(t) << ' '
-            << std::get<1>(t) << ' '
-            << std::get<2>(t) << " }\n";
+    for (auto&& [a, b, c] : iter::product(v1,v2,v3)) {
+        std::cout << "{ " << a << ' ' << b << ' ' << c << " }\n";
     }
 
     std::cout << "powerset({1,2,3,4,5}):\n";

From 9f0d349dfcf6cdcaf0e3b411f44f3c79015cdf11 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 23 Feb 2017 12:09:09 -0800
Subject: [PATCH 1557/1866] uses structured bindings in README zip example

---
 README.md | 19 ++++++++-----------
 1 file changed, 8 insertions(+), 11 deletions(-)

diff --git a/README.md b/README.md
index a740372d..4af5b982 100644
--- a/README.md
+++ b/README.md
@@ -500,17 +500,14 @@ tuple of the elements the iterators were holding.
 
 Example usage:
 ```c++
-array<int,4> i{{1,2,3,4}};
-vector<float> f{1.2,1.4,12.3,4.5,9.9};
-vector<string> s{"i","like","apples","alot","dude"};
-array<double,5> d{{1.2,1.2,1.2,1.2,1.2}};
-
-for (auto&& e : zip(i,f,s,d)) {
-    cout << std::get<0>(e) << ' '
-         << std::get<1>(e) << ' '
-         << std::get<2>(e) << ' '
-         << std::get<3>(e) << '\n';
-    std::get<1>(e)=2.2f; // modifies the underlying 'f' array
+array<int,4> iseq{{1,2,3,4}};
+vector<float> fseq{1.2,1.4,12.3,4.5,9.9};
+vector<string> sseq{"i","like","apples","a lot","dude"};
+array<double,5> dseq{{1.2,1.2,1.2,1.2,1.2}};
+
+for (auto&& [i, f, s, d] : zip(iseq, fseq, sseq, dseq)) {
+    cout << i << ' ' << f << ' ' << s << ' ' << d << '\n';
+    f = 2.2f; // modifies the underlying 'fseq' sequence
 }
 ```
 

From a3592d9dac066507ddeb2913867daaf733cf388b Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 23 Feb 2017 12:10:25 -0800
Subject: [PATCH 1558/1866] uses structured bindings in README zip_longest ex

---
 README.md | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/README.md b/README.md
index 4af5b982..587a8118 100644
--- a/README.md
+++ b/README.md
@@ -524,16 +524,16 @@ element in each tuple yielded.
 ```c++
 vector<int> v1 = {0, 1, 2, 3};
 vector<int> v2 = {10, 11};
-for (auto&& t : zip_longest(v1, v2)) {
+for (auto&& [x, y] : zip_longest(v1, v2)) {
     cout << '{';
-    if (std::get<0>(t)) {
-        cout << "Just " << *std::get<0>(t);
+    if (x) {
+        cout << "Just " << *x;
     } else {
         cout << "Nothing";
     }
     cout << ", ";
-    if (std::get<1>(t)) {
-        cout << "Just " << *std::get<1>(t);
+    if (y) {
+        cout << "Just " << *y;
     } else {
         cout << "Nothing";
     }

From cc06e7a5ae2c96013eb08a2c4b8b941f741420f0 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 23 Feb 2017 12:18:37 -0800
Subject: [PATCH 1559/1866] uses structured bindings in README product example

---
 README.md | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/README.md b/README.md
index 587a8118..e7bcd27e 100644
--- a/README.md
+++ b/README.md
@@ -749,12 +749,9 @@ Example usage:
 vector<int> v1{1,2,3};
 vector<int> v2{7,8};
 vector<string> v3{"the","cat"};
-vector<string> v4{"hi","what","up","dude"};
-for (auto&& t : product(v1,v2,v3,v4)) {
-    cout << std::get<0>(t) << ", "
-        << std::get<1>(t) << ", "
-        << std::get<2>(t) << ", "
-        << std::get<3>(t) << '\n';
+vector<string> v4{"hi","what's","up","dude"};
+for (auto&& [a, b, c, d] : product(v1,v2,v3,v4)) {
+    cout << a << ", " << b << ", " << c << ", " << d << '\n';
 }
 ```
 

From 72164712b7dd7ae6e94b56280792b20d3a479046 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 23 Feb 2017 22:01:52 -0800
Subject: [PATCH 1560/1866] uses structured bindings in test_zip

---
 test/test_zip.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/test/test_zip.cpp b/test/test_zip.cpp
index b0312e1e..0fc3b8fc 100644
--- a/test/test_zip.cpp
+++ b/test/test_zip.cpp
@@ -67,9 +67,9 @@ TEST_CASE("zip: Empty", "[zip]") {
 TEST_CASE("zip: Modify sequence through zip", "[zip]") {
   std::vector<int> iv{1, 2, 3};
   std::vector<int> iv2{1, 2, 3, 4};
-  for (auto&& t : zip(iv, iv2)) {
-    std::get<0>(t) = -1;
-    std::get<1>(t) = -1;
+  for (auto&& [a, b] : zip(iv, iv2)) {
+    a = -1;
+    b = -1;
   }
 
   const std::vector<int> vc{-1, -1, -1};

From 606bd1f5415a2c9e793433f16c97420cdeceac71 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 23 Feb 2017 22:02:07 -0800
Subject: [PATCH 1561/1866] uses structured bindings in test_zip_longest

---
 test/test_zip_longest.cpp | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/test/test_zip_longest.cpp b/test/test_zip_longest.cpp
index 85b8ee31..fd421097 100644
--- a/test/test_zip_longest.cpp
+++ b/test/test_zip_longest.cpp
@@ -90,8 +90,8 @@ TEST_CASE(
   CharRange cr('c');
 
   ResVec v;
-  for (auto&& p : zip_longest(iv, cr)) {
-    v.push_back(TP{*std::get<0>(p), *std::get<1>(p)});
+  for (auto&& [i, c] : zip_longest(iv, cr)) {
+    v.push_back(TP{*i, *c});
   }
   ResVec vc{TP{10, 'a'}, TP{20, 'b'}};
   REQUIRE(v == vc);
@@ -110,9 +110,9 @@ TEST_CASE(
 TEST_CASE("zip longest: can modify zipped sequences", "[zip_longest]") {
   std::vector<int> ns1 = {1, 2, 3};
   std::vector<int> ns2 = {10, 11, 12};
-  for (auto&& t : zip_longest(ns1, ns2)) {
-    *std::get<0>(t) = -1;
-    *std::get<1>(t) = -1;
+  for (auto&& [a, b] : zip_longest(ns1, ns2)) {
+    *a = -1;
+    *b = -1;
   }
 
   std::vector<int> vc = {-1, -1, -1};

From 150792dd39b4cd65f4876bba445080e3baff07f2 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 24 Feb 2017 23:41:21 -0800
Subject: [PATCH 1562/1866] Adds get_begin() and get_end() for non-members

These should delegate to std::begin or non-member begin (or end).
Whatever works.
---
 examples/SConstruct   | 12 ++++++++----
 internal/iterbase.hpp | 39 ++++++++++++++++++++++++++++++++-------
 2 files changed, 40 insertions(+), 11 deletions(-)

diff --git a/examples/SConstruct b/examples/SConstruct
index 947064f9..8a6b6f40 100644
--- a/examples/SConstruct
+++ b/examples/SConstruct
@@ -2,12 +2,16 @@ import os
 
 env = Environment(
     ENV=os.environ,
-    CXX='c++',
+    CXX='clang++',
     CXXFLAGS= ['-g', '-Wall', '-Wextra',
-               '-pedantic', '-std=c++14',
-               '-I/usr/local/include'],
+               '-stdlib=libc++',
+               '-pedantic', '-std=c++1z',
+               '-I/usr/local/include'
+    ],
     CPPPATH='..',
-    LINKFLAGS='-L/usr/local/lib')
+    LINKFLAGS=['-L/usr/local/lib',
+    '-lc++', '-lc++abi',
+    ])
 
 # allows highighting to print to terminal from compiler output
 env['ENV']['TERM'] = os.environ['TERM']
diff --git a/internal/iterbase.hpp b/internal/iterbase.hpp
index 032d8e00..9970610c 100644
--- a/internal/iterbase.hpp
+++ b/internal/iterbase.hpp
@@ -17,6 +17,31 @@
 
 namespace iter {
   namespace impl {
+    namespace get_iters {
+      // This has to be set up in a really weird way.
+      // This looks at first as if it could be
+      // decltype(auto) get_begin(T& t) {
+      //     using std::begin;
+      //     return begin(t);
+      // }
+      // However, without return types in the declaration, SFINAE gets
+      // messed up everywhere.
+      using std::begin;
+      // TODO add constexpr for c++17
+      template <typename T>
+      auto get_begin(T& t) -> decltype(begin(t)) {
+        return begin(t);
+      }
+      using std::end;
+      // TODO add constexpr for c++17
+      template <typename T>
+      auto get_end(T& t) -> decltype(end(t)) {
+        return end(t);
+      }
+    }
+    using get_iters::get_begin;
+    using get_iters::get_end;
+
     template <typename T>
     struct type_is {
       using type = T;
@@ -32,7 +57,7 @@ namespace iter {
 
     // iterator_type<C> is the type of C's iterator
     template <typename Container>
-    using iterator_type = decltype(std::begin(std::declval<Container&>()));
+    using iterator_type = decltype(get_begin(std::declval<Container&>()));
 
     // iterator_deref<C> is the type obtained by dereferencing an iterator
     // to an object of type C
@@ -53,7 +78,7 @@ namespace iter {
     template <typename T, typename = void>
     struct IsIterable : std::false_type {};
 
-    // Assuming that if a type works with std::begin, it is an iterable.
+    // Assuming that if a type works with begin, it is an iterable.
     template <typename T>
     struct IsIterable<T, void_t<iterator_type<T>>> : std::true_type {};
 
@@ -121,9 +146,9 @@ namespace iter {
 
     template <typename T>
     struct is_random_access_iter<T,
-        std::enable_if_t<std::is_same<
-            typename std::iterator_traits<T>::iterator_category,
-            std::random_access_iterator_tag>::value>> : std::true_type {};
+        std::enable_if_t<
+            std::is_same<typename std::iterator_traits<T>::iterator_category,
+                std::random_access_iterator_tag>::value>> : std::true_type {};
 
     template <typename T>
     using has_random_access_iter = is_random_access_iter<iterator_type<T>>;
@@ -177,8 +202,8 @@ namespace iter {
     template <typename Container, typename Distance = std::size_t>
     Distance dumb_size(Container&& container) {
       Distance d{0};
-      auto end_it = std::end(container);
-      for (auto it = std::begin(container); it != end_it; ++it) {
+      auto end_it = get_end(container);
+      for (auto it = get_begin(container); it != end_it; ++it) {
         ++d;
       }
       return d;

From 263bca384b662b8f97d304292da593f734018430 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 24 Feb 2017 23:43:26 -0800
Subject: [PATCH 1563/1866] Switches BasicIterable to non-member begin and end

---
 test/helpers.hpp | 65 ++++--------------------------------------------
 1 file changed, 5 insertions(+), 60 deletions(-)

diff --git a/test/helpers.hpp b/test/helpers.hpp
index 9cf67fd0..1ab8adfe 100644
--- a/test/helpers.hpp
+++ b/test/helpers.hpp
@@ -158,20 +158,20 @@ namespace itertest {
       }
     };
 
-    Iterator begin() {
-      return {this->data};
+    friend BasicIterable::Iterator begin(BasicIterable& b) {
+      return {b.data};
     }
 
-    Iterator end() {
-      return {this->data + this->size};
+    friend BasicIterable::Iterator end(BasicIterable& b) {
+      return {b.data + b.size};
     }
 
+
 #ifdef DECLARE_REVERSE_ITERATOR
     Iterator rbegin();
     Iterator rend();
 #endif  // ifdef DECLARE_REVERSE_ITERATOR
   };
-
   using iter::impl::void_t;
 
   template <typename, typename = void>
@@ -341,59 +341,4 @@ class IntCharPairRange
       : DiffEndRange<std::pair<int, char>, IncIntCharPair>({0, 'a'}, stop) {}
 };
 
-#if 0
-class CharRange {
-  private:
-    char stop_{};
-
-  public:
-    constexpr CharRange(char stop) : stop_{stop} {}
-
-    class Iterator;
-    class EndIterator;
-
-    class Iterator {
-      private:
-        char stop_{};
-        mutable char value_{'a'};
-      public:
-#ifdef CHAR_RANGE_DEFAULT_CONSTRUCTIBLE
-        Iterator() = default;
-#endif
-        Iterator(char stop) : stop_{stop} {}
-
-        char& operator*() const { return value_; }
-        char* operator->() const { return &value_; }
-
-        Iterator& operator++() {
-          ++value_;
-          return *this;
-        }
-
-        bool operator!=(const Iterator& other) const {
-          return value_ != other.value_;
-        }
-
-        bool operator!=(const EndIterator&) const {
-          return value_ < stop_;
-        }
-
-        friend bool operator!=(const EndIterator& lhs, const Iterator& rhs) {
-          return rhs != lhs;
-        }
-
-    };
-
-    class EndIterator { };
-
-    Iterator begin() {
-      return {stop_};
-    }
-
-    EndIterator end() {
-      return {};
-    }
-};
-#endif
-
 #endif

From 3a6db8349c298b0e685ca7938791b6aa01d83598 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 24 Feb 2017 23:43:55 -0800
Subject: [PATCH 1564/1866] Tests get_begin() returns correct type

---
 test/test_iterbase.cpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/test/test_iterbase.cpp b/test/test_iterbase.cpp
index 59b80066..fecfb9a4 100644
--- a/test/test_iterbase.cpp
+++ b/test/test_iterbase.cpp
@@ -89,3 +89,8 @@ TEST_CASE("DerefHolder non-reference", "[iterbase]") {
   dh.reset(std::move(b));
   REQUIRE(dh.get() == 5);
 }
+
+TEST_CASE("get_begin returns correct type", "[iterbase]") {
+  std::vector<int> v;
+  REQUIRE((std::is_same<decltype(it::get_begin(v)), decltype(v.begin())>{}));
+}

From d1d7e6ad71ff4e7e86c731eed01aaf4afeb4921b Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 24 Feb 2017 23:44:48 -0800
Subject: [PATCH 1565/1866] Uses get_begin and get_end throughout itertools

Now everything should work with non-member begin and end iterables.
Not that anyone cared enough to ask for it. Gotta stay ahead of the
game.
---
 accumulate.hpp                    |  4 ++--
 chain.hpp                         | 20 ++++++++++----------
 chunked.hpp                       |  4 ++--
 combinations.hpp                  |  8 ++++----
 combinations_with_replacement.hpp |  6 +++---
 compress.hpp                      | 10 +++++-----
 cycle.hpp                         |  4 ++--
 dropwhile.hpp                     |  4 ++--
 enumerate.hpp                     |  4 ++--
 filter.hpp                        |  4 ++--
 groupby.hpp                       |  4 ++--
 internal/iterator_wrapper.hpp     |  2 +-
 permutations.hpp                  | 10 +++++-----
 powerset.hpp                      |  8 ++++----
 product.hpp                       |  8 ++++----
 slice.hpp                         |  8 ++++----
 sliding_window.hpp                |  8 ++++----
 sorted.hpp                        |  8 ++++----
 starmap.hpp                       |  8 ++++----
 takewhile.hpp                     |  4 ++--
 unique_justseen.hpp               |  2 +-
 zip.hpp                           |  6 +++---
 zip_longest.hpp                   | 12 ++++++------
 23 files changed, 78 insertions(+), 78 deletions(-)

diff --git a/accumulate.hpp b/accumulate.hpp
index 64e3dd44..aec33626 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -107,11 +107,11 @@ class iter::impl::Accumulator {
   };
 
   Iterator begin() {
-    return {std::begin(container_), std::end(container_), accumulate_func_};
+    return {get_begin(container_), get_end(container_), accumulate_func_};
   }
 
   Iterator end() {
-    return {std::end(container_), std::end(container_), accumulate_func_};
+    return {get_end(container_), get_end(container_), accumulate_func_};
   }
 };
 
diff --git a/chain.hpp b/chain.hpp
index 7abb9f2a..90f553e1 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -144,13 +144,13 @@ class iter::impl::Chained {
   };
 
   Iterator begin() {
-    return {0, IterTupType{std::begin(std::get<Is>(tup_))...},
-        IterTupType{std::end(std::get<Is>(tup_))...}};
+    return {0, IterTupType{get_begin(std::get<Is>(tup_))...},
+        IterTupType{get_end(std::get<Is>(tup_))...}};
   }
 
   Iterator end() {
-    return {sizeof...(Is), IterTupType{std::end(std::get<Is>(tup_))...},
-        IterTupType{std::end(std::get<Is>(tup_))...}};
+    return {sizeof...(Is), IterTupType{get_end(std::get<Is>(tup_))...},
+        IterTupType{get_end(std::get<Is>(tup_))...}};
   }
 };
 
@@ -219,11 +219,11 @@ class iter::impl::ChainedFromIterable {
           sub_iter_p_{!(top_iter != top_end)
                           ?  // iter == end ?
                           nullptr
-                          : std::make_unique<SubIter>(std::begin(*top_iter))},
+                          : std::make_unique<SubIter>(get_begin(*top_iter))},
           sub_end_p_{!(top_iter != top_end)
                          ?  // iter == end ?
                          nullptr
-                         : std::make_unique<SubIter>(std::end(*top_iter))} {}
+                         : std::make_unique<SubIter>(get_end(*top_iter))} {}
 
     Iterator(const Iterator& other)
         : top_level_iter_{other.top_level_iter_},
@@ -253,8 +253,8 @@ class iter::impl::ChainedFromIterable {
       if (!(*sub_iter_p_ != *sub_end_p_)) {
         ++top_level_iter_;
         if (top_level_iter_ != top_level_end_) {
-          sub_iter_p_ = std::make_unique<SubIter>(std::begin(*top_level_iter_));
-          sub_end_p_ = std::make_unique<SubIter>(std::end(*top_level_iter_));
+          sub_iter_p_ = std::make_unique<SubIter>(get_begin(*top_level_iter_));
+          sub_end_p_ = std::make_unique<SubIter>(get_end(*top_level_iter_));
         } else {
           sub_iter_p_.reset();
           sub_end_p_.reset();
@@ -288,11 +288,11 @@ class iter::impl::ChainedFromIterable {
   };
 
   Iterator begin() {
-    return {std::begin(container_), std::end(container_)};
+    return {get_begin(container_), get_end(container_)};
   }
 
   Iterator end() {
-    return {std::end(container_), std::end(container_)};
+    return {get_end(container_), get_end(container_)};
   }
 };
 
diff --git a/chunked.hpp b/chunked.hpp
index 6dcb8917..90f578ca 100644
--- a/chunked.hpp
+++ b/chunked.hpp
@@ -99,11 +99,11 @@ class iter::impl::Chunker {
   };
 
   Iterator begin() {
-    return {std::begin(container_), std::end(container_), chunk_size_};
+    return {get_begin(container_), get_end(container_), chunk_size_};
   }
 
   Iterator end() {
-    return {std::end(container_), std::end(container_), chunk_size_};
+    return {get_end(container_), get_end(container_), chunk_size_};
   }
 };
 
diff --git a/combinations.hpp b/combinations.hpp
index 71660512..fe6c31ac 100644
--- a/combinations.hpp
+++ b/combinations.hpp
@@ -51,9 +51,9 @@ class iter::impl::Combinator {
       }
       size_t inc = 0;
       for (auto& iter : indices_.get()) {
-        auto it = std::begin(*container_p_);
-        dumb_advance(it, std::end(*container_p_), inc);
-        if (it != std::end(*container_p_)) {
+        auto it = get_begin(*container_p_);
+        dumb_advance(it, get_end(*container_p_), inc);
+        if (it != get_end(*container_p_)) {
           iter = it;
           ++inc;
         } else {
@@ -81,7 +81,7 @@ class iter::impl::Combinator {
         // between the item and end of item
         auto dist = std::distance(indices_.get().rbegin(), iter);
 
-        if (!(dumb_next(*iter, dist) != std::end(*container_p_))) {
+        if (!(dumb_next(*iter, dist) != get_end(*container_p_))) {
           if ((iter + 1) != indices_.get().rend()) {
             size_t inc = 1;
             for (auto down = iter; down != indices_.get().rbegin() - 1;
diff --git a/combinations_with_replacement.hpp b/combinations_with_replacement.hpp
index 2fa33bd8..0467147c 100644
--- a/combinations_with_replacement.hpp
+++ b/combinations_with_replacement.hpp
@@ -45,8 +45,8 @@ class iter::impl::CombinatorWithReplacement {
    public:
     Iterator(Container& in_container, std::size_t n)
         : container_p_{&in_container},
-          indices_(n, std::begin(in_container)),
-          steps_{(std::begin(in_container) != std::end(in_container) && n)
+          indices_(n, get_begin(in_container)),
+          steps_{(get_begin(in_container) != get_end(in_container) && n)
                      ? 0
                      : COMPLETE} {}
 
@@ -62,7 +62,7 @@ class iter::impl::CombinatorWithReplacement {
       for (auto iter = indices_.get().rbegin(); iter != indices_.get().rend();
            ++iter) {
         ++(*iter);
-        if (!(*iter != std::end(*container_p_))) {
+        if (!(*iter != get_end(*container_p_))) {
           if ((iter + 1) != indices_.get().rend()) {
             for (auto down = iter; down != indices_.get().rbegin() - 1;
                  --down) {
diff --git a/compress.hpp b/compress.hpp
index ede8e934..ca0da7d2 100644
--- a/compress.hpp
+++ b/compress.hpp
@@ -27,7 +27,7 @@ class iter::impl::Compressed {
       Container&&, Selector&&);
 
   // Selector::Iterator type
-  using selector_iter_type = decltype(std::begin(selectors_));
+  using selector_iter_type = decltype(get_begin(selectors_));
 
   Compressed(Container&& in_container, Selector&& in_selectors)
       : container_(std::forward<Container>(in_container)),
@@ -98,13 +98,13 @@ class iter::impl::Compressed {
   };
 
   Iterator begin() {
-    return {std::begin(container_), std::end(container_),
-        std::begin(selectors_), std::end(selectors_)};
+    return {get_begin(container_), get_end(container_), get_begin(selectors_),
+        get_end(selectors_)};
   }
 
   Iterator end() {
-    return {std::end(container_), std::end(container_), std::end(selectors_),
-        std::end(selectors_)};
+    return {get_end(container_), get_end(container_), get_end(selectors_),
+        get_end(selectors_)};
   }
 };
 
diff --git a/cycle.hpp b/cycle.hpp
index 24396e7e..cd058335 100644
--- a/cycle.hpp
+++ b/cycle.hpp
@@ -77,11 +77,11 @@ class iter::impl::Cycler {
   };
 
   Iterator begin() {
-    return {std::begin(container_), std::end(container_)};
+    return {get_begin(container_), get_end(container_)};
   }
 
   Iterator end() {
-    return {std::end(container_), std::end(container_)};
+    return {get_end(container_), get_end(container_)};
   }
 };
 
diff --git a/dropwhile.hpp b/dropwhile.hpp
index 1f544137..6e781baf 100644
--- a/dropwhile.hpp
+++ b/dropwhile.hpp
@@ -96,11 +96,11 @@ class iter::impl::Dropper {
   };
 
   Iterator begin() {
-    return {std::begin(container_), std::end(container_), filter_func_};
+    return {get_begin(container_), get_end(container_), filter_func_};
   }
 
   Iterator end() {
-    return {std::end(container_), std::end(container_), filter_func_};
+    return {get_end(container_), get_end(container_), filter_func_};
   }
 };
 
diff --git a/enumerate.hpp b/enumerate.hpp
index 9331b139..25fbceb6 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -89,11 +89,11 @@ class iter::impl::Enumerable {
   };
 
   Iterator begin() {
-    return {std::begin(container_), start_};
+    return {get_begin(container_), start_};
   }
 
   Iterator end() {
-    return {std::end(container_), start_};
+    return {get_end(container_), start_};
   }
 };
 
diff --git a/filter.hpp b/filter.hpp
index 1c118407..aa0de753 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -109,11 +109,11 @@ class iter::impl::Filtered {
   };
 
   Iterator begin() {
-    return {std::begin(container_), std::end(container_), filter_func_};
+    return {get_begin(container_), get_end(container_), filter_func_};
   }
 
   Iterator end() {
-    return {std::end(container_), std::end(container_), filter_func_};
+    return {get_end(container_), get_end(container_), filter_func_};
   }
 };
 
diff --git a/groupby.hpp b/groupby.hpp
index a4074b5b..1a06e60f 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -250,11 +250,11 @@ class iter::impl::GroupProducer {
   };
 
   Iterator begin() {
-    return {std::begin(container_), std::end(container_), key_func_};
+    return {get_begin(container_), get_end(container_), key_func_};
   }
 
   Iterator end() {
-    return {std::end(container_), std::end(container_), key_func_};
+    return {get_end(container_), get_end(container_), key_func_};
   }
 };
 
diff --git a/internal/iterator_wrapper.hpp b/internal/iterator_wrapper.hpp
index a181539f..272266cf 100644
--- a/internal/iterator_wrapper.hpp
+++ b/internal/iterator_wrapper.hpp
@@ -8,7 +8,7 @@ namespace iter {
   namespace impl {
     // iterator_end_type<C> is the type of C's end iterator
     template <typename Container>
-    using iterator_end_type = decltype(std::end(std::declval<Container&>()));
+    using iterator_end_type = decltype(get_end(std::declval<Container&>()));
 
     template <typename SubIter, typename SubEnd>
     class IteratorWrapperImpl;
diff --git a/permutations.hpp b/permutations.hpp
index a522a980..540ae62b 100644
--- a/permutations.hpp
+++ b/permutations.hpp
@@ -57,7 +57,7 @@ class iter::impl::Permuter {
         working_set_.get().push_back(sub_iter);
         ++sub_iter;
       }
-      std::sort(std::begin(working_set_.get()), std::end(working_set_.get()),
+      std::sort(get_begin(working_set_.get()), get_end(working_set_.get()),
           cmp_iters);
     }
 
@@ -71,8 +71,8 @@ class iter::impl::Permuter {
 
     Iterator& operator++() {
       ++steps_;
-      if (!std::next_permutation(std::begin(working_set_.get()),
-              std::end(working_set_.get()), cmp_iters)) {
+      if (!std::next_permutation(get_begin(working_set_.get()),
+              get_end(working_set_.get()), cmp_iters)) {
         steps_ = COMPLETE;
       }
       return *this;
@@ -94,11 +94,11 @@ class iter::impl::Permuter {
   };
 
   Iterator begin() {
-    return {std::begin(container_), std::end(container_)};
+    return {get_begin(container_), get_end(container_)};
   }
 
   Iterator end() {
-    return {std::end(container_), std::end(container_)};
+    return {get_end(container_), get_end(container_)};
   }
 };
 
diff --git a/powerset.hpp b/powerset.hpp
index 2cbad540..9c369e98 100644
--- a/powerset.hpp
+++ b/powerset.hpp
@@ -49,8 +49,8 @@ class iter::impl::Powersetter {
         : container_p_{&container},
           set_size_{sz},
           comb_{std::make_shared<CombinatorType>(combinations(container, sz))},
-          comb_iter_{std::begin(*comb_)},
-          comb_end_{std::end(*comb_)} {}
+          comb_iter_{get_begin(*comb_)},
+          comb_end_{get_end(*comb_)} {}
 
     Iterator& operator++() {
       ++comb_iter_;
@@ -59,8 +59,8 @@ class iter::impl::Powersetter {
         comb_ = std::make_shared<CombinatorType>(
             combinations(*container_p_, set_size_));
 
-        comb_iter_ = std::begin(*comb_);
-        comb_end_ = std::end(*comb_);
+        comb_iter_ = get_begin(*comb_);
+        comb_end_ = get_end(*comb_);
       }
       return *this;
     }
diff --git a/product.hpp b/product.hpp
index e7e06f26..db9d31f7 100644
--- a/product.hpp
+++ b/product.hpp
@@ -105,13 +105,13 @@ class iter::impl::Productor<Container, RestContainers...> {
   };
 
   Iterator begin() {
-    return {std::begin(container_), std::begin(rest_products_),
-        std::end(rest_products_)};
+    return {get_begin(container_), get_begin(rest_products_),
+        get_end(rest_products_)};
   }
 
   Iterator end() {
-    return {std::end(container_), std::end(rest_products_),
-        std::end(rest_products_)};
+    return {
+        get_end(container_), get_end(rest_products_), get_end(rest_products_)};
   }
 };
 
diff --git a/slice.hpp b/slice.hpp
index ff4979a5..1ee4252a 100644
--- a/slice.hpp
+++ b/slice.hpp
@@ -87,13 +87,13 @@ class iter::impl::Sliced {
   };
 
   Iterator begin() {
-    auto it = std::begin(container_);
-    dumb_advance(it, std::end(container_), start_);
-    return {std::move(it), std::end(container_), start_, stop_, step_};
+    auto it = get_begin(container_);
+    dumb_advance(it, get_end(container_), start_);
+    return {std::move(it), get_end(container_), start_, stop_, step_};
   }
 
   Iterator end() {
-    return {std::end(container_), std::end(container_), stop_, stop_, step_};
+    return {get_end(container_), get_end(container_), stop_, stop_, step_};
   }
 };
 
diff --git a/sliding_window.hpp b/sliding_window.hpp
index 27539c87..84c0e4b1 100644
--- a/sliding_window.hpp
+++ b/sliding_window.hpp
@@ -85,13 +85,13 @@ class iter::impl::WindowSlider {
 
   Iterator begin() {
     return {
-        (window_size_ != 0 ? IteratorWrapper<Container>{std::begin(container_)}
-                           : IteratorWrapper<Container>{std::end(container_)}),
-        std::end(container_), window_size_};
+        (window_size_ != 0 ? IteratorWrapper<Container>{get_begin(container_)}
+                           : IteratorWrapper<Container>{get_end(container_)}),
+        get_end(container_), window_size_};
   }
 
   Iterator end() {
-    return {std::end(container_), std::end(container_), window_size_};
+    return {get_end(container_), get_end(container_), window_size_};
   }
 };
 
diff --git a/sorted.hpp b/sorted.hpp
index 4caf35e0..d5fdf050 100644
--- a/sorted.hpp
+++ b/sorted.hpp
@@ -32,13 +32,13 @@ class iter::impl::SortedView {
       : container_(std::forward<Container>(container)) {
     // Fill the sorted_iters_ vector with an iterator to each
     // element in the container_
-    for (auto iter = std::begin(container_); iter != std::end(container_);
+    for (auto iter = get_begin(container_); iter != get_end(container_);
          ++iter) {
       sorted_iters_.get().push_back(iter);
     }
 
     // sort by comparing the elements that the iterators point to
-    std::sort(std::begin(sorted_iters_.get()), std::end(sorted_iters_.get()),
+    std::sort(get_begin(sorted_iters_.get()), get_end(sorted_iters_.get()),
         [compare_func](iterator_type<Container> it1,
             iterator_type<Container> it2) { return compare_func(*it1, *it2); });
   }
@@ -47,11 +47,11 @@ class iter::impl::SortedView {
   SortedView(SortedView&&) = default;
 
   ItIt begin() {
-    return std::begin(sorted_iters_);
+    return get_begin(sorted_iters_);
   }
 
   ItIt end() {
-    return std::end(sorted_iters_);
+    return get_end(sorted_iters_);
   }
 };
 
diff --git a/starmap.hpp b/starmap.hpp
index 84cb2da9..3748f244 100644
--- a/starmap.hpp
+++ b/starmap.hpp
@@ -82,11 +82,11 @@ class iter::impl::StarMapper {
   };
 
   Iterator begin() {
-    return {func_, std::begin(container_)};
+    return {func_, get_begin(container_)};
   }
 
   Iterator end() {
-    return {func_, std::end(container_)};
+    return {func_, get_end(container_)};
   }
 };
 
@@ -185,8 +185,8 @@ struct iter::impl::StarMapFn : PipeableAndBindFirst<StarMapFn> {
   template <typename Func, typename TupType>
   auto helper(Func func, TupType&& tup, std::true_type) const {
     return helper_with_tuples(std::move(func), std::forward<TupType>(tup),
-        std::make_index_sequence<std::tuple_size<std::decay_t<TupType>>::
-                value>{});
+        std::make_index_sequence<
+            std::tuple_size<std::decay_t<TupType>>::value>{});
   }
 
   // handles everything else
diff --git a/takewhile.hpp b/takewhile.hpp
index e180acd1..af3eeeb9 100644
--- a/takewhile.hpp
+++ b/takewhile.hpp
@@ -97,11 +97,11 @@ class iter::impl::Taker {
   };
 
   Iterator begin() {
-    return {std::begin(container_), std::end(container_), filter_func_};
+    return {get_begin(container_), get_end(container_), filter_func_};
   }
 
   Iterator end() {
-    return {std::end(container_), std::end(container_), filter_func_};
+    return {get_end(container_), get_end(container_), filter_func_};
   }
 };
 
diff --git a/unique_justseen.hpp b/unique_justseen.hpp
index c7fd2462..5e5e3170 100644
--- a/unique_justseen.hpp
+++ b/unique_justseen.hpp
@@ -15,7 +15,7 @@ namespace iter {
         // explicit return type in lambda so reference types are preserved
         return imap(
             [](auto&& group) -> impl::iterator_deref<Container> {
-              return *std::begin(group.second);
+              return *get_begin(group.second);
             },
             groupby(std::forward<Container>(container)));
       }
diff --git a/zip.hpp b/zip.hpp
index 89182fe6..c5142cc4 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -60,7 +60,7 @@ class iter::impl::Zipped {
       bool results[] = {
           true, (std::get<Is>(iters_) != std::get<Is>(other.iters_))...};
       return std::all_of(
-          std::begin(results), std::end(results), [](bool b) { return b; });
+          get_begin(results), get_end(results), [](bool b) { return b; });
     }
 
     bool operator==(const Iterator& other) const {
@@ -78,12 +78,12 @@ class iter::impl::Zipped {
 
   Iterator begin() {
     return {iterator_tuple_type<TupleType>{
-        std::begin(std::get<Is>(containers_))...}};
+        get_begin(std::get<Is>(containers_))...}};
   }
 
   Iterator end() {
     return {
-        iterator_tuple_type<TupleType>{std::end(std::get<Is>(containers_))...}};
+        iterator_tuple_type<TupleType>{get_end(std::get<Is>(containers_))...}};
   }
 };
 
diff --git a/zip_longest.hpp b/zip_longest.hpp
index b72aa5c7..00c15cbd 100644
--- a/zip_longest.hpp
+++ b/zip_longest.hpp
@@ -71,7 +71,7 @@ class iter::impl::ZippedLongest {
       bool results[] = {
           false, (std::get<Is>(iters_) != std::get<Is>(other.iters_))...};
       return std::any_of(
-          std::begin(results), std::end(results), [](bool b) { return b; });
+          get_begin(results), get_end(results), [](bool b) { return b; });
     }
 
     bool operator==(const Iterator& other) const {
@@ -90,15 +90,15 @@ class iter::impl::ZippedLongest {
   };
 
   Iterator begin() {
-    return {iterator_tuple_type<TupleType>{
-                std::begin(std::get<Is>(containers_))...},
-        iterator_tuple_type<TupleType>{std::end(std::get<Is>(containers_))...}};
+    return {
+        iterator_tuple_type<TupleType>{get_begin(std::get<Is>(containers_))...},
+        iterator_tuple_type<TupleType>{get_end(std::get<Is>(containers_))...}};
   }
 
   Iterator end() {
     return {
-        iterator_tuple_type<TupleType>{std::end(std::get<Is>(containers_))...},
-        iterator_tuple_type<TupleType>{std::end(std::get<Is>(containers_))...}};
+        iterator_tuple_type<TupleType>{get_end(std::get<Is>(containers_))...},
+        iterator_tuple_type<TupleType>{get_end(std::get<Is>(containers_))...}};
   }
 };
 

From 635d8d09507bd89faea725adfb85b7ff70606bd2 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 25 Feb 2017 17:34:02 -0800
Subject: [PATCH 1566/1866] Replaces iter::impl::void_t with std::void_t

---
 internal/iteratoriterator.hpp |  6 +++---
 internal/iterbase.hpp         | 13 +++----------
 starmap.hpp                   |  2 +-
 test/helpers.hpp              |  6 +++---
 4 files changed, 10 insertions(+), 17 deletions(-)

diff --git a/internal/iteratoriterator.hpp b/internal/iteratoriterator.hpp
index 23bde9d5..e29d740a 100644
--- a/internal/iteratoriterator.hpp
+++ b/internal/iteratoriterator.hpp
@@ -19,7 +19,7 @@ namespace iter {
     struct HasConstDeref : std::false_type {};
 
     template <typename T>
-    struct HasConstDeref<T, void_t<decltype(*std::declval<const T&>())>>
+    struct HasConstDeref<T, std::void_t<decltype(*std::declval<const T&>())>>
         : std::true_type {};
 
     template <typename TopIter>
@@ -156,7 +156,7 @@ namespace iter {
 
       template <typename U>
       struct ConstAtTypeOrVoid<U,
-          void_t<decltype(*std::declval<const U&>().at(0))>>
+          std::void_t<decltype(*std::declval<const U&>().at(0))>>
           : type_is<decltype(*std::declval<const U&>().at(0))> {};
 
       using const_at_type_or_void_t = typename ConstAtTypeOrVoid<>::type;
@@ -166,7 +166,7 @@ namespace iter {
 
       template <typename U>
       struct ConstIndexTypeOrVoid<U,
-          void_t<decltype(*std::declval<const U&>()[0])>>
+          std::void_t<decltype(*std::declval<const U&>()[0])>>
           : type_is<decltype(*std::declval<const U&>()[0])> {};
 
       using const_index_type_or_void_t = typename ConstIndexTypeOrVoid<>::type;
diff --git a/internal/iterbase.hpp b/internal/iterbase.hpp
index 9970610c..7e133c3a 100644
--- a/internal/iterbase.hpp
+++ b/internal/iterbase.hpp
@@ -47,14 +47,6 @@ namespace iter {
       using type = T;
     };
 
-    // gcc CWG 1558
-    template <typename...>
-    struct void_t_help {
-      using type = void;
-    };
-    template <typename... Ts>
-    using void_t = typename void_t_help<Ts...>::type;
-
     // iterator_type<C> is the type of C's iterator
     template <typename Container>
     using iterator_type = decltype(get_begin(std::declval<Container&>()));
@@ -80,7 +72,7 @@ namespace iter {
 
     // Assuming that if a type works with begin, it is an iterable.
     template <typename T>
-    struct IsIterable<T, void_t<iterator_type<T>>> : std::true_type {};
+    struct IsIterable<T, std::void_t<iterator_type<T>>> : std::true_type {};
 
     template <typename T>
     constexpr bool is_iterable = IsIterable<T>::value;
@@ -101,7 +93,8 @@ namespace iter {
       };
 
       template <typename T>
-      struct ArrowHelper<T, void_t<decltype(std::declval<T&>().operator->())>> {
+      struct ArrowHelper<T,
+          std::void_t<decltype(std::declval<T&>().operator->())>> {
         using type = decltype(std::declval<T&>().operator->());
         type operator()(T& t) const {
           return t.operator->();
diff --git a/starmap.hpp b/starmap.hpp
index 3748f244..1f259437 100644
--- a/starmap.hpp
+++ b/starmap.hpp
@@ -201,7 +201,7 @@ struct iter::impl::StarMapFn : PipeableAndBindFirst<StarMapFn> {
 
   template <typename T>
   struct is_tuple_like<T,
-      void_t<decltype(std::tuple_size<std::decay_t<T>>::value)>>
+      std::void_t<decltype(std::tuple_size<std::decay_t<T>>::value)>>
       : public std::true_type {};
 
  public:
diff --git a/test/helpers.hpp b/test/helpers.hpp
index 1ab8adfe..cc2180b2 100644
--- a/test/helpers.hpp
+++ b/test/helpers.hpp
@@ -166,20 +166,18 @@ namespace itertest {
       return {b.data + b.size};
     }
 
-
 #ifdef DECLARE_REVERSE_ITERATOR
     Iterator rbegin();
     Iterator rend();
 #endif  // ifdef DECLARE_REVERSE_ITERATOR
   };
-  using iter::impl::void_t;
 
   template <typename, typename = void>
   struct IsIterator : std::false_type {};
 
   template <typename T>
   struct IsIterator<T,
-      void_t<decltype(T(std::declval<const T&>())),                 // copyctor
+      std::void_t<decltype(T(std::declval<const T&>())),            // copyctor
           decltype(std::declval<T&>() = std::declval<const T&>()),  // copy =
           decltype(*std::declval<T&>()),                            // operator*
           decltype(std::declval<T&>().operator->()),  // operator->
@@ -223,6 +221,7 @@ class DiffEndRange {
 
   class Iterator {
     using SubIter = typename std::vector<T>::iterator;
+
    private:
     SubIter it_;
     SubIter end_;
@@ -260,6 +259,7 @@ class DiffEndRange {
 
   class ReverseIterator {
     using SubIter = typename std::vector<T>::reverse_iterator;
+
    private:
     SubIter it_;
     SubIter end_;

From b49e4822050ac4d088c8731fa33432aa14bdb08e Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 8 Apr 2017 10:20:22 -0700
Subject: [PATCH 1567/1866] Moves IterYield out of Enumerable class

Preparing for structured bindings.
---
 enumerate.hpp | 27 +++++++++++++++------------
 1 file changed, 15 insertions(+), 12 deletions(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index 25fbceb6..36738121 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -9,9 +9,23 @@
 #include <iterator>
 #include <type_traits>
 #include <utility>
+#include <tuple>
 
 namespace iter {
   namespace impl {
+    template <typename Index, typename Elem>
+    using EnumBasePair = std::pair<Index, Elem>;
+
+    // "yielded" by the Enumerable::Iterator.  Has a .index, and a
+    // .element referencing the value yielded by the subiterator
+    template <typename Index, typename Elem>
+    class EnumIterYield : public EnumBasePair<Index, Elem> {
+      using BasePair =  EnumBasePair<Index, Elem>;
+      using BasePair::BasePair;
+      typename BasePair::first_type& index = BasePair::first;
+      typename BasePair::second_type& element = BasePair::second;
+    };
+
     template <typename Container, typename Index>
     class Enumerable;
 
@@ -28,9 +42,6 @@ class iter::impl::Enumerable {
 
   friend EnumerateFn;
 
-  // for IterYield
-  using BasePair = std::pair<Index, iterator_deref<Container>>;
-
   // Value constructor for use only in the enumerate function
   Enumerable(Container&& container, Index start)
       : container_(std::forward<Container>(container)), start_{start} {}
@@ -38,14 +49,7 @@ class iter::impl::Enumerable {
  public:
   Enumerable(Enumerable&&) = default;
 
-  // "yielded" by the Enumerable::Iterator.  Has a .index, and a
-  // .element referencing the value yielded by the subiterator
-  class IterYield : public BasePair {
-   public:
-    using BasePair::BasePair;
-    typename BasePair::first_type& index = BasePair::first;
-    typename BasePair::second_type& element = BasePair::second;
-  };
+  using IterYield = EnumIterYield<Index, iterator_deref<Container>>;
 
   //  Holds an iterator of the contained type and an Index for the
   //  index_.  Each call to ++ increments both of these data members.
@@ -96,5 +100,4 @@ class iter::impl::Enumerable {
     return {get_end(container_), start_};
   }
 };
-
 #endif

From 34717e6920fa43714907dba2d66c054c526fb343 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 8 Apr 2017 10:29:26 -0700
Subject: [PATCH 1568/1866] Tests enumerate IterYield has tuple_size

---
 test/test_enumerate.cpp | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/test/test_enumerate.cpp b/test/test_enumerate.cpp
index 33666dc6..e854c081 100644
--- a/test/test_enumerate.cpp
+++ b/test/test_enumerate.cpp
@@ -48,6 +48,13 @@ TEST_CASE("Postfix ++ enumerate", "[enumerate]") {
   REQUIRE((*it).first == 1);
 }
 
+TEST_CASE("enumerate: structured bindings", "[enumerate]") {
+  std::string s{"amz"};
+  auto e = enumerate(s);
+  auto it = std::begin(e);
+  REQUIRE(std::tuple_size<std::decay_t<decltype(*it)>>{} == 2);
+}
+
 TEST_CASE("enumerate: with starting value", "[enumerate]") {
   std::string str = "hey";
   auto e = enumerate(str, 5u);

From 1defa207c3fc337da5717b4eb59ed1f850f75856 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 8 Apr 2017 10:33:13 -0700
Subject: [PATCH 1569/1866] Supports tuple_size for IterYield

---
 enumerate.hpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/enumerate.hpp b/enumerate.hpp
index 36738121..5e76703e 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -34,6 +34,12 @@ namespace iter {
   constexpr impl::EnumerateFn enumerate{};
 }
 
+namespace std {
+  template <typename Container, typename Index>
+  class tuple_size<iter::impl::EnumIterYield<Index, Container>>
+    : public tuple_size<iter::impl::EnumBasePair<Index, Container>> { };
+}
+
 template <typename Container, typename Index>
 class iter::impl::Enumerable {
  private:

From 3e612405b8023fd7ebc65dfd6a1317c1f84b10d0 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 8 Apr 2017 11:02:44 -0700
Subject: [PATCH 1570/1866] Tests structured bindings with enumerate()

---
 test/test_enumerate.cpp | 18 ++++++++++++++----
 1 file changed, 14 insertions(+), 4 deletions(-)

diff --git a/test/test_enumerate.cpp b/test/test_enumerate.cpp
index e854c081..e70f168c 100644
--- a/test/test_enumerate.cpp
+++ b/test/test_enumerate.cpp
@@ -49,10 +49,20 @@ TEST_CASE("Postfix ++ enumerate", "[enumerate]") {
 }
 
 TEST_CASE("enumerate: structured bindings", "[enumerate]") {
-  std::string s{"amz"};
-  auto e = enumerate(s);
-  auto it = std::begin(e);
-  REQUIRE(std::tuple_size<std::decay_t<decltype(*it)>>{} == 2);
+  {
+    std::string s{"amz"};
+    auto e = enumerate(s);
+    auto it = std::begin(e);
+    REQUIRE(std::tuple_size<std::decay_t<decltype(*it)>>{} == 2);
+    REQUIRE(std::get<0>(*it) == it->first);
+  }
+
+  Vec v;
+  for (auto && [ i, c ] : enumerate(std::string{"xyz"})) {
+    v.emplace_back(i, c);
+  }
+  const Vec vc{{0, 'x'}, {1, 'y'}, {2, 'z'}};
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("enumerate: with starting value", "[enumerate]") {

From 3ef2107c26709214821f086e44b9c91fa4506ef4 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 8 Apr 2017 11:04:44 -0700
Subject: [PATCH 1571/1866] Supports structured bindings in enumerate.

It turns out I didn't need to implement get<>, having tuple_element and
tuple_size is enough. get<> for std::pair is actually called and we're
all set!
---
 enumerate.hpp | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index 5e76703e..22c7e33b 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -7,9 +7,9 @@
 #include <functional>
 #include <initializer_list>
 #include <iterator>
+#include <tuple>
 #include <type_traits>
 #include <utility>
-#include <tuple>
 
 namespace iter {
   namespace impl {
@@ -20,7 +20,7 @@ namespace iter {
     // .element referencing the value yielded by the subiterator
     template <typename Index, typename Elem>
     class EnumIterYield : public EnumBasePair<Index, Elem> {
-      using BasePair =  EnumBasePair<Index, Elem>;
+      using BasePair = EnumBasePair<Index, Elem>;
       using BasePair::BasePair;
       typename BasePair::first_type& index = BasePair::first;
       typename BasePair::second_type& element = BasePair::second;
@@ -35,9 +35,13 @@ namespace iter {
 }
 
 namespace std {
-  template <typename Container, typename Index>
-  class tuple_size<iter::impl::EnumIterYield<Index, Container>>
-    : public tuple_size<iter::impl::EnumBasePair<Index, Container>> { };
+  template <typename Index, typename Elem>
+  class tuple_size<iter::impl::EnumIterYield<Index, Elem>>
+      : public tuple_size<iter::impl::EnumBasePair<Index, Elem>> {};
+
+  template <std::size_t N, typename Index, typename Elem>
+  class tuple_element<N, iter::impl::EnumIterYield<Index, Elem>>
+      : public tuple_element<N, iter::impl::EnumBasePair<Index, Elem>> {};
 }
 
 template <typename Container, typename Index>

From 321cdb53af3aea33e21113f43bf4cc5aff4441ff Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 8 Apr 2017 10:29:26 -0700
Subject: [PATCH 1572/1866] Tests enumerate IterYield has tuple_size

---
 test/test_enumerate.cpp | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/test/test_enumerate.cpp b/test/test_enumerate.cpp
index 33666dc6..e854c081 100644
--- a/test/test_enumerate.cpp
+++ b/test/test_enumerate.cpp
@@ -48,6 +48,13 @@ TEST_CASE("Postfix ++ enumerate", "[enumerate]") {
   REQUIRE((*it).first == 1);
 }
 
+TEST_CASE("enumerate: structured bindings", "[enumerate]") {
+  std::string s{"amz"};
+  auto e = enumerate(s);
+  auto it = std::begin(e);
+  REQUIRE(std::tuple_size<std::decay_t<decltype(*it)>>{} == 2);
+}
+
 TEST_CASE("enumerate: with starting value", "[enumerate]") {
   std::string str = "hey";
   auto e = enumerate(str, 5u);

From 33b68783988efdb306678185c68f2ce53f71b464 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 8 Apr 2017 10:20:22 -0700
Subject: [PATCH 1573/1866] Moves IterYield out of Enumerable class

Preparing for structured bindings.
---
 enumerate.hpp | 27 +++++++++++++++------------
 1 file changed, 15 insertions(+), 12 deletions(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index 25fbceb6..36738121 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -9,9 +9,23 @@
 #include <iterator>
 #include <type_traits>
 #include <utility>
+#include <tuple>
 
 namespace iter {
   namespace impl {
+    template <typename Index, typename Elem>
+    using EnumBasePair = std::pair<Index, Elem>;
+
+    // "yielded" by the Enumerable::Iterator.  Has a .index, and a
+    // .element referencing the value yielded by the subiterator
+    template <typename Index, typename Elem>
+    class EnumIterYield : public EnumBasePair<Index, Elem> {
+      using BasePair =  EnumBasePair<Index, Elem>;
+      using BasePair::BasePair;
+      typename BasePair::first_type& index = BasePair::first;
+      typename BasePair::second_type& element = BasePair::second;
+    };
+
     template <typename Container, typename Index>
     class Enumerable;
 
@@ -28,9 +42,6 @@ class iter::impl::Enumerable {
 
   friend EnumerateFn;
 
-  // for IterYield
-  using BasePair = std::pair<Index, iterator_deref<Container>>;
-
   // Value constructor for use only in the enumerate function
   Enumerable(Container&& container, Index start)
       : container_(std::forward<Container>(container)), start_{start} {}
@@ -38,14 +49,7 @@ class iter::impl::Enumerable {
  public:
   Enumerable(Enumerable&&) = default;
 
-  // "yielded" by the Enumerable::Iterator.  Has a .index, and a
-  // .element referencing the value yielded by the subiterator
-  class IterYield : public BasePair {
-   public:
-    using BasePair::BasePair;
-    typename BasePair::first_type& index = BasePair::first;
-    typename BasePair::second_type& element = BasePair::second;
-  };
+  using IterYield = EnumIterYield<Index, iterator_deref<Container>>;
 
   //  Holds an iterator of the contained type and an Index for the
   //  index_.  Each call to ++ increments both of these data members.
@@ -96,5 +100,4 @@ class iter::impl::Enumerable {
     return {get_end(container_), start_};
   }
 };
-
 #endif

From f049edd585cdd38e04f53daa9f09029ecd863830 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 8 Apr 2017 10:33:13 -0700
Subject: [PATCH 1574/1866] Supports tuple_size for IterYield

---
 enumerate.hpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/enumerate.hpp b/enumerate.hpp
index 36738121..5e76703e 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -34,6 +34,12 @@ namespace iter {
   constexpr impl::EnumerateFn enumerate{};
 }
 
+namespace std {
+  template <typename Container, typename Index>
+  class tuple_size<iter::impl::EnumIterYield<Index, Container>>
+    : public tuple_size<iter::impl::EnumBasePair<Index, Container>> { };
+}
+
 template <typename Container, typename Index>
 class iter::impl::Enumerable {
  private:

From df4c68628cfb9d623484fbded6c9b19b71e6ba77 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 8 Apr 2017 11:04:44 -0700
Subject: [PATCH 1575/1866] Supports structured bindings in enumerate.

It turns out I didn't need to implement get<>, having tuple_element and
tuple_size is enough. get<> for std::pair is actually called and we're
all set!
---
 enumerate.hpp | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index 5e76703e..22c7e33b 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -7,9 +7,9 @@
 #include <functional>
 #include <initializer_list>
 #include <iterator>
+#include <tuple>
 #include <type_traits>
 #include <utility>
-#include <tuple>
 
 namespace iter {
   namespace impl {
@@ -20,7 +20,7 @@ namespace iter {
     // .element referencing the value yielded by the subiterator
     template <typename Index, typename Elem>
     class EnumIterYield : public EnumBasePair<Index, Elem> {
-      using BasePair =  EnumBasePair<Index, Elem>;
+      using BasePair = EnumBasePair<Index, Elem>;
       using BasePair::BasePair;
       typename BasePair::first_type& index = BasePair::first;
       typename BasePair::second_type& element = BasePair::second;
@@ -35,9 +35,13 @@ namespace iter {
 }
 
 namespace std {
-  template <typename Container, typename Index>
-  class tuple_size<iter::impl::EnumIterYield<Index, Container>>
-    : public tuple_size<iter::impl::EnumBasePair<Index, Container>> { };
+  template <typename Index, typename Elem>
+  class tuple_size<iter::impl::EnumIterYield<Index, Elem>>
+      : public tuple_size<iter::impl::EnumBasePair<Index, Elem>> {};
+
+  template <std::size_t N, typename Index, typename Elem>
+  class tuple_element<N, iter::impl::EnumIterYield<Index, Elem>>
+      : public tuple_element<N, iter::impl::EnumBasePair<Index, Elem>> {};
 }
 
 template <typename Container, typename Index>

From 686a1e16204ab4de65d761f275d15260417b4b2e Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Sun, 23 Apr 2017 06:47:53 -0700
Subject: [PATCH 1576/1866] tests enumerate index and element

---
 test/test_enumerate.cpp | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/test/test_enumerate.cpp b/test/test_enumerate.cpp
index e854c081..a56f07d1 100644
--- a/test/test_enumerate.cpp
+++ b/test/test_enumerate.cpp
@@ -116,6 +116,21 @@ TEST_CASE("enumerate: operator->", "[enumerate]") {
   REQUIRE(it->second == 50);
 }
 
+TEST_CASE("enumerate: index and element", "[enumerate]") {
+  std::string s{"ace"};
+  auto e = enumerate(s);
+  auto it = std::begin(e);
+  REQUIRE((*it).index == 0);
+  REQUIRE((*it).element == 'a');
+
+  Vec v;
+  for (auto&& p : enumerate(s)) {
+    v.emplace_back(p.index, p.element);
+  }
+  Vec vc{{0, 'a'}, {1, 'c'}, {2, 'e'}};
+  REQUIRE(v == vc);
+}
+
 TEST_CASE("Works with const iterable", "[enumerate]") {
   const std::string s{"ace"};
   auto e = enumerate(s);

From 278500cf77bca7d76ca7b4f014c3adef746a00cb Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Sun, 23 Apr 2017 06:48:07 -0700
Subject: [PATCH 1577/1866] Fixes EnumIterYield, index & element were private

---
 enumerate.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/enumerate.hpp b/enumerate.hpp
index 22c7e33b..0780facb 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -22,6 +22,7 @@ namespace iter {
     class EnumIterYield : public EnumBasePair<Index, Elem> {
       using BasePair = EnumBasePair<Index, Elem>;
       using BasePair::BasePair;
+     public:
       typename BasePair::first_type& index = BasePair::first;
       typename BasePair::second_type& element = BasePair::second;
     };

From 6d98d621716281cf83f2d5448017c6b399702803 Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Sun, 23 Apr 2017 08:12:26 -0700
Subject: [PATCH 1578/1866] Tests enum ->index

---
 test/test_enumerate.cpp | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/test/test_enumerate.cpp b/test/test_enumerate.cpp
index a56f07d1..5633e00c 100644
--- a/test/test_enumerate.cpp
+++ b/test/test_enumerate.cpp
@@ -131,6 +131,25 @@ TEST_CASE("enumerate: index and element", "[enumerate]") {
   REQUIRE(v == vc);
 }
 
+TEST_CASE("enumerate: index and element through arrow", "[enumerate]") {
+  std::string s{"ace"};
+  auto e = enumerate(s);
+  SECTION("One inspection") {
+    auto it = std::begin(e);
+    REQUIRE(it->index == 0);
+    REQUIRE(it->element == 'a');
+  }
+
+  SECTION("full loop") {
+    Vec v;
+    for (auto it = std::begin(e), end_it = std::end(e); it != end_it; ++it) {
+      v.emplace_back(it->index, it->element);
+    }
+    Vec vc{{0, 'a'}, {1, 'c'}, {2, 'e'}};
+    REQUIRE(v == vc);
+  }
+}
+
 TEST_CASE("Works with const iterable", "[enumerate]") {
   const std::string s{"ace"};
   auto e = enumerate(s);

From 89c6752a7e2832a98277a58e834bbc99fa911cc4 Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Sun, 23 Apr 2017 08:12:43 -0700
Subject: [PATCH 1579/1866] Makes IterYield index not a reference.

There are problems with lifetime extension; binding a reference to
index won't extend the lifetime of the IterYield object (or whatever
it's called now). element isn't an obvious issue because the object it
references should live inside of Enumerable, unless the underlying
iterable's operator* returns a non-reference type in which case we're
kind of screwed.
---
 enumerate.hpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index 0780facb..7e0a8196 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -22,8 +22,9 @@ namespace iter {
     class EnumIterYield : public EnumBasePair<Index, Elem> {
       using BasePair = EnumBasePair<Index, Elem>;
       using BasePair::BasePair;
+
      public:
-      typename BasePair::first_type& index = BasePair::first;
+      typename BasePair::first_type index = BasePair::first;
       typename BasePair::second_type& element = BasePair::second;
     };
 

From 79a233be0750261bad78efcbe6945a1707419e59 Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Sun, 23 Apr 2017 08:17:34 -0700
Subject: [PATCH 1580/1866] Undoes accidental SConstruct changes

---
 examples/SConstruct | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/examples/SConstruct b/examples/SConstruct
index 8a6b6f40..119b2026 100644
--- a/examples/SConstruct
+++ b/examples/SConstruct
@@ -2,16 +2,12 @@ import os
 
 env = Environment(
     ENV=os.environ,
-    CXX='clang++',
     CXXFLAGS= ['-g', '-Wall', '-Wextra',
-               '-stdlib=libc++',
-               '-pedantic', '-std=c++1z',
+               '-pedantic', '-std=c++14',
                '-I/usr/local/include'
     ],
     CPPPATH='..',
-    LINKFLAGS=['-L/usr/local/lib',
-    '-lc++', '-lc++abi',
-    ])
+    LINKFLAGS=['-L/usr/local/lib'])
 
 # allows highighting to print to terminal from compiler output
 env['ENV']['TERM'] = os.environ['TERM']

From 222abfeb3da381038cc02f110255b076e1bd7338 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 9 Jul 2017 19:55:03 -0700
Subject: [PATCH 1581/1866] Supports const iteration on enumerate

---
 enumerate.hpp           | 27 +++++++++++++++++++--------
 internal/iterbase.hpp   | 21 ++++++++++++++++++---
 test/test_enumerate.cpp | 23 +++++++++++++++++++++++
 3 files changed, 60 insertions(+), 11 deletions(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index 22c7e33b..cfedbf79 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -59,25 +59,28 @@ class iter::impl::Enumerable {
  public:
   Enumerable(Enumerable&&) = default;
 
-  using IterYield = EnumIterYield<Index, iterator_deref<Container>>;
+  template <typename T>
+  using IterYield = EnumIterYield<Index, iterator_deref<T>>;
 
   //  Holds an iterator of the contained type and an Index for the
   //  index_.  Each call to ++ increments both of these data members.
   //  Each dereference returns an IterYield.
-  class Iterator : public std::iterator<std::input_iterator_tag, IterYield> {
+  template <typename ContainerT>
+  class Iterator
+      : public std::iterator<std::input_iterator_tag, IterYield<ContainerT>> {
    private:
-    IteratorWrapper<Container> sub_iter_;
+    IteratorWrapper<ContainerT> sub_iter_;
     Index index_;
 
    public:
-    Iterator(IteratorWrapper<Container>&& sub_iter, Index start)
+    Iterator(IteratorWrapper<ContainerT>&& sub_iter, Index start)
         : sub_iter_{std::move(sub_iter)}, index_{start} {}
 
-    IterYield operator*() {
+    IterYield<ContainerT> operator*() {
       return {index_, *sub_iter_};
     }
 
-    ArrowProxy<IterYield> operator->() {
+    ArrowProxy<IterYield<ContainerT>> operator->() {
       return {**this};
     }
 
@@ -102,12 +105,20 @@ class iter::impl::Enumerable {
     }
   };
 
-  Iterator begin() {
+  Iterator<Container> begin() {
     return {get_begin(container_), start_};
   }
 
-  Iterator end() {
+  Iterator<Container> end() {
     return {get_end(container_), start_};
   }
+
+  Iterator<AsConst<Container>> begin() const {
+    return {get_begin(as_const(container_)), start_};
+  }
+
+  Iterator<AsConst<Container>> end() const {
+    return {get_end(as_const(container_)), start_};
+  }
 };
 #endif
diff --git a/internal/iterbase.hpp b/internal/iterbase.hpp
index 9970610c..3ac7409f 100644
--- a/internal/iterbase.hpp
+++ b/internal/iterbase.hpp
@@ -47,6 +47,21 @@ namespace iter {
       using type = T;
     };
 
+    // TODO use std::as_const for c++17
+    template <typename T>
+    const T& as_const(T& t) {
+      return t;
+    }
+    template <typename T>
+    const T& as_const(const T& t) {
+      return t;
+    }
+    template <typename T>
+    void as_const(T&&) = delete;
+
+    template <typename T>
+    using AsConst = decltype(as_const(std::declval<T&>()));
+
     // gcc CWG 1558
     template <typename...>
     struct void_t_help {
@@ -146,9 +161,9 @@ namespace iter {
 
     template <typename T>
     struct is_random_access_iter<T,
-        std::enable_if_t<
-            std::is_same<typename std::iterator_traits<T>::iterator_category,
-                std::random_access_iterator_tag>::value>> : std::true_type {};
+        std::enable_if_t<std::is_same<
+            typename std::iterator_traits<T>::iterator_category,
+            std::random_access_iterator_tag>::value>> : std::true_type {};
 
     template <typename T>
     using has_random_access_iter = is_random_access_iter<iterator_type<T>>;
diff --git a/test/test_enumerate.cpp b/test/test_enumerate.cpp
index e854c081..bf5a7a7d 100644
--- a/test/test_enumerate.cpp
+++ b/test/test_enumerate.cpp
@@ -34,6 +34,29 @@ TEST_CASE("Basic Functioning enumerate", "[enumerate]") {
   REQUIRE(v == vc);
 }
 
+TEST_CASE("const enumerate", "[enumerate][const]") {
+  Vec v;
+  SECTION("lvalue") {
+    std::string str = "abc";
+    const auto e = enumerate(str);
+    v.assign(std::begin(e), std::end(e));
+  }
+  SECTION("rvalue") {
+    const auto e = enumerate(std::string("abc"));
+    v.assign(std::begin(e), std::end(e));
+  }
+  SECTION("const lvalue") {
+    const std::string str = "abc";
+    const auto e = enumerate(str);
+    v.assign(std::begin(e), std::end(e));
+  }
+
+
+  Vec vc{{0, 'a'}, {1, 'b'}, {2, 'c'}};
+
+  REQUIRE(v == vc);
+}
+
 TEST_CASE("Empty enumerate", "[enumerate]") {
   std::string emp{};
   auto e = enumerate(emp);

From 92043563da3f3bbe62838526cffca2add1bbf03f Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Fri, 28 Jul 2017 11:21:11 -0700
Subject: [PATCH 1582/1866] Adds product test with repeat argument.

---
 test/test_product.cpp | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/test/test_product.cpp b/test/test_product.cpp
index f5303e4f..d4a2cfbd 100644
--- a/test/test_product.cpp
+++ b/test/test_product.cpp
@@ -58,6 +58,27 @@ TEST_CASE("product: three sequences", "[product]") {
   REQUIRE(v == vc);
 }
 
+TEST_CASE("product: with repeat", "[product]") {
+  using TP = std::tuple<char, char, char>;
+  using ResType = const std::vector<TP>;
+  const std::string s = "hop";
+  auto p = product<3>(s);
+  ResType v(std::begin(p), std::end(p));
+
+  ResType vc = {
+      TP{'h', 'h', 'h'}, TP{'h', 'h', 'o'}, TP{'h', 'h', 'p'},
+      TP{'h', 'o', 'h'}, TP{'h', 'o', 'o'}, TP{'h', 'o', 'p'},
+      TP{'h', 'p', 'h'}, TP{'h', 'p', 'o'}, TP{'h', 'p', 'p'},
+      TP{'o', 'h', 'h'}, TP{'o', 'h', 'o'}, TP{'o', 'h', 'p'},
+      TP{'o', 'o', 'h'}, TP{'o', 'o', 'o'}, TP{'o', 'o', 'p'},
+      TP{'o', 'p', 'h'}, TP{'o', 'p', 'o'}, TP{'o', 'p', 'p'},
+      TP{'p', 'h', 'h'}, TP{'p', 'h', 'o'}, TP{'p', 'h', 'p'},
+      TP{'p', 'o', 'h'}, TP{'p', 'o', 'o'}, TP{'p', 'o', 'p'},
+      TP{'p', 'p', 'h'}, TP{'p', 'p', 'o'}, TP{'p', 'p', 'p'},
+  };
+  REQUIRE(v == vc);
+}
+
 TEST_CASE("product: empty when any iterable is empty", "[product]") {
   Vec n1 = {0, 1};
   Vec n2 = {0, 1, 2};

From c1462d1452943dde2185eee75a01d0a3f2617eb6 Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Fri, 28 Jul 2017 11:21:28 -0700
Subject: [PATCH 1583/1866] Adds repeat arg to product

---
 product.hpp | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/product.hpp b/product.hpp
index db9d31f7..6a8c9bbe 100644
--- a/product.hpp
+++ b/product.hpp
@@ -164,6 +164,32 @@ iter::impl::Productor<Containers...> iter::product(Containers&&... containers) {
 }
 
 namespace iter {
+  namespace impl {
+    // rvalue must be copied, lvalue and const lvalue references can be bound
+    template <std::size_t... Is, typename Container>
+    decltype(auto) product_repeat(
+        std::index_sequence<Is...>, Container&& container) {
+      return product(((void)Is, Container(container))...);
+    }
+
+    template <std::size_t... Is, typename Container>
+    decltype(auto) product_repeat(
+        std::index_sequence<Is...>, Container& container) {
+      return product(((void)Is, container)...);
+    }
+
+    template <std::size_t... Is, typename Container>
+    decltype(auto) product_repeat(
+        std::index_sequence<Is...>, const Container& container) {
+      return product(((void)Is, container)...);
+    }
+  }
+  template <std::size_t N, typename Container>
+  decltype(auto) product(Container&& container) {
+    return impl::product_repeat(
+        std::make_index_sequence<N>{}, std::forward<Container>(container));
+  }
+
   constexpr std::array<std::tuple<>, 1> product() {
     return {{}};
   }

From 9818303b210a88f17df2b7d545afc944ab7886cd Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Fri, 28 Jul 2017 12:02:29 -0700
Subject: [PATCH 1584/1866] Some harder testing on the inputs to product<N>

---
 test/helpers.hpp      | 50 +++++++++++++++++++++++++++----------------
 test/test_product.cpp | 25 ++++++++++++++++++++++
 2 files changed, 56 insertions(+), 19 deletions(-)

diff --git a/test/helpers.hpp b/test/helpers.hpp
index 1ab8adfe..76b4c359 100644
--- a/test/helpers.hpp
+++ b/test/helpers.hpp
@@ -87,7 +87,7 @@ namespace itertest {
     T* data;
     std::size_t size;
     bool was_moved_from_ = false;
-    bool was_copied_from_ = false;
+    mutable bool was_copied_from_ = false;
 
    public:
     BasicIterable(std::initializer_list<T> il)
@@ -104,18 +104,17 @@ namespace itertest {
     BasicIterable& operator=(BasicIterable&&) = delete;
     BasicIterable& operator=(const BasicIterable&) = delete;
 
+#ifndef DEFINE_BASIC_ITERABLE_COPY_CTOR
     BasicIterable(const BasicIterable&) = delete;
-#if 0
-        BasicIterable(const BasicIterable& other)
-            : data{new T[other.size()]},
-            size{other.size}
-        { 
-            for (auto it = this->begin(), o_it = other.begin();
-                    o_it != other.end();
-                    ++it, ++o_it) {
-                *it = *o_it;
-            }
-        }
+#else
+    BasicIterable(const BasicIterable& other)
+        : data{new T[other.size]}, size{other.size} {
+      other.was_copied_from_ = true;
+      for (auto it = begin(*this), o_it = begin(other); o_it != end(other);
+           ++it, ++o_it) {
+        *it = *o_it;
+      }
+    }
 #endif
 
     BasicIterable(BasicIterable&& other) : data{other.data}, size{other.size} {
@@ -135,15 +134,16 @@ namespace itertest {
       delete[] this->data;
     }
 
+    template <typename U>
     class Iterator {
      private:
-      T* p;
+      U* p;
 
      public:
 #ifdef DEFINE_DEFAULT_ITERATOR_CTOR
       Iterator() = default;
 #endif
-      Iterator(T* b) : p{b} {}
+      Iterator(U* b) : p{b} {}
       bool operator!=(const Iterator& other) const {
         return this->p != other.p;
       }
@@ -153,25 +153,35 @@ namespace itertest {
         return *this;
       }
 
-      T& operator*() {
+      U& operator*() {
         return *this->p;
       }
     };
 
-    friend BasicIterable::Iterator begin(BasicIterable& b) {
+    friend BasicIterable::Iterator<T> begin(BasicIterable& b) {
       return {b.data};
     }
 
-    friend BasicIterable::Iterator end(BasicIterable& b) {
+    friend BasicIterable::Iterator<T> end(BasicIterable& b) {
       return {b.data + b.size};
     }
 
+#ifdef DEFINE_BASIC_ITERABLE_CONST_BEGIN_AND_END
+    friend BasicIterable::Iterator<const T> begin(const BasicIterable& b) {
+      return {b.data};
+    }
+
+    friend BasicIterable::Iterator<const T> end(const BasicIterable& b) {
+      return {b.data + b.size};
+    }
+#endif
 
 #ifdef DECLARE_REVERSE_ITERATOR
-    Iterator rbegin();
-    Iterator rend();
+    Iterator<T> rbegin();
+    Iterator<T> rend();
 #endif  // ifdef DECLARE_REVERSE_ITERATOR
   };
+
   using iter::impl::void_t;
 
   template <typename, typename = void>
@@ -223,6 +233,7 @@ class DiffEndRange {
 
   class Iterator {
     using SubIter = typename std::vector<T>::iterator;
+
    private:
     SubIter it_;
     SubIter end_;
@@ -260,6 +271,7 @@ class DiffEndRange {
 
   class ReverseIterator {
     using SubIter = typename std::vector<T>::reverse_iterator;
+
    private:
     SubIter it_;
     SubIter end_;
diff --git a/test/test_product.cpp b/test/test_product.cpp
index d4a2cfbd..5f7e701d 100644
--- a/test/test_product.cpp
+++ b/test/test_product.cpp
@@ -1,6 +1,10 @@
 #include <product.hpp>
 
+#define DEFINE_BASIC_ITERABLE_COPY_CTOR
+#define DEFINE_BASIC_ITERABLE_CONST_BEGIN_AND_END
 #include "helpers.hpp"
+#undef DEFINE_BASIC_ITERABLE_CONST_BEGIN_AND_END
+#undef DEFINE_BASIC_ITERABLE_COPY_CTOR
 
 #include <iterator>
 #include <string>
@@ -128,14 +132,35 @@ TEST_CASE("product: binds to lvalues and moves rvalues", "[product]") {
   SECTION("First ref'd, second moved") {
     product(bi, std::move(bi2));
     REQUIRE_FALSE(bi.was_moved_from());
+    REQUIRE_FALSE(bi.was_copied_from());
     REQUIRE(bi2.was_moved_from());
   }
 
   SECTION("First moved, second ref'd") {
     product(std::move(bi), bi2);
     REQUIRE(bi.was_moved_from());
+    REQUIRE_FALSE(bi2.was_copied_from());
     REQUIRE_FALSE(bi2.was_moved_from());
   }
+
+  SECTION("repeat, lvalue not moved or copied") {
+    product<2>(bi);
+    REQUIRE_FALSE(bi.was_moved_from());
+    REQUIRE_FALSE(bi.was_copied_from());
+  }
+
+  SECTION("repeat, const lvalue not moved or copied") {
+    const auto& r = bi;
+    product<2>(r);
+    REQUIRE_FALSE(bi.was_moved_from());
+    REQUIRE_FALSE(bi.was_copied_from());
+  }
+
+  SECTION("repeat, rvalue copied") {
+    product<2>(std::move(bi));
+    REQUIRE_FALSE(bi.was_moved_from());
+    REQUIRE(bi.was_copied_from());
+  }
 }
 
 TEST_CASE("product: doesn't move or copy elements of iterable", "[product]") {

From d990df92820c3493eb1dbdd92fd23463a7089b6b Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 28 Jul 2017 12:10:06 -0700
Subject: [PATCH 1585/1866] Adds description of product() with repeat

---
 README.md | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/README.md b/README.md
index a740372d..cd2d7c6e 100644
--- a/README.md
+++ b/README.md
@@ -761,6 +761,17 @@ for (auto&& t : product(v1,v2,v3,v4)) {
 }
 ```
 
+Product also accepts a "repeat" as a template argument. Currently this is the only way to do repeats. **If you are reading this and need `product(seq, 3)` instead of `product<3>(seq)` please open an issue**.
+
+Example usage:
+```c++
+std::string s = "abc";
+// equivalent of product(s, s, s);
+for (auto&& t : product<3>(s)) {
+   // ...
+}
+```
+
 combinations
 -----------
 *Additional Requirements*: Input must have a ForwardIterator

From 7fdad8d8b02ef32325dce939b0eb2abc98a39968 Mon Sep 17 00:00:00 2001
From: Mislav Bradac <mislav.bradac@gmail.com>
Date: Thu, 10 Aug 2017 01:08:37 +0200
Subject: [PATCH 1586/1866] Migrate unique_ptr to optional

---
 accumulate.hpp        | 15 ++++++++-------
 chain.hpp             | 44 ++++++++++++++-----------------------------
 groupby.hpp           |  7 ++++---
 internal/iterbase.hpp | 13 +++++--------
 4 files changed, 31 insertions(+), 48 deletions(-)

diff --git a/accumulate.hpp b/accumulate.hpp
index aec33626..75b357ee 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -6,7 +6,7 @@
 
 #include <functional>
 #include <iterator>
-#include <memory>
+#include <optional>
 #include <type_traits>
 #include <utility>
 
@@ -43,7 +43,7 @@ class iter::impl::Accumulator {
     IteratorWrapper<Container> sub_iter_;
     IteratorWrapper<Container> sub_end_;
     AccumulateFunc* accumulate_func_;
-    std::unique_ptr<AccumVal> acc_val_;
+    std::optional<AccumVal> acc_val_;
 
    public:
     Iterator(IteratorWrapper<Container>&& sub_iter,
@@ -52,14 +52,15 @@ class iter::impl::Accumulator {
           sub_end_{std::move(sub_end)},
           accumulate_func_(&accumulate_fun),
           // only get first value if not an end iterator
-          acc_val_{
-              !(sub_iter_ != sub_end_) ? nullptr : new AccumVal(*sub_iter_)} {}
+          acc_val_{!(sub_iter_ != sub_end_)
+                       ? std::nullopt
+                       : std::make_optional<AccumVal>(*sub_iter_)} {}
 
     Iterator(const Iterator& other)
         : sub_iter_{other.sub_iter_},
           sub_end_{other.sub_end_},
           accumulate_func_{other.accumulate_func_},
-          acc_val_{other.acc_val_ ? new AccumVal(*other.acc_val_) : nullptr} {}
+          acc_val_{other.acc_val_} {}
 
     Iterator& operator=(const Iterator& other) {
       if (this == &other) {
@@ -68,7 +69,7 @@ class iter::impl::Accumulator {
       sub_iter_ = other.sub_iter_;
       sub_end_ = other.sub_end_;
       accumulate_func_ = other.accumulate_func_;
-      acc_val_.reset(other.acc_val_ ? new AccumVal(*other.acc_val_) : nullptr);
+      acc_val_ = other.acc_val_;
       return *this;
     }
 
@@ -80,7 +81,7 @@ class iter::impl::Accumulator {
     }
 
     const AccumVal* operator->() const {
-      return acc_val_.get();
+      return acc_val_.operator->();
     }
 
     Iterator& operator++() {
diff --git a/chain.hpp b/chain.hpp
index 90f553e1..c122e509 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -7,7 +7,7 @@
 
 #include <array>
 #include <iterator>
-#include <memory>
+#include <optional>
 #include <tuple>
 #include <type_traits>
 #include <utility>
@@ -192,24 +192,8 @@ class iter::impl::ChainedFromIterable {
 
     IteratorWrapper<Container> top_level_iter_;
     IteratorWrapper<Container> top_level_end_;
-    std::unique_ptr<SubIter> sub_iter_p_;
-    std::unique_ptr<SubIter> sub_end_p_;
-
-    static std::unique_ptr<SubIter> clone_sub_pointer(const SubIter* sub_iter) {
-      return sub_iter ? std::make_unique<SubIter>(*sub_iter) : nullptr;
-    }
-
-    bool sub_iters_differ(const Iterator& other) const {
-      if (sub_iter_p_ == other.sub_iter_p_) {
-        return false;
-      }
-      if (sub_iter_p_ == nullptr || other.sub_iter_p_ == nullptr) {
-        // since the first check tests if they're the same,
-        // this will return if only one is nullptr
-        return true;
-      }
-      return *sub_iter_p_ != *other.sub_iter_p_;
-    }
+    std::optional<SubIter> sub_iter_p_;
+    std::optional<SubIter> sub_end_p_;
 
    public:
     Iterator(IteratorWrapper<Container>&& top_iter,
@@ -218,18 +202,18 @@ class iter::impl::ChainedFromIterable {
           top_level_end_{std::move(top_end)},
           sub_iter_p_{!(top_iter != top_end)
                           ?  // iter == end ?
-                          nullptr
-                          : std::make_unique<SubIter>(get_begin(*top_iter))},
+                          std::nullopt
+                          : std::make_optional<SubIter>(get_begin(*top_iter))},
           sub_end_p_{!(top_iter != top_end)
                          ?  // iter == end ?
-                         nullptr
-                         : std::make_unique<SubIter>(get_end(*top_iter))} {}
+                         std::nullopt
+                         : std::make_optional<SubIter>(get_end(*top_iter))} {}
 
     Iterator(const Iterator& other)
         : top_level_iter_{other.top_level_iter_},
           top_level_end_{other.top_level_end_},
-          sub_iter_p_{clone_sub_pointer(other.sub_iter_p_.get())},
-          sub_end_p_{clone_sub_pointer(other.sub_end_p_.get())} {}
+          sub_iter_p_{other.sub_iter_p_},
+          sub_end_p_{other.sub_end_p_} {}
 
     Iterator& operator=(const Iterator& other) {
       if (this == &other) {
@@ -238,8 +222,8 @@ class iter::impl::ChainedFromIterable {
 
       top_level_iter_ = other.top_level_iter_;
       top_level_end_ = other.top_level_end_;
-      sub_iter_p_ = clone_sub_pointer(other.sub_iter_p_.get());
-      sub_end_p_ = clone_sub_pointer(other.sub_end_p_.get());
+      sub_iter_p_ = other.sub_iter_p_;
+      sub_end_p_ = other.sub_end_p_;
 
       return *this;
     }
@@ -253,8 +237,8 @@ class iter::impl::ChainedFromIterable {
       if (!(*sub_iter_p_ != *sub_end_p_)) {
         ++top_level_iter_;
         if (top_level_iter_ != top_level_end_) {
-          sub_iter_p_ = std::make_unique<SubIter>(get_begin(*top_level_iter_));
-          sub_end_p_ = std::make_unique<SubIter>(get_end(*top_level_iter_));
+          sub_iter_p_ = get_begin(*top_level_iter_);
+          sub_end_p_ = get_end(*top_level_iter_);
         } else {
           sub_iter_p_.reset();
           sub_end_p_.reset();
@@ -271,7 +255,7 @@ class iter::impl::ChainedFromIterable {
 
     bool operator!=(const Iterator& other) const {
       return top_level_iter_ != other.top_level_iter_
-             || sub_iters_differ(other);
+             || sub_iter_p_ != other.sub_iter_p_;
     }
 
     bool operator==(const Iterator& other) const {
diff --git a/groupby.hpp b/groupby.hpp
index 1a06e60f..68c5e515 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -8,6 +8,7 @@
 
 #include <iterator>
 #include <memory>
+#include <optional>
 #include <type_traits>
 #include <utility>
 
@@ -58,7 +59,7 @@ class iter::impl::GroupProducer {
     IteratorWrapper<Container> sub_end_;
     Holder item_;
     KeyFunc* key_func_;
-    std::unique_ptr<KeyGroupPair> current_key_group_pair_;
+    std::optional<KeyGroupPair> current_key_group_pair_;
 
    public:
     Iterator(IteratorWrapper<Container>&& sub_iter,
@@ -101,7 +102,7 @@ class iter::impl::GroupProducer {
 
     KeyGroupPair* operator->() {
       set_key_group_pair();
-      return current_key_group_pair_.get();
+      return current_key_group_pair_.operator->();
     }
 
     Iterator& operator++() {
@@ -153,7 +154,7 @@ class iter::impl::GroupProducer {
 
     void set_key_group_pair() {
       if (!current_key_group_pair_) {
-        current_key_group_pair_ = std::make_unique<KeyGroupPair>(
+        current_key_group_pair_.emplace(
             (*key_func_)(item_.get()), Group{*this, next_key()});
       }
     }
diff --git a/internal/iterbase.hpp b/internal/iterbase.hpp
index 7e133c3a..db9d9183 100644
--- a/internal/iterbase.hpp
+++ b/internal/iterbase.hpp
@@ -10,7 +10,7 @@
 #include <cstddef>
 #include <functional>
 #include <iterator>
-#include <memory>
+#include <optional>
 #include <tuple>
 #include <type_traits>
 #include <utility>
@@ -225,7 +225,7 @@ namespace iter {
       // it could still be an rvalue reference
       using TPlain = std::remove_reference_t<T>;
 
-      std::unique_ptr<TPlain> item_p;
+      std::optional<TPlain> item_p;
 
      public:
       using reference = TPlain&;
@@ -233,13 +233,10 @@ namespace iter {
 
       DerefHolder() = default;
 
-      DerefHolder(const DerefHolder& other)
-          : item_p{other.item_p ? std::make_unique<TPlain>(*other.item_p)
-                                : nullptr} {}
+      DerefHolder(const DerefHolder& other) : item_p{other.item_p} {}
 
       DerefHolder& operator=(const DerefHolder& other) {
-        this->item_p =
-            other.item_p ? std::make_unique<TPlain>(*other.item_p) : nullptr;
+        this->item_p = other.item_p;
         return *this;
       }
 
@@ -256,7 +253,7 @@ namespace iter {
       }
 
       void reset(T&& item) {
-        item_p = std::make_unique<TPlain>(std::move(item));
+        item_p = std::move(item);
       }
 
       explicit operator bool() const {

From ed73f31eee07075478e07444d0fd9ecf8a43d439 Mon Sep 17 00:00:00 2001
From: Mislav Bradac <mislav.bradac@gmail.com>
Date: Thu, 10 Aug 2017 02:50:27 +0200
Subject: [PATCH 1587/1866] Make copy operators default

---
 accumulate.hpp | 19 ++-----------------
 chain.hpp      | 21 ++-------------------
 2 files changed, 4 insertions(+), 36 deletions(-)

diff --git a/accumulate.hpp b/accumulate.hpp
index 75b357ee..a8e20a8f 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -56,23 +56,8 @@ class iter::impl::Accumulator {
                        ? std::nullopt
                        : std::make_optional<AccumVal>(*sub_iter_)} {}
 
-    Iterator(const Iterator& other)
-        : sub_iter_{other.sub_iter_},
-          sub_end_{other.sub_end_},
-          accumulate_func_{other.accumulate_func_},
-          acc_val_{other.acc_val_} {}
-
-    Iterator& operator=(const Iterator& other) {
-      if (this == &other) {
-        return *this;
-      }
-      sub_iter_ = other.sub_iter_;
-      sub_end_ = other.sub_end_;
-      accumulate_func_ = other.accumulate_func_;
-      acc_val_ = other.acc_val_;
-      return *this;
-    }
-
+    Iterator(const Iterator& other) = default;
+    Iterator& operator=(const Iterator& other) = default;
     Iterator(Iterator&&) = default;
     Iterator& operator=(Iterator&&) = default;
 
diff --git a/chain.hpp b/chain.hpp
index c122e509..d73a9d13 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -209,25 +209,8 @@ class iter::impl::ChainedFromIterable {
                          std::nullopt
                          : std::make_optional<SubIter>(get_end(*top_iter))} {}
 
-    Iterator(const Iterator& other)
-        : top_level_iter_{other.top_level_iter_},
-          top_level_end_{other.top_level_end_},
-          sub_iter_p_{other.sub_iter_p_},
-          sub_end_p_{other.sub_end_p_} {}
-
-    Iterator& operator=(const Iterator& other) {
-      if (this == &other) {
-        return *this;
-      }
-
-      top_level_iter_ = other.top_level_iter_;
-      top_level_end_ = other.top_level_end_;
-      sub_iter_p_ = other.sub_iter_p_;
-      sub_end_p_ = other.sub_end_p_;
-
-      return *this;
-    }
-
+    Iterator(const Iterator& other) = default;
+    Iterator& operator=(const Iterator& other) = default;
     Iterator(Iterator&&) = default;
     Iterator& operator=(Iterator&&) = default;
     ~Iterator() = default;

From 206216ac0c26a5357f2b7144c36fab59c9dbf7df Mon Sep 17 00:00:00 2001
From: Mislav Bradac <mislav.bradac@memgraph.io>
Date: Thu, 10 Aug 2017 17:13:43 +0200
Subject: [PATCH 1588/1866] Change operator-> to &*, default copy functions

---
 accumulate.hpp        | 2 +-
 groupby.hpp           | 2 +-
 internal/iterbase.hpp | 9 ++-------
 3 files changed, 4 insertions(+), 9 deletions(-)

diff --git a/accumulate.hpp b/accumulate.hpp
index a8e20a8f..c7c3a6c2 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -66,7 +66,7 @@ class iter::impl::Accumulator {
     }
 
     const AccumVal* operator->() const {
-      return acc_val_.operator->();
+      return &*acc_val_;
     }
 
     Iterator& operator++() {
diff --git a/groupby.hpp b/groupby.hpp
index 68c5e515..9642c734 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -102,7 +102,7 @@ class iter::impl::GroupProducer {
 
     KeyGroupPair* operator->() {
       set_key_group_pair();
-      return current_key_group_pair_.operator->();
+      return &*current_key_group_pair_;
     }
 
     Iterator& operator++() {
diff --git a/internal/iterbase.hpp b/internal/iterbase.hpp
index db9d9183..deb01cf0 100644
--- a/internal/iterbase.hpp
+++ b/internal/iterbase.hpp
@@ -233,13 +233,8 @@ namespace iter {
 
       DerefHolder() = default;
 
-      DerefHolder(const DerefHolder& other) : item_p{other.item_p} {}
-
-      DerefHolder& operator=(const DerefHolder& other) {
-        this->item_p = other.item_p;
-        return *this;
-      }
-
+      DerefHolder(const DerefHolder& other) = default;
+      DerefHolder& operator=(const DerefHolder& other) = default;
       DerefHolder(DerefHolder&&) = default;
       DerefHolder& operator=(DerefHolder&&) = default;
       ~DerefHolder() = default;

From 42c2dd6e470bd2b8dfc8e01b49eb42ef83369f3b Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 10 Aug 2017 11:13:16 -0500
Subject: [PATCH 1589/1866] Fixes unused variable warning in test_accumulate

---
 test/test_accumulate.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/test_accumulate.cpp b/test/test_accumulate.cpp
index 7ba3ba22..0eb7c360 100644
--- a/test/test_accumulate.cpp
+++ b/test/test_accumulate.cpp
@@ -57,7 +57,7 @@ TEST_CASE("accumulate: intermidate type need not be default constructible",
     "[accumulate]") {
   std::vector<Integer> v = {{2}, {3}, {10}};
   auto a = accumulate(v, std::plus<Integer>{});
-  auto it = std::begin(a);
+  std::begin(a);
 }
 
 TEST_CASE("accumulate: binds reference when it should", "[accumulate]") {

From 09c3bbe8d2bc010df40de37000df181e62a8b460 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 10 Aug 2017 11:15:03 -0500
Subject: [PATCH 1590/1866] Removes unnecessary declarations in DerefHolder

---
 internal/iterbase.hpp | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/internal/iterbase.hpp b/internal/iterbase.hpp
index deb01cf0..ed63c786 100644
--- a/internal/iterbase.hpp
+++ b/internal/iterbase.hpp
@@ -233,12 +233,6 @@ namespace iter {
 
       DerefHolder() = default;
 
-      DerefHolder(const DerefHolder& other) = default;
-      DerefHolder& operator=(const DerefHolder& other) = default;
-      DerefHolder(DerefHolder&&) = default;
-      DerefHolder& operator=(DerefHolder&&) = default;
-      ~DerefHolder() = default;
-
       reference get() {
         return *this->item_p;
       }

From eaef737da1bf8cb5bf1034ccf4c3f3b7a5090a57 Mon Sep 17 00:00:00 2001
From: Mislav Bradac <mislav.bradac@memgraph.io>
Date: Fri, 11 Aug 2017 12:18:49 +0200
Subject: [PATCH 1591/1866] Make index and element public in enumerate

---
 enumerate.hpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/enumerate.hpp b/enumerate.hpp
index 22c7e33b..f1a18bbe 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -22,6 +22,8 @@ namespace iter {
     class EnumIterYield : public EnumBasePair<Index, Elem> {
       using BasePair = EnumBasePair<Index, Elem>;
       using BasePair::BasePair;
+
+     public:
       typename BasePair::first_type& index = BasePair::first;
       typename BasePair::second_type& element = BasePair::second;
     };

From f48355e819ffec8cca0798f91443916e91b9c656 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 11 Aug 2017 07:20:40 -0500
Subject: [PATCH 1592/1866] Tests that enumerate .index and .element.

---
 test/test_enumerate.cpp | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/test/test_enumerate.cpp b/test/test_enumerate.cpp
index 5633e00c..39afd090 100644
--- a/test/test_enumerate.cpp
+++ b/test/test_enumerate.cpp
@@ -34,6 +34,14 @@ TEST_CASE("Basic Functioning enumerate", "[enumerate]") {
   REQUIRE(v == vc);
 }
 
+TEST_CASE("enumerate: has .index, .element, .first, and .second") {
+  std::string s = "abc";
+  auto e = enumerate(s);
+  auto it = std::begin(e);
+  REQUIRE(it->index == it->first);
+  REQUIRE(&it->element == &it->second);
+}
+
 TEST_CASE("Empty enumerate", "[enumerate]") {
   std::string emp{};
   auto e = enumerate(emp);

From 67b2101ae8f0f246f90986273f804181798cc4c8 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 11 Aug 2017 07:26:21 -0500
Subject: [PATCH 1593/1866] Switches to c++1z

---
 examples/SConstruct | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/SConstruct b/examples/SConstruct
index 119b2026..c1ed4d10 100644
--- a/examples/SConstruct
+++ b/examples/SConstruct
@@ -3,7 +3,7 @@ import os
 env = Environment(
     ENV=os.environ,
     CXXFLAGS= ['-g', '-Wall', '-Wextra',
-               '-pedantic', '-std=c++14',
+               '-pedantic', '-std=c++1z',
                '-I/usr/local/include'
     ],
     CPPPATH='..',

From e26e338e60e62ae00f851dd2a918626dae03c224 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 11 Aug 2017 07:26:40 -0500
Subject: [PATCH 1594/1866] Uses structured bindings for enumerate

---
 examples/enumerate_examples.cpp | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/examples/enumerate_examples.cpp b/examples/enumerate_examples.cpp
index 39786696..899c3b39 100644
--- a/examples/enumerate_examples.cpp
+++ b/examples/enumerate_examples.cpp
@@ -9,16 +9,16 @@
 int main() {
     std::cout << "enumerating the characters of a string \"hello\":\n";
     const std::string const_string("hello");
-    for (auto&& e : iter::enumerate(const_string)) {
-        std::cout << '(' << e.index << ", " << e.element << ") ";
+    for (auto&& [i, c] : iter::enumerate(const_string)) {
+        std::cout << '(' << i << ", " << c << ") ";
     }
     std::cout << '\n';
 
     std::vector<int> vec = {20, 30, 50};
     std::cout << "enumerating a vector of {20, 30, 50}:\n";
-    for (auto&& e : iter::enumerate(vec)) { 
-        std::cout << '(' << e.index << ", " << e.element << ") ";
-        e.element = 0;
+    for (auto&& [i, n] : iter::enumerate(vec)) { 
+        std::cout << '(' << i << ", " << n << ") ";
+        n = 0;
     }
     std::cout << '\n';
     assert(vec[0] == 0);
@@ -28,15 +28,15 @@ int main() {
     // itertools supports raw arrays
     std::cout << "statically sized arrays can be enumerated\n";
     int array[] = {1, 9, 8, 11};
-    for (auto&& e : iter::enumerate(array)) {
-        std::cout << '(' << e.index << ", " << e.element << ") ";
+    for (auto&& [i, n]  : iter::enumerate(array)) {
+        std::cout << '(' << i << ", " << n << ") ";
     }
     std::cout << '\n';
 
     // itertools supports temporaries
     std::cout << "vector temporary of {5, 2}\n";
-    for (auto&& e : iter::enumerate(std::vector<int>(5,2))) {
-        std::cout << '(' << e.index << ", " << e.element << ") ";
+    for (auto&& [i, n] : iter::enumerate(std::vector<int>(5,2))) {
+        std::cout << '(' << i << ", " << n << ") ";
     }
     std::cout << '\n';
 }

From b4369bd4faada70af0a03b253337f155d4284b23 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 11 Aug 2017 07:39:21 -0500
Subject: [PATCH 1595/1866] removes unnecessary declarations of copy/=

---
 accumulate.hpp | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/accumulate.hpp b/accumulate.hpp
index c7c3a6c2..02fd9a6d 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -56,11 +56,6 @@ class iter::impl::Accumulator {
                        ? std::nullopt
                        : std::make_optional<AccumVal>(*sub_iter_)} {}
 
-    Iterator(const Iterator& other) = default;
-    Iterator& operator=(const Iterator& other) = default;
-    Iterator(Iterator&&) = default;
-    Iterator& operator=(Iterator&&) = default;
-
     const AccumVal& operator*() const {
       return *acc_val_;
     }

From 28a2eb61533410a435b240c5bf1443233ba6593e Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 11 Aug 2017 07:41:18 -0500
Subject: [PATCH 1596/1866] removes unnecessary declarations of copy/=

---
 chain.hpp | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/chain.hpp b/chain.hpp
index d73a9d13..f6b247ea 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -209,12 +209,6 @@ class iter::impl::ChainedFromIterable {
                          std::nullopt
                          : std::make_optional<SubIter>(get_end(*top_iter))} {}
 
-    Iterator(const Iterator& other) = default;
-    Iterator& operator=(const Iterator& other) = default;
-    Iterator(Iterator&&) = default;
-    Iterator& operator=(Iterator&&) = default;
-    ~Iterator() = default;
-
     Iterator& operator++() {
       ++*sub_iter_p_;
       if (!(*sub_iter_p_ != *sub_end_p_)) {

From f2f85a6fa3212d89ac4d2698a45d12352b708e58 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fr=C3=A9d=C3=A9ric=20Dubouchet?= <angel@calodox.org>
Date: Mon, 28 Aug 2017 16:34:01 +0200
Subject: [PATCH 1597/1866] Typo

You probably wanted to say product and not project.
---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index cd2d7c6e..0d138f3d 100644
--- a/README.md
+++ b/README.md
@@ -745,7 +745,7 @@ product
 ------
 *Additional Requirements*: Input must have a ForwardIterator
 
-Generates the cartesian project of the given ranges put together
+Generates the cartesian product of the given ranges put together.
 
 Example usage:
 ```c++

From 5a16b0db6165a6e63f90b954f5cd8ac43abce16c Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Wed, 4 Oct 2017 10:20:23 -0500
Subject: [PATCH 1598/1866] Tests comparison of const and non-const iterators

---
 test/test_enumerate.cpp | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/test/test_enumerate.cpp b/test/test_enumerate.cpp
index bf5a7a7d..75272c2f 100644
--- a/test/test_enumerate.cpp
+++ b/test/test_enumerate.cpp
@@ -51,12 +51,17 @@ TEST_CASE("const enumerate", "[enumerate][const]") {
     v.assign(std::begin(e), std::end(e));
   }
 
-
   Vec vc{{0, 'a'}, {1, 'b'}, {2, 'c'}};
 
   REQUIRE(v == vc);
 }
 
+TEST_CASE("enumerate: const iterators can be compared", "[enumerate][const]") {
+  auto e = enumerate(std::string("hello"));
+  const auto& ce = e;
+  std::begin(e) == std::end(ce);
+}
+
 TEST_CASE("Empty enumerate", "[enumerate]") {
   std::string emp{};
   auto e = enumerate(emp);

From 764310bd561cfa28710cf67b34c492a7dd18dcf8 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Wed, 4 Oct 2017 10:33:17 -0500
Subject: [PATCH 1599/1866] Allows comparison of const and non-const iterators

---
 enumerate.hpp | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index cfedbf79..23cfe3cd 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -69,6 +69,8 @@ class iter::impl::Enumerable {
   class Iterator
       : public std::iterator<std::input_iterator_tag, IterYield<ContainerT>> {
    private:
+    template <typename>
+    friend class Iterator;
     IteratorWrapper<ContainerT> sub_iter_;
     Index index_;
 
@@ -96,11 +98,13 @@ class iter::impl::Enumerable {
       return ret;
     }
 
-    bool operator!=(const Iterator& other) const {
+    template <typename T>
+    bool operator!=(const Iterator<T>& other) const {
       return sub_iter_ != other.sub_iter_;
     }
 
-    bool operator==(const Iterator& other) const {
+    template <typename T>
+    bool operator==(const Iterator<T>& other) const {
       return !(*this != other);
     }
   };

From 238673886c294055ef180022a2c2170f907e7e16 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Wed, 4 Oct 2017 10:39:45 -0500
Subject: [PATCH 1600/1866] tests accumulate for const iterators

---
 test/test_accumulate.cpp | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/test/test_accumulate.cpp b/test/test_accumulate.cpp
index 7ba3ba22..4774dece 100644
--- a/test/test_accumulate.cpp
+++ b/test/test_accumulate.cpp
@@ -45,6 +45,32 @@ TEST_CASE("accumulate: With subtraction lambda", "[accumulate]") {
   REQUIRE(v == vc);
 }
 
+TEST_CASE("accumulate: const iterators", "[accumulate][const]") {
+  std::vector<int> v;
+  SECTION("lvalue") {
+    Vec ns{1, 2, 3, 4, 5};
+    const auto a = accumulate(ns);
+    v.assign(std::begin(a), std::end(a));
+  }
+  SECTION("rvalue") {
+    const auto a = accumulate(Vec{1, 2, 3, 4, 5});
+    v.assign(std::begin(a), std::end(a));
+  }
+  SECTION("const lvalue") {
+    const Vec ns{1, 2, 3, 4, 5};
+    const auto a = accumulate(ns);
+    v.assign(std::begin(a), std::end(a));
+  }
+  Vec vc{1, 3, 6, 10, 15};
+  REQUIRE(v == vc);
+}
+
+TEST_CASE("accumulate: const iterators can be compared", "[accumulate][const]") {
+  auto e = accumulate(std::string("hello"));
+  const auto& ce = e;
+  std::begin(e) == std::end(ce);
+}
+
 struct Integer {
   const int value;
   constexpr Integer(int i) : value{i} {}

From e73892f1dbcd963d3125e0ad90e6d9cb80a34e73 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Wed, 4 Oct 2017 10:39:58 -0500
Subject: [PATCH 1601/1866] Adds support for const iteration to accumulate

---
 accumulate.hpp | 32 +++++++++++++++++++++++---------
 1 file changed, 23 insertions(+), 9 deletions(-)

diff --git a/accumulate.hpp b/accumulate.hpp
index aec33626..d533a8d7 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -24,7 +24,7 @@ template <typename Container, typename AccumulateFunc>
 class iter::impl::Accumulator {
  private:
   Container container_;
-  AccumulateFunc accumulate_func_;
+  mutable AccumulateFunc accumulate_func_;
 
   friend AccumulateFn;
 
@@ -38,16 +38,19 @@ class iter::impl::Accumulator {
  public:
   Accumulator(Accumulator&&) = default;
 
+  template <typename ContainerT>
   class Iterator : public std::iterator<std::input_iterator_tag, AccumVal> {
    private:
-    IteratorWrapper<Container> sub_iter_;
-    IteratorWrapper<Container> sub_end_;
+    template <typename>
+    friend class Iterator;
+    IteratorWrapper<ContainerT> sub_iter_;
+    IteratorWrapper<ContainerT> sub_end_;
     AccumulateFunc* accumulate_func_;
     std::unique_ptr<AccumVal> acc_val_;
 
    public:
-    Iterator(IteratorWrapper<Container>&& sub_iter,
-        IteratorWrapper<Container>&& sub_end, AccumulateFunc& accumulate_fun)
+    Iterator(IteratorWrapper<ContainerT>&& sub_iter,
+        IteratorWrapper<ContainerT>&& sub_end, AccumulateFunc& accumulate_fun)
         : sub_iter_{std::move(sub_iter)},
           sub_end_{std::move(sub_end)},
           accumulate_func_(&accumulate_fun),
@@ -97,22 +100,33 @@ class iter::impl::Accumulator {
       return ret;
     }
 
-    bool operator!=(const Iterator& other) const {
+    template <typename T>
+    bool operator!=(const Iterator<T>& other) const {
       return sub_iter_ != other.sub_iter_;
     }
 
-    bool operator==(const Iterator& other) const {
+    template <typename T>
+    bool operator==(const Iterator<T>& other) const {
       return !(*this != other);
     }
   };
 
-  Iterator begin() {
+  Iterator<Container> begin() {
     return {get_begin(container_), get_end(container_), accumulate_func_};
   }
 
-  Iterator end() {
+  Iterator<Container> end() {
     return {get_end(container_), get_end(container_), accumulate_func_};
   }
+  Iterator<AsConst<Container>> begin() const {
+    return {get_begin(as_const(container_)), get_end(as_const(container_)),
+        accumulate_func_};
+  }
+
+  Iterator<AsConst<Container>> end() const {
+    return {get_end(as_const(container_)), get_end(as_const(container_)),
+        accumulate_func_};
+  }
 };
 
 #endif

From 829213e1fa0c280e9103b76e6aaea73cc291ec33 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Wed, 4 Oct 2017 11:06:14 -0500
Subject: [PATCH 1602/1866] Tests chunked with const iterators

---
 test/test_chunked.cpp | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/test/test_chunked.cpp b/test/test_chunked.cpp
index 533bec05..f8c12f69 100644
--- a/test/test_chunked.cpp
+++ b/test/test_chunked.cpp
@@ -31,6 +31,27 @@ TEST_CASE("chunked: basic test", "[chunked]") {
   REQUIRE(results == rc);
 }
 
+TEST_CASE("chunked: const chunked", "[chunked][const]") {
+  Vec ns = {1, 2, 3, 4, 5, 6};
+  ResVec results;
+  SECTION("Normal call") {
+    const auto& ch = chunked(ns, 2);
+    for (auto&& g : ch) {
+      results.emplace_back(std::begin(g), std::end(g));
+    }
+  }
+  ResVec rc = {{1, 2}, {3, 4}, {5, 6}};
+
+  REQUIRE(results == rc);
+}
+
+TEST_CASE("chunked: const iterators can be compared to non-const iterators",
+    "[chunked][const]") {
+  auto c = chunked(Vec{}, 1);
+  const auto& cc = c;
+  std::begin(c) == std::end(cc);
+}
+
 TEST_CASE("chunked: len(iterable) % groupsize != 0", "[chunked]") {
   Vec ns = {1, 2, 3, 4, 5, 6, 7};
   ResVec results;

From bd12264e5e3fa5ecd5b9939a8490e77ff737d27a Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Wed, 4 Oct 2017 11:16:45 -0500
Subject: [PATCH 1603/1866] Adds support for const iteration in chunked

---
 chunked.hpp | 46 ++++++++++++++++++++++++++++++++--------------
 1 file changed, 32 insertions(+), 14 deletions(-)

diff --git a/chunked.hpp b/chunked.hpp
index 90f578ca..bf152a3f 100644
--- a/chunked.hpp
+++ b/chunked.hpp
@@ -33,16 +33,22 @@ class iter::impl::Chunker {
 
   friend ChunkedFn;
 
-  using IndexVector = std::vector<IteratorWrapper<Container>>;
-  using DerefVec = IterIterWrapper<IndexVector>;
+  template <typename T>
+  using IndexVector = std::vector<IteratorWrapper<T>>;
+  template <typename T>
+  using DerefVec = IterIterWrapper<IndexVector<T>>;
 
  public:
   Chunker(Chunker&&) = default;
-  class Iterator : public std::iterator<std::input_iterator_tag, DerefVec> {
+  template <typename ContainerT>
+  class Iterator
+      : public std::iterator<std::input_iterator_tag, DerefVec<ContainerT>> {
    private:
-    IteratorWrapper<Container> sub_iter_;
-    IteratorWrapper<Container> sub_end_;
-    DerefVec chunk_;
+    template <typename>
+    friend class Iterator;
+    IteratorWrapper<ContainerT> sub_iter_;
+    IteratorWrapper<ContainerT> sub_end_;
+    DerefVec<ContainerT> chunk_;
     std::size_t chunk_size_ = 0;
 
     bool done() const {
@@ -60,8 +66,8 @@ class iter::impl::Chunker {
     }
 
    public:
-    Iterator(IteratorWrapper<Container>&& sub_iter,
-        IteratorWrapper<Container>&& sub_end, std::size_t s)
+    Iterator(IteratorWrapper<ContainerT>&& sub_iter,
+        IteratorWrapper<ContainerT>&& sub_end, std::size_t s)
         : sub_iter_{std::move(sub_iter)},
           sub_end_{std::move(sub_end)},
           chunk_size_{s} {
@@ -80,31 +86,43 @@ class iter::impl::Chunker {
       return ret;
     }
 
-    bool operator!=(const Iterator& other) const {
+    template <typename T>
+    bool operator!=(const Iterator<T>& other) const {
       return !(*this == other);
     }
 
-    bool operator==(const Iterator& other) const {
+    template <typename T>
+    bool operator==(const Iterator<T>& other) const {
       return done() == other.done()
              && (done() || !(sub_iter_ != other.sub_iter_));
     }
 
-    DerefVec& operator*() {
+    DerefVec<ContainerT>& operator*() {
       return chunk_;
     }
 
-    DerefVec* operator->() {
+    DerefVec<ContainerT>* operator->() {
       return &chunk_;
     }
   };
 
-  Iterator begin() {
+  Iterator<Container> begin() {
     return {get_begin(container_), get_end(container_), chunk_size_};
   }
 
-  Iterator end() {
+  Iterator<Container> end() {
     return {get_end(container_), get_end(container_), chunk_size_};
   }
+
+  Iterator<AsConst<Container>> begin() const {
+    return {get_begin(as_const(container_)), get_end(as_const(container_)),
+        chunk_size_};
+  }
+
+  Iterator<AsConst<Container>> end() const {
+    return {get_end(as_const(container_)), get_end(as_const(container_)),
+        chunk_size_};
+  }
 };
 
 #endif

From 2bbb2ac0464f1994070d453530d2f72da656dd57 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Wed, 4 Oct 2017 11:40:40 -0500
Subject: [PATCH 1604/1866] Tests const iterators for filter

---
 test/test_filter.cpp | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/test/test_filter.cpp b/test/test_filter.cpp
index bb29ee90..f6950eb7 100644
--- a/test/test_filter.cpp
+++ b/test/test_filter.cpp
@@ -53,6 +53,21 @@ TEST_CASE("filter: handles different callable types", "[filter]") {
   }
 }
 
+TEST_CASE("filter: const iteration", "[filter][const]") {
+  Vec ns = {1, 2, 5, 6, 3, 1, 7, -1, 5};
+  const auto f = filter(LessThanValue{5}, ns);
+  Vec v(std::begin(f), std::end(f));
+  Vec vc = {1, 2, 3, 1, -1};
+  REQUIRE(v == vc);
+}
+
+TEST_CASE("filter: const iterator can be compared to non-const iterator",
+    "[filter][const]") {
+  auto f = filter(LessThanValue{5}, Vec{});
+  const auto& cf = f;
+  std::begin(f) == std::end(cf);
+}
+
 TEST_CASE("filter: iterator with lambda can be assigned", "[filter]") {
   Vec ns{};
   auto ltf = [](int i) { return i < 5; };

From 033a10575a59d0b37954c60f461331a03e967266 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Wed, 4 Oct 2017 11:47:56 -0500
Subject: [PATCH 1605/1866] Adds support for const iteration to filter

---
 filter.hpp | 37 ++++++++++++++++++++++++++-----------
 1 file changed, 26 insertions(+), 11 deletions(-)

diff --git a/filter.hpp b/filter.hpp
index aa0de753..4b450b14 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -30,7 +30,7 @@ template <typename FilterFunc, typename Container>
 class iter::impl::Filtered {
  private:
   Container container_;
-  FilterFunc filter_func_;
+  mutable FilterFunc filter_func_;
 
   friend FilterFn;
 
@@ -43,12 +43,15 @@ class iter::impl::Filtered {
  public:
   Filtered(Filtered&&) = default;
 
+  template <typename ContainerT>
   class Iterator : public std::iterator<std::input_iterator_tag,
-                       iterator_traits_deref<Container>> {
+                       iterator_traits_deref<ContainerT>> {
    protected:
-    using Holder = DerefHolder<iterator_deref<Container>>;
-    IteratorWrapper<Container> sub_iter_;
-    IteratorWrapper<Container> sub_end_;
+    template <typename>
+    friend class Iterator;
+    using Holder = DerefHolder<iterator_deref<ContainerT>>;
+    IteratorWrapper<ContainerT> sub_iter_;
+    IteratorWrapper<ContainerT> sub_end_;
     Holder item_;
     FilterFunc* filter_func_;
 
@@ -68,8 +71,8 @@ class iter::impl::Filtered {
     }
 
    public:
-    Iterator(IteratorWrapper<Container>&& sub_iter,
-        IteratorWrapper<Container>&& sub_end, FilterFunc& filter_func)
+    Iterator(IteratorWrapper<ContainerT>&& sub_iter,
+        IteratorWrapper<ContainerT>&& sub_end, FilterFunc& filter_func)
         : sub_iter_{std::move(sub_iter)},
           sub_end_{std::move(sub_end)},
           filter_func_(&filter_func) {
@@ -99,22 +102,34 @@ class iter::impl::Filtered {
       return ret;
     }
 
-    bool operator!=(const Iterator& other) const {
+    template <typename T>
+    bool operator!=(const Iterator<T>& other) const {
       return sub_iter_ != other.sub_iter_;
     }
 
-    bool operator==(const Iterator& other) const {
+    template <typename T>
+    bool operator==(const Iterator<T>& other) const {
       return !(*this != other);
     }
   };
 
-  Iterator begin() {
+  Iterator<Container> begin() {
     return {get_begin(container_), get_end(container_), filter_func_};
   }
 
-  Iterator end() {
+  Iterator<Container> end() {
     return {get_end(container_), get_end(container_), filter_func_};
   }
+
+  Iterator<AsConst<Container>> begin() const {
+    return {get_begin(as_const(container_)), get_end(as_const(container_)),
+        filter_func_};
+  }
+
+  Iterator<AsConst<Container>> end() const {
+    return {get_end(as_const(container_)), get_end(as_const(container_)),
+        filter_func_};
+  }
 };
 
 #endif

From 0cd7b66129c2111369efcbf603251f7bae63fd0f Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Wed, 4 Oct 2017 12:18:28 -0500
Subject: [PATCH 1606/1866] Tests const iteration in filterfalse

---
 test/test_filterfalse.cpp | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/test/test_filterfalse.cpp b/test/test_filterfalse.cpp
index 07726cf8..a2fc14b9 100644
--- a/test/test_filterfalse.cpp
+++ b/test/test_filterfalse.cpp
@@ -60,6 +60,21 @@ TEST_CASE("filterfalse: handles different callable types", "[filterfalse]") {
   }
 }
 
+TEST_CASE("filterfalse: const iteration", "[filterfalse][const]") {
+  Vec ns = {1, 2, 5, 6, 3, 1, 7, -1, 5};
+  const auto f = filterfalse(LessThanValue{5}, ns);
+  Vec v(std::begin(f), std::end(f));
+  Vec vc = {5, 6, 7, 5};
+  REQUIRE(v == vc);
+}
+
+TEST_CASE("filterfalse: const iterator and non-const iterator can be compared",
+    "[filterfalse][const]") {
+  auto f = filterfalse(LessThanValue{5}, Vec{});
+  const auto& cf = f;
+  std::begin(f) == std::end(cf);
+}
+
 TEST_CASE(
     "filterfalse: Works with different begin and end types", "[filterfalse]") {
   CharRange cr{'d'};

From 72b32bbb44d59956370b9e0f1d6babd9a447ffdf Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Wed, 4 Oct 2017 12:42:45 -0500
Subject: [PATCH 1607/1866] Tests dropwhile with const iteration

---
 test/test_dropwhile.cpp | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/test/test_dropwhile.cpp b/test/test_dropwhile.cpp
index 49b4e49a..5802c7a6 100644
--- a/test/test_dropwhile.cpp
+++ b/test/test_dropwhile.cpp
@@ -12,6 +12,20 @@ using iter::dropwhile;
 
 using Vec = const std::vector<int>;
 
+namespace {
+  class LessThanValue {
+   private:
+    int compare_val;
+
+   public:
+    LessThanValue(int v) : compare_val(v) {}
+
+    bool operator()(int i) {
+      return i < this->compare_val;
+    }
+  };
+}
+
 TEST_CASE("dropwhile: skips initial elements", "[dropwhile]") {
   Vec ns{1, 2, 3, 4, 5, 6, 7, 8};
   std::vector<int> v;
@@ -27,6 +41,21 @@ TEST_CASE("dropwhile: skips initial elements", "[dropwhile]") {
   REQUIRE(v == vc);
 }
 
+TEST_CASE("dropwhile: const iteration", "[dropwhile][const]") {
+  Vec ns{1, 2, 3, 4, 5, 6, 7, 8};
+  const auto d = dropwhile(LessThanValue{5}, ns);
+  Vec v(std::begin(d), std::end(d));
+  Vec vc = {5, 6, 7, 8};
+  REQUIRE(v == vc);
+}
+
+TEST_CASE("dropwhile: const iterators can be compared to non-const iterators",
+    "[dropwhile][const]") {
+  auto d = dropwhile(LessThanValue{5}, Vec{});
+  const auto& cd = d;
+  std::begin(d) == std::end(cd);
+}
+
 TEST_CASE(
     "dropwhile: Works with different begin and end types", "[dropwhile]") {
   CharRange cr{'f'};

From eb242b364b1c69b866409ae2497df0467f6da1bf Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Wed, 4 Oct 2017 12:45:40 -0500
Subject: [PATCH 1608/1866] Adds support for const iteration in dropwhile

---
 dropwhile.hpp | 37 ++++++++++++++++++++++++++-----------
 1 file changed, 26 insertions(+), 11 deletions(-)

diff --git a/dropwhile.hpp b/dropwhile.hpp
index 6e781baf..1c9c5737 100644
--- a/dropwhile.hpp
+++ b/dropwhile.hpp
@@ -22,7 +22,7 @@ template <typename FilterFunc, typename Container>
 class iter::impl::Dropper {
  private:
   Container container_;
-  FilterFunc filter_func_;
+  mutable FilterFunc filter_func_;
 
   friend DropWhileFn;
 
@@ -32,12 +32,15 @@ class iter::impl::Dropper {
 
  public:
   Dropper(Dropper&&) = default;
+  template <typename ContainerT>
   class Iterator : public std::iterator<std::input_iterator_tag,
-                       iterator_traits_deref<Container>> {
+                       iterator_traits_deref<ContainerT>> {
    private:
-    using Holder = DerefHolder<iterator_deref<Container>>;
-    IteratorWrapper<Container> sub_iter_;
-    IteratorWrapper<Container> sub_end_;
+    template <typename>
+    friend class Iterator;
+    using Holder = DerefHolder<iterator_deref<ContainerT>>;
+    IteratorWrapper<ContainerT> sub_iter_;
+    IteratorWrapper<ContainerT> sub_end_;
     Holder item_;
     FilterFunc* filter_func_;
 
@@ -56,8 +59,8 @@ class iter::impl::Dropper {
     }
 
    public:
-    Iterator(IteratorWrapper<Container>&& sub_iter,
-        IteratorWrapper<Container>&& sub_end, FilterFunc& filter_func)
+    Iterator(IteratorWrapper<ContainerT>&& sub_iter,
+        IteratorWrapper<ContainerT>&& sub_end, FilterFunc& filter_func)
         : sub_iter_{std::move(sub_iter)},
           sub_end_{std::move(sub_end)},
           filter_func_(&filter_func) {
@@ -86,22 +89,34 @@ class iter::impl::Dropper {
       return ret;
     }
 
-    bool operator!=(const Iterator& other) const {
+    template <typename T>
+    bool operator!=(const Iterator<T>& other) const {
       return sub_iter_ != other.sub_iter_;
     }
 
-    bool operator==(const Iterator& other) const {
+    template <typename T>
+    bool operator==(const Iterator<T>& other) const {
       return !(*this != other);
     }
   };
 
-  Iterator begin() {
+  Iterator<Container> begin() {
     return {get_begin(container_), get_end(container_), filter_func_};
   }
 
-  Iterator end() {
+  Iterator<Container> end() {
     return {get_end(container_), get_end(container_), filter_func_};
   }
+
+  Iterator<AsConst<Container>> begin() const {
+    return {get_begin(as_const(container_)), get_end(as_const(container_)),
+        filter_func_};
+  }
+
+  Iterator<AsConst<Container>> end() const {
+    return {get_end(as_const(container_)), get_end(as_const(container_)),
+        filter_func_};
+  }
 };
 
 #endif

From faa62c5ff1062e800b859ec893acdccfbc011f9e Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Wed, 4 Oct 2017 13:12:50 -0500
Subject: [PATCH 1609/1866] Tests const iteration in takewhile

---
 test/test_takewhile.cpp | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/test/test_takewhile.cpp b/test/test_takewhile.cpp
index 14a739c1..30c572c0 100644
--- a/test/test_takewhile.cpp
+++ b/test/test_takewhile.cpp
@@ -57,6 +57,21 @@ TEST_CASE("takewhile: works with lambda, callable, and function pointer",
   }
 }
 
+TEST_CASE("takewhile: supports const iteration", "[takewhile][const]") {
+  Vec ns = {1, 3, 5, 20, 2, 4, 6, 8};
+  const auto tw = takewhile(UnderTen{}, ns);
+  Vec v(std::begin(tw), std::end(tw));
+  Vec vc = {1, 3, 5};
+  REQUIRE(v == vc);
+}
+
+TEST_CASE("takewhile: const iterator and non-const iterator are comparable",
+    "[takewhile][const]") {
+  auto tw = takewhile(UnderTen{}, Vec{});
+  const auto& ctw = tw;
+  std::begin(tw) == std::end(ctw);
+}
+
 TEST_CASE(
     "takewhile: Works with different begin and end types", "[takewhile]") {
   CharRange cr{'f'};

From e09dd229bee7b5c11ade67aaf2ad3e7d060aac21 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Wed, 4 Oct 2017 13:17:53 -0500
Subject: [PATCH 1610/1866] Adds support for const iteration to takewhile

---
 takewhile.hpp | 37 ++++++++++++++++++++++++++-----------
 1 file changed, 26 insertions(+), 11 deletions(-)

diff --git a/takewhile.hpp b/takewhile.hpp
index af3eeeb9..d4b0e956 100644
--- a/takewhile.hpp
+++ b/takewhile.hpp
@@ -22,7 +22,7 @@ template <typename FilterFunc, typename Container>
 class iter::impl::Taker {
  private:
   Container container_;
-  FilterFunc filter_func_;
+  mutable FilterFunc filter_func_;
 
   friend TakeWhileFn;
 
@@ -33,12 +33,15 @@ class iter::impl::Taker {
  public:
   Taker(Taker&&) = default;
 
+  template <typename ContainerT>
   class Iterator : public std::iterator<std::input_iterator_tag,
-                       iterator_traits_deref<Container>> {
+                       iterator_traits_deref<ContainerT>> {
    private:
-    using Holder = DerefHolder<iterator_deref<Container>>;
-    IteratorWrapper<Container> sub_iter_;
-    IteratorWrapper<Container> sub_end_;
+    template <typename>
+    friend class Iterator;
+    using Holder = DerefHolder<iterator_deref<ContainerT>>;
+    IteratorWrapper<ContainerT> sub_iter_;
+    IteratorWrapper<ContainerT> sub_end_;
     Holder item_;
     FilterFunc* filter_func_;
 
@@ -56,8 +59,8 @@ class iter::impl::Taker {
     }
 
    public:
-    Iterator(IteratorWrapper<Container>&& sub_iter,
-        IteratorWrapper<Container>&& sub_end, FilterFunc& filter_func)
+    Iterator(IteratorWrapper<ContainerT>&& sub_iter,
+        IteratorWrapper<ContainerT>&& sub_end, FilterFunc& filter_func)
         : sub_iter_{std::move(sub_iter)},
           sub_end_{std::move(sub_end)},
           filter_func_(&filter_func) {
@@ -87,22 +90,34 @@ class iter::impl::Taker {
       return ret;
     }
 
-    bool operator!=(const Iterator& other) const {
+    template <typename T>
+    bool operator!=(const Iterator<T>& other) const {
       return sub_iter_ != other.sub_iter_;
     }
 
-    bool operator==(const Iterator& other) const {
+    template <typename T>
+    bool operator==(const Iterator<T>& other) const {
       return !(*this != other);
     }
   };
 
-  Iterator begin() {
+  Iterator<Container> begin() {
     return {get_begin(container_), get_end(container_), filter_func_};
   }
 
-  Iterator end() {
+  Iterator<Container> end() {
     return {get_end(container_), get_end(container_), filter_func_};
   }
+
+  Iterator<AsConst<Container>> begin() const {
+    return {get_begin(as_const(container_)), get_end(as_const(container_)),
+        filter_func_};
+  }
+
+  Iterator<AsConst<Container>> end() const {
+    return {get_end(as_const(container_)), get_end(as_const(container_)),
+        filter_func_};
+  }
 };
 
 #endif

From 9bc5710eb29cf536bbbd4cead13466261080ae05 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 5 Oct 2017 10:16:50 -0500
Subject: [PATCH 1611/1866] broken attempt

---
 starmap.hpp | 120 ++++++++++++++++++++++++++++++++--------------------
 1 file changed, 73 insertions(+), 47 deletions(-)

diff --git a/starmap.hpp b/starmap.hpp
index 3748f244..a970c09d 100644
--- a/starmap.hpp
+++ b/starmap.hpp
@@ -94,7 +94,7 @@ class iter::impl::StarMapper {
 template <typename Func, typename TupType, std::size_t... Is>
 class iter::impl::TupleStarMapper {
  private:
-  Func func_;
+  mutable Func func_;
   TupType tup_;
 
  private:
@@ -103,60 +103,77 @@ class iter::impl::TupleStarMapper {
 
   friend StarMapFn;
 
-  template <std::size_t Idx>
-  static decltype(auto) get_and_call_with_tuple(Func& f, TupType& t) {
-    return call_with_tuple(f, std::get<Idx>(t));
-  }
-
-  using ResultType = decltype(get_and_call_with_tuple<0>(func_, tup_));
-  using CallerFunc = ResultType (*)(Func&, TupType&);
-
-  constexpr static std::array<CallerFunc, sizeof...(Is)> callers{
-      {get_and_call_with_tuple<Is>...}};
-
-  using TraitsValue = std::remove_reference_t<ResultType>;
-
   TupleStarMapper(Func f, TupType t)
       : func_(std::move(f)), tup_(std::forward<TupType>(t)) {}
 
  public:
-  class Iterator : public std::iterator<std::input_iterator_tag, TraitsValue> {
-   private:
-    Func* func_;
-    std::remove_reference_t<TupType>* tup_;
-    std::size_t index_;
-
-   public:
-    Iterator(Func& f, TupType& t, std::size_t i)
-        : func_{&f}, tup_{&t}, index_{i} {}
+  // this is a wrapper class to hold the aliases and functions needed for the Iterator.
+  // the bool IsConst is needed so I can define the operator== and operator!= outside of IteratorData. I have to have the two types of iterators compare equal to each other, but also can't rely on AsConst<TupType> and TupType being different types, the IsConst distinguishes them. Without it, I risk redefining operator== and operator!= with the same iterator types
+  template <typename TupTypeT, bool IsConst>
+  class IteratorData { 
+    private:
+      template <std::size_t Idx>
+      static decltype(auto) get_and_call_with_tuple(Func& f, TupTypeT& t) {
+        return call_with_tuple(f, std::get<Idx>(t));
+      }
 
-    decltype(auto) operator*() {
-      return callers[index_](*func_, *tup_);
-    }
+      using ResultType = decltype(get_and_call_with_tuple<0>(func_, tup_));
+      using CallerFunc = ResultType (*)(Func&, TupTypeT&);
 
-    auto operator-> () -> ArrowProxy<decltype(**this)> {
-      return {**this};
-    }
+      constexpr static std::array<CallerFunc, sizeof...(Is)> callers{
+          {get_and_call_with_tuple<Is>...}};
 
-    Iterator& operator++() {
-      ++index_;
-      return *this;
-    }
+      using TraitsValue = std::remove_reference_t<ResultType>;
 
-    Iterator operator++(int) {
-      auto ret = *this;
-      ++*this;
-      return ret;
-    }
+      IteratorData() = delete;
+   public:
+    class Iterator : public std::iterator<std::input_iterator_tag, TraitsValue> {
+     private:
+      Func* func_;
+      std::remove_reference_t<TupTypeT>* tup_;
+      std::size_t index_;
+
+     public:
+      Iterator(Func& f, TupTypeT& t, std::size_t i)
+          : func_{&f}, tup_{&t}, index_{i} {}
+
+      decltype(auto) operator*() {
+        return callers[index_](*func_, *tup_);
+      }
+
+      auto operator-> () -> ArrowProxy<decltype(**this)> {
+        return {**this};
+      }
+
+      Iterator& operator++() {
+        ++index_;
+        return *this;
+      }
+
+      Iterator operator++(int) {
+        auto ret = *this;
+        ++*this;
+        return ret;
+      }
+
+      
+      // TODO
+      bool operator!=(const Iterator& other) const {
+        return index_ != other.index_;
+      }
+
+      bool operator==(const Iterator& other) const {
+        return !(*this != other);
+      }
+    };
+  };
 
-    bool operator!=(const Iterator& other) const {
-      return index_ != other.index_;
-    }
+  using Iterator = typename IteratorData<TupType, false>::Iterator;
+  using ConstIterator = typename IteratorData<AsConst<TupType>, true>::Iterator;
 
-    bool operator==(const Iterator& other) const {
-      return !(*this != other);
-    }
-  };
+  friend bool operator==(const Iterator& lhs, const ConstIterator& rhs) {
+    return lhs.index_ == rhs.index_;
+  }
 
   Iterator begin() {
     return {func_, tup_, 0};
@@ -165,13 +182,22 @@ class iter::impl::TupleStarMapper {
   Iterator end() {
     return {func_, tup_, sizeof...(Is)};
   }
+
+  ConstIterator begin() const {
+    return {func_, as_const(tup_), 0};
+  }
+
+  ConstIterator end() const {
+    return {func_, as_const(tup_), sizeof...(Is)};
+  }
 };
 
 template <typename Func, typename TupType, std::size_t... Is>
+template <typename T, bool B>
 constexpr std::array<
-    typename iter::impl::TupleStarMapper<Func, TupType, Is...>::CallerFunc,
+    typename iter::impl::TupleStarMapper<Func, TupType, Is...>::template IteratorData<T, B>::CallerFunc,
     sizeof...(Is)>
-    iter::impl::TupleStarMapper<Func, TupType, Is...>::callers;
+    iter::impl::TupleStarMapper<Func, TupType, Is...>::IteratorData<T, B>::callers;
 
 struct iter::impl::StarMapFn : PipeableAndBindFirst<StarMapFn> {
  private:

From ab2c736767a93a3dbe76466ec7bbdd6c3cfa0a9b Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 5 Oct 2017 10:28:59 -0500
Subject: [PATCH 1612/1866] Adds support for const iteration to starmap(tuple)

---
 starmap.hpp | 139 +++++++++++++++++++++++++---------------------------
 1 file changed, 68 insertions(+), 71 deletions(-)

diff --git a/starmap.hpp b/starmap.hpp
index a970c09d..3f66ac1e 100644
--- a/starmap.hpp
+++ b/starmap.hpp
@@ -106,98 +106,95 @@ class iter::impl::TupleStarMapper {
   TupleStarMapper(Func f, TupType t)
       : func_(std::move(f)), tup_(std::forward<TupType>(t)) {}
 
- public:
-  // this is a wrapper class to hold the aliases and functions needed for the Iterator.
-  // the bool IsConst is needed so I can define the operator== and operator!= outside of IteratorData. I have to have the two types of iterators compare equal to each other, but also can't rely on AsConst<TupType> and TupType being different types, the IsConst distinguishes them. Without it, I risk redefining operator== and operator!= with the same iterator types
-  template <typename TupTypeT, bool IsConst>
-  class IteratorData { 
-    private:
-      template <std::size_t Idx>
-      static decltype(auto) get_and_call_with_tuple(Func& f, TupTypeT& t) {
-        return call_with_tuple(f, std::get<Idx>(t));
-      }
+  // this is a wrapper class to hold the aliases and functions needed for the
+  // Iterator.
+  template <typename TupTypeT>
+  class IteratorData {
+   public:
+    template <std::size_t Idx>
+    static decltype(auto) get_and_call_with_tuple(Func& f, TupTypeT& t) {
+      return call_with_tuple(f, std::get<Idx>(t));
+    }
 
-      using ResultType = decltype(get_and_call_with_tuple<0>(func_, tup_));
-      using CallerFunc = ResultType (*)(Func&, TupTypeT&);
+    using ResultType = decltype(get_and_call_with_tuple<0>(func_, tup_));
+    using CallerFunc = ResultType (*)(Func&, TupTypeT&);
 
-      constexpr static std::array<CallerFunc, sizeof...(Is)> callers{
-          {get_and_call_with_tuple<Is>...}};
+    constexpr static std::array<CallerFunc, sizeof...(Is)> callers{
+        {get_and_call_with_tuple<Is>...}};
 
-      using TraitsValue = std::remove_reference_t<ResultType>;
+    using TraitsValue = std::remove_reference_t<ResultType>;
 
-      IteratorData() = delete;
-   public:
-    class Iterator : public std::iterator<std::input_iterator_tag, TraitsValue> {
-     private:
-      Func* func_;
-      std::remove_reference_t<TupTypeT>* tup_;
-      std::size_t index_;
-
-     public:
-      Iterator(Func& f, TupTypeT& t, std::size_t i)
-          : func_{&f}, tup_{&t}, index_{i} {}
-
-      decltype(auto) operator*() {
-        return callers[index_](*func_, *tup_);
-      }
-
-      auto operator-> () -> ArrowProxy<decltype(**this)> {
-        return {**this};
-      }
-
-      Iterator& operator++() {
-        ++index_;
-        return *this;
-      }
-
-      Iterator operator++(int) {
-        auto ret = *this;
-        ++*this;
-        return ret;
-      }
-
-      
-      // TODO
-      bool operator!=(const Iterator& other) const {
-        return index_ != other.index_;
-      }
-
-      bool operator==(const Iterator& other) const {
-        return !(*this != other);
-      }
-    };
+    IteratorData() = delete;
   };
 
-  using Iterator = typename IteratorData<TupType, false>::Iterator;
-  using ConstIterator = typename IteratorData<AsConst<TupType>, true>::Iterator;
+ public:
+  template <typename TupTypeT>
+  class Iterator : public std::iterator<std::input_iterator_tag,
+                       typename IteratorData<TupTypeT>::TraitsValue> {
+   private:
+    template <typename>
+    friend class Iterator;
+    Func* func_;
+    std::remove_reference_t<TupTypeT>* tup_;
+    std::size_t index_;
 
-  friend bool operator==(const Iterator& lhs, const ConstIterator& rhs) {
-    return lhs.index_ == rhs.index_;
-  }
+   public:
+    Iterator(Func& f, TupTypeT& t, std::size_t i)
+        : func_{&f}, tup_{&t}, index_{i} {}
 
-  Iterator begin() {
+    decltype(auto) operator*() {
+      return IteratorData<TupTypeT>::callers[index_](*func_, *tup_);
+    }
+
+    auto operator-> () -> ArrowProxy<decltype(**this)> {
+      return {**this};
+    }
+
+    Iterator& operator++() {
+      ++index_;
+      return *this;
+    }
+
+    Iterator operator++(int) {
+      auto ret = *this;
+      ++*this;
+      return ret;
+    }
+
+    template <typename T>
+    bool operator!=(const Iterator<T>& other) const {
+      return index_ != other.index_;
+    }
+
+    template <typename T>
+    bool operator==(const Iterator<T>& other) const {
+      return !(*this != other);
+    }
+  };
+
+  Iterator<TupType> begin() {
     return {func_, tup_, 0};
   }
 
-  Iterator end() {
+  Iterator<TupType> end() {
     return {func_, tup_, sizeof...(Is)};
   }
 
-  ConstIterator begin() const {
+  Iterator<AsConst<TupType>> begin() const {
     return {func_, as_const(tup_), 0};
   }
 
-  ConstIterator end() const {
+  Iterator<AsConst<TupType>> end() const {
     return {func_, as_const(tup_), sizeof...(Is)};
   }
 };
 
 template <typename Func, typename TupType, std::size_t... Is>
-template <typename T, bool B>
-constexpr std::array<
-    typename iter::impl::TupleStarMapper<Func, TupType, Is...>::template IteratorData<T, B>::CallerFunc,
+template <typename T>
+constexpr std::array<typename iter::impl::TupleStarMapper<Func, TupType,
+                         Is...>::template IteratorData<T>::CallerFunc,
     sizeof...(Is)>
-    iter::impl::TupleStarMapper<Func, TupType, Is...>::IteratorData<T, B>::callers;
+    iter::impl::TupleStarMapper<Func, TupType, Is...>::IteratorData<T>::callers;
 
 struct iter::impl::StarMapFn : PipeableAndBindFirst<StarMapFn> {
  private:
@@ -211,8 +208,8 @@ struct iter::impl::StarMapFn : PipeableAndBindFirst<StarMapFn> {
   template <typename Func, typename TupType>
   auto helper(Func func, TupType&& tup, std::true_type) const {
     return helper_with_tuples(std::move(func), std::forward<TupType>(tup),
-        std::make_index_sequence<
-            std::tuple_size<std::decay_t<TupType>>::value>{});
+        std::make_index_sequence<std::tuple_size<std::decay_t<TupType>>::
+                                      value>{});
   }
 
   // handles everything else

From 62878fd507187986c29e2b1d6a13b80a3ad5c333 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 5 Oct 2017 10:29:16 -0500
Subject: [PATCH 1613/1866] Tests starmap(tuple) with const iteration

---
 test/test_starmap.cpp | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/test/test_starmap.cpp b/test/test_starmap.cpp
index 55e94503..36897f63 100644
--- a/test/test_starmap.cpp
+++ b/test/test_starmap.cpp
@@ -66,6 +66,24 @@ TEST_CASE("starmap: Works with different begin and end types", "[starmap]") {
   REQUIRE(v == vc);
 }
 
+TEST_CASE("starmap: tuple of tuples const iteration", "[starmap][const]") {
+  using Vec = const std::vector<int>;
+  auto tup = std::make_tuple(std::make_tuple(10, 19, 60), std::make_tuple(7));
+  const auto sm = starmap(Callable{}, tup);
+  Vec v(std::begin(sm), std::end(sm));
+}
+
+TEST_CASE(
+    "starmap: tuple of tuples const iterators can be compared to non-const "
+    "iterator",
+    "[starmap][const]") {
+  auto tup = std::make_tuple(std::make_tuple(10, 19, 60), std::make_tuple(7));
+  auto sm = starmap(Callable{}, tup);
+  const auto& csm = sm;
+  std::begin(sm) == std::end(csm);
+  std::begin(csm) == std::end(sm);
+}
+
 TEST_CASE("starmap: list of tuples", "[starmap]") {
   using Vec = const std::vector<std::string>;
   using T = std::tuple<std::string, int, double>;

From fa2e3bc81fd8e3d1dacde0730f19ea14a80bb9e1 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 5 Oct 2017 10:47:03 -0500
Subject: [PATCH 1614/1866] Fixes error under clang

The explicit trailing return caused an incomplete type issue in clang.
Idk why, I've had too many issues with compilers messing up to care
whether clang or gcc is right on this.
---
 starmap.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/starmap.hpp b/starmap.hpp
index 3f66ac1e..a4951f55 100644
--- a/starmap.hpp
+++ b/starmap.hpp
@@ -146,8 +146,8 @@ class iter::impl::TupleStarMapper {
       return IteratorData<TupTypeT>::callers[index_](*func_, *tup_);
     }
 
-    auto operator-> () -> ArrowProxy<decltype(**this)> {
-      return {**this};
+    auto operator-> () {
+      return ArrowProxy<decltype(**this)>{**this};
     }
 
     Iterator& operator++() {

From 25687ada446cd83bbfafb2eacb61363c6380649b Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 5 Oct 2017 10:53:44 -0500
Subject: [PATCH 1615/1866] Silences clang unused warnings

---
 test/test_accumulate.cpp  | 2 +-
 test/test_chunked.cpp     | 2 +-
 test/test_dropwhile.cpp   | 2 +-
 test/test_enumerate.cpp   | 2 +-
 test/test_filter.cpp      | 2 +-
 test/test_filterfalse.cpp | 2 +-
 test/test_starmap.cpp     | 4 ++--
 test/test_takewhile.cpp   | 2 +-
 8 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/test/test_accumulate.cpp b/test/test_accumulate.cpp
index 4774dece..98058dbd 100644
--- a/test/test_accumulate.cpp
+++ b/test/test_accumulate.cpp
@@ -68,7 +68,7 @@ TEST_CASE("accumulate: const iterators", "[accumulate][const]") {
 TEST_CASE("accumulate: const iterators can be compared", "[accumulate][const]") {
   auto e = accumulate(std::string("hello"));
   const auto& ce = e;
-  std::begin(e) == std::end(ce);
+  (void)(std::begin(e) == std::end(ce));
 }
 
 struct Integer {
diff --git a/test/test_chunked.cpp b/test/test_chunked.cpp
index f8c12f69..7e3165a0 100644
--- a/test/test_chunked.cpp
+++ b/test/test_chunked.cpp
@@ -49,7 +49,7 @@ TEST_CASE("chunked: const iterators can be compared to non-const iterators",
     "[chunked][const]") {
   auto c = chunked(Vec{}, 1);
   const auto& cc = c;
-  std::begin(c) == std::end(cc);
+  (void)(std::begin(c) == std::end(cc));
 }
 
 TEST_CASE("chunked: len(iterable) % groupsize != 0", "[chunked]") {
diff --git a/test/test_dropwhile.cpp b/test/test_dropwhile.cpp
index 5802c7a6..1b4edcb5 100644
--- a/test/test_dropwhile.cpp
+++ b/test/test_dropwhile.cpp
@@ -53,7 +53,7 @@ TEST_CASE("dropwhile: const iterators can be compared to non-const iterators",
     "[dropwhile][const]") {
   auto d = dropwhile(LessThanValue{5}, Vec{});
   const auto& cd = d;
-  std::begin(d) == std::end(cd);
+  (void)(std::begin(d) == std::end(cd));
 }
 
 TEST_CASE(
diff --git a/test/test_enumerate.cpp b/test/test_enumerate.cpp
index 75272c2f..943dc245 100644
--- a/test/test_enumerate.cpp
+++ b/test/test_enumerate.cpp
@@ -59,7 +59,7 @@ TEST_CASE("const enumerate", "[enumerate][const]") {
 TEST_CASE("enumerate: const iterators can be compared", "[enumerate][const]") {
   auto e = enumerate(std::string("hello"));
   const auto& ce = e;
-  std::begin(e) == std::end(ce);
+  (void)(std::begin(e) == std::end(ce));
 }
 
 TEST_CASE("Empty enumerate", "[enumerate]") {
diff --git a/test/test_filter.cpp b/test/test_filter.cpp
index f6950eb7..62b5f9a1 100644
--- a/test/test_filter.cpp
+++ b/test/test_filter.cpp
@@ -65,7 +65,7 @@ TEST_CASE("filter: const iterator can be compared to non-const iterator",
     "[filter][const]") {
   auto f = filter(LessThanValue{5}, Vec{});
   const auto& cf = f;
-  std::begin(f) == std::end(cf);
+  (void)(std::begin(f) == std::end(cf));
 }
 
 TEST_CASE("filter: iterator with lambda can be assigned", "[filter]") {
diff --git a/test/test_filterfalse.cpp b/test/test_filterfalse.cpp
index a2fc14b9..9e230ee1 100644
--- a/test/test_filterfalse.cpp
+++ b/test/test_filterfalse.cpp
@@ -72,7 +72,7 @@ TEST_CASE("filterfalse: const iterator and non-const iterator can be compared",
     "[filterfalse][const]") {
   auto f = filterfalse(LessThanValue{5}, Vec{});
   const auto& cf = f;
-  std::begin(f) == std::end(cf);
+  (void)(std::begin(f) == std::end(cf));
 }
 
 TEST_CASE(
diff --git a/test/test_starmap.cpp b/test/test_starmap.cpp
index 36897f63..fdab5de4 100644
--- a/test/test_starmap.cpp
+++ b/test/test_starmap.cpp
@@ -80,8 +80,8 @@ TEST_CASE(
   auto tup = std::make_tuple(std::make_tuple(10, 19, 60), std::make_tuple(7));
   auto sm = starmap(Callable{}, tup);
   const auto& csm = sm;
-  std::begin(sm) == std::end(csm);
-  std::begin(csm) == std::end(sm);
+  (void)(std::begin(sm) == std::end(csm));
+  (void)(std::begin(csm) == std::end(sm));
 }
 
 TEST_CASE("starmap: list of tuples", "[starmap]") {
diff --git a/test/test_takewhile.cpp b/test/test_takewhile.cpp
index 30c572c0..bea9e6e2 100644
--- a/test/test_takewhile.cpp
+++ b/test/test_takewhile.cpp
@@ -69,7 +69,7 @@ TEST_CASE("takewhile: const iterator and non-const iterator are comparable",
     "[takewhile][const]") {
   auto tw = takewhile(UnderTen{}, Vec{});
   const auto& ctw = tw;
-  std::begin(tw) == std::end(ctw);
+  (void)(std::begin(tw) == std::end(ctw));
 }
 
 TEST_CASE(

From 04c6373235c38415cef7b0401354f61209b48aeb Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 5 Oct 2017 12:40:39 -0500
Subject: [PATCH 1616/1866] Tests starmap(seq<tuple>) with const iteration

---
 test/test_starmap.cpp | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/test/test_starmap.cpp b/test/test_starmap.cpp
index fdab5de4..1b284738 100644
--- a/test/test_starmap.cpp
+++ b/test/test_starmap.cpp
@@ -27,6 +27,10 @@ namespace {
       return a + b + c;
     }
 
+    int operator()(int a, int b) {
+      return a + b;
+    }
+
     int operator()(int a) {
       return a;
     }
@@ -57,6 +61,26 @@ TEST_CASE("starmap: works with function pointer and lambda", "[starmap]") {
   REQUIRE(v == vc);
 }
 
+TEST_CASE("starmap: vector of pairs const iteration", "[starmap][const]") {
+  using Vec = const std::vector<int>;
+  const std::vector<std::pair<double, int>> v1 = {{1l, 2}, {3l, 11}, {6l, 7}};
+
+  const auto sm = starmap(Callable{}, v1);
+  std::vector<int> v(std::begin(sm), std::end(sm));
+  Vec vc = {3, 14, 13};
+  REQUIRE(v == vc);
+}
+
+TEST_CASE(
+    "starmap: vector of pairs const iterators can be compared to non-const "
+    "iterators",
+    "[starmap][const]") {
+  const std::vector<std::pair<double, int>> v1;
+  auto sm = starmap(Callable{}, v1);
+  const auto& csm = sm;
+  (void)(std::begin(sm) == std::end(csm));
+}
+
 TEST_CASE("starmap: Works with different begin and end types", "[starmap]") {
   IntCharPairRange icr{{3, 'd'}};
   using Vec = std::vector<std::string>;

From 806a0dc865afae2f833f4c4e1e5b9b04fa589105 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 5 Oct 2017 12:41:16 -0500
Subject: [PATCH 1617/1866] Supports const iteration in starmap(seq<tuple>)

---
 starmap.hpp | 27 ++++++++++++++++++++-------
 1 file changed, 20 insertions(+), 7 deletions(-)

diff --git a/starmap.hpp b/starmap.hpp
index a4951f55..4f82d106 100644
--- a/starmap.hpp
+++ b/starmap.hpp
@@ -31,7 +31,7 @@ namespace iter {
 template <typename Func, typename Container>
 class iter::impl::StarMapper {
  private:
-  Func func_;
+  mutable Func func_;
   Container container_;
 
   using StarIterDeref = std::remove_reference_t<decltype(
@@ -43,21 +43,26 @@ class iter::impl::StarMapper {
   friend StarMapFn;
 
  public:
+  template <typename ContainerT>
   class Iterator
       : public std::iterator<std::input_iterator_tag, StarIterDeref> {
    private:
+    template <typename>
+    friend class Iterator;
     Func* func_;
-    IteratorWrapper<Container> sub_iter_;
+    IteratorWrapper<ContainerT> sub_iter_;
 
    public:
-    Iterator(Func& f, IteratorWrapper<Container>&& sub_iter)
+    Iterator(Func& f, IteratorWrapper<ContainerT>&& sub_iter)
         : func_(&f), sub_iter_(std::move(sub_iter)) {}
 
-    bool operator!=(const Iterator& other) const {
+    template <typename T>
+    bool operator!=(const Iterator<T>& other) const {
       return sub_iter_ != other.sub_iter_;
     }
 
-    bool operator==(const Iterator& other) const {
+    template <typename T>
+    bool operator==(const Iterator<T>& other) const {
       return !(*this != other);
     }
 
@@ -81,13 +86,21 @@ class iter::impl::StarMapper {
     }
   };
 
-  Iterator begin() {
+  Iterator<Container> begin() {
     return {func_, get_begin(container_)};
   }
 
-  Iterator end() {
+  Iterator<Container> end() {
     return {func_, get_end(container_)};
   }
+
+  Iterator<AsConst<Container>> begin() const {
+    return {func_, get_begin(as_const(container_))};
+  }
+
+  Iterator<AsConst<Container>> end() const {
+    return {func_, get_end(as_const(container_))};
+  }
 };
 
 // starmap for a tuple or pair of tuples or pairs

From 254e9f53d4656af607de171c01f8b4d4fd4f942b Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 5 Oct 2017 13:13:10 -0500
Subject: [PATCH 1618/1866] Tests range iterators compare to const iterators

---
 test/test_range.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/test/test_range.cpp b/test/test_range.cpp
index c7705d41..dab748e3 100644
--- a/test/test_range.cpp
+++ b/test/test_range.cpp
@@ -112,6 +112,12 @@ TEST_CASE("range: can create constexpr ranges", "[range]") {
   static_assert(f == 0.0, "range's begin has tho wrong value (float)");
 }
 
+TEST_CASE("range: const iterators compare to non-const iterators", "[range]") {
+  auto r = range(0);
+  const auto& cr = r;
+  (void)(std::begin(r) == std::end(cr));
+}
+
 TEST_CASE("range: works with a variable start, stop, and step", "[range]") {
   constexpr int a = 10;
   constexpr int b = 100;

From db13cb83ad9fa6488621c3a190d0f843914399f5 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 5 Oct 2017 13:14:58 -0500
Subject: [PATCH 1619/1866] Tests repeat iterators compare to const iterators

---
 test/test_repeat.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/test/test_repeat.cpp b/test/test_repeat.cpp
index df42c99c..0fc62e72 100644
--- a/test/test_repeat.cpp
+++ b/test/test_repeat.cpp
@@ -50,6 +50,12 @@ TEST_CASE("repeat: can be used as constexpr", "[repeat]") {
   }
 }
 
+TEST_CASE("repeat: iterators compare to const iterators", "[repeat]") {
+  auto r = repeat(1);
+  const auto& cr = r;
+  (void)(std::begin(r) == std::end(cr));
+}
+
 TEST_CASE("repeat: two argument repeats a number of times", "[repeat]") {
   auto r = repeat('a', 3);
   std::string s(std::begin(r), std::end(r));

From 578c6e1750611282d97566abe10e3a0409bb4719 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 5 Oct 2017 13:40:51 -0500
Subject: [PATCH 1620/1866] Tests compress with const iteration

---
 test/test_compress.cpp | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/test/test_compress.cpp b/test/test_compress.cpp
index 5b13b345..1330e9c2 100644
--- a/test/test_compress.cpp
+++ b/test/test_compress.cpp
@@ -23,6 +23,23 @@ TEST_CASE("compress: alternating", "[compress]") {
   REQUIRE(v == vc);
 }
 
+TEST_CASE("compress: const iteration ", "[compress][const]") {
+  std::vector<int> ivec{1, 2, 3, 4, 5, 6};
+  std::vector<bool> bvec{true, false, true, false, true, false};
+  const auto c = compress(ivec, bvec);
+  Vec v(std::begin(c), std::end(c));
+  Vec vc = {1, 3, 5};
+
+  REQUIRE(v == vc);
+}
+
+TEST_CASE("compress: const iterators can be compared to non-const iterators",
+    "[compress][const]") {
+  auto c = compress(std::vector<int>{}, std::vector<bool>{});
+  const auto& cc = c;
+  (void)(std::begin(c) == std::end(cc));
+}
+
 TEST_CASE("compress: consecutive falses", "[compress]") {
   std::vector<int> ivec{1, 2, 3, 4, 5};
   std::vector<bool> bvec{true, false, false, false, true};

From d029462b49be55edbc4f63e352efbacdf379a73a Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 5 Oct 2017 13:41:10 -0500
Subject: [PATCH 1621/1866] Adds support for compress with const iteration

---
 compress.hpp | 47 ++++++++++++++++++++++++++++++-----------------
 1 file changed, 30 insertions(+), 17 deletions(-)

diff --git a/compress.hpp b/compress.hpp
index ca0da7d2..9c511215 100644
--- a/compress.hpp
+++ b/compress.hpp
@@ -26,23 +26,23 @@ class iter::impl::Compressed {
   friend Compressed iter::compress<Container, Selector>(
       Container&&, Selector&&);
 
-  // Selector::Iterator type
-  using selector_iter_type = decltype(get_begin(selectors_));
-
   Compressed(Container&& in_container, Selector&& in_selectors)
       : container_(std::forward<Container>(in_container)),
         selectors_(std::forward<Selector>(in_selectors)) {}
 
  public:
   Compressed(Compressed&&) = default;
+  template <typename ContainerT, typename SelectorT>
   class Iterator : public std::iterator<std::input_iterator_tag,
-                       iterator_traits_deref<Container>> {
+                       iterator_traits_deref<ContainerT>> {
    private:
-    IteratorWrapper<Container> sub_iter_;
-    IteratorWrapper<Container> sub_end_;
+    template <typename, typename>
+    friend class Iterator;
+    IteratorWrapper<ContainerT> sub_iter_;
+    IteratorWrapper<ContainerT> sub_end_;
 
-    selector_iter_type selector_iter_;
-    selector_iter_type selector_end_;
+    IteratorWrapper<SelectorT> selector_iter_;
+    IteratorWrapper<SelectorT> selector_end_;
 
     void increment_iterators() {
       ++sub_iter_;
@@ -57,9 +57,10 @@ class iter::impl::Compressed {
     }
 
    public:
-    Iterator(IteratorWrapper<Container>&& cont_iter,
-        IteratorWrapper<Container>&& cont_end, selector_iter_type&& sel_iter,
-        selector_iter_type&& sel_end)
+    Iterator(IteratorWrapper<ContainerT>&& cont_iter,
+        IteratorWrapper<ContainerT>&& cont_end,
+        IteratorWrapper<SelectorT>&& sel_iter,
+        IteratorWrapper<SelectorT>&& sel_end)
         : sub_iter_{std::move(cont_iter)},
           sub_end_{std::move(cont_end)},
           selector_iter_{std::move(sel_iter)},
@@ -67,11 +68,11 @@ class iter::impl::Compressed {
       skip_failures();
     }
 
-    iterator_deref<Container> operator*() {
+    iterator_deref<ContainerT> operator*() {
       return *sub_iter_;
     }
 
-    iterator_arrow<Container> operator->() {
+    iterator_arrow<ContainerT> operator->() {
       return apply_arrow(sub_iter_);
     }
 
@@ -87,25 +88,37 @@ class iter::impl::Compressed {
       return ret;
     }
 
-    bool operator!=(const Iterator& other) const {
+    template <typename T, typename U>
+    bool operator!=(const Iterator<T, U>& other) const {
       return sub_iter_ != other.sub_iter_
              && selector_iter_ != other.selector_iter_;
     }
 
-    bool operator==(const Iterator& other) const {
+    template <typename T, typename U>
+    bool operator==(const Iterator<T, U>& other) const {
       return !(*this != other);
     }
   };
 
-  Iterator begin() {
+  Iterator<Container, Selector> begin() {
     return {get_begin(container_), get_end(container_), get_begin(selectors_),
         get_end(selectors_)};
   }
 
-  Iterator end() {
+  Iterator<Container, Selector> end() {
     return {get_end(container_), get_end(container_), get_end(selectors_),
         get_end(selectors_)};
   }
+
+  Iterator<AsConst<Container>, AsConst<Selector>> begin() const {
+    return {get_begin(as_const(container_)), get_end(as_const(container_)),
+        get_begin(as_const(selectors_)), get_end(as_const(selectors_))};
+  }
+
+  Iterator<AsConst<Container>, AsConst<Selector>> end() const {
+    return {get_end(as_const(container_)), get_end(as_const(container_)),
+        get_end(as_const(selectors_)), get_end(as_const(selectors_))};
+  }
 };
 
 template <typename Container, typename Selector>

From 7c0c9261cce758d696880bd8bc31364dfa3fbb16 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 5 Oct 2017 13:45:12 -0500
Subject: [PATCH 1622/1866] Tests count with const iteration

---
 test/test_count.cpp | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/test/test_count.cpp b/test/test_count.cpp
index d1f0ff65..f0f0de68 100644
--- a/test/test_count.cpp
+++ b/test/test_count.cpp
@@ -20,6 +20,18 @@ TEST_CASE("count: watch for 10 elements", "[count]") {
   REQUIRE(v == vc);
 }
 
+TEST_CASE("count: const watch for 10 elements", "[count][const]") {
+  std::vector<int> v{};
+  const auto c = count();
+  for (auto i : c) {
+    v.push_back(i);
+    if (i == 9) break;
+  }
+
+  const std::vector<int> vc{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+  REQUIRE(v == vc);
+}
+
 TEST_CASE("count: start at 10", "[count]") {
   std::vector<int> v{};
   for (auto i : count(10)) {

From 6ebe781e7956e9e340ac61f0d452e7415f15b8e0 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 5 Oct 2017 14:04:37 -0500
Subject: [PATCH 1623/1866] Tests cycle with const iteration

---
 test/test_cycle.cpp | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/test/test_cycle.cpp b/test/test_cycle.cpp
index 39e3bb19..84981878 100644
--- a/test/test_cycle.cpp
+++ b/test/test_cycle.cpp
@@ -27,6 +27,31 @@ TEST_CASE("cycle: iterate twice", "[cycle]") {
   REQUIRE(v == vc);
 }
 
+TEST_CASE("cycle: const iteration, iterate twice", "[cycle][const]") {
+  std::vector<int> ns{2, 4, 6};
+  std::vector<int> v{};
+  std::size_t count = 0;
+  const auto c = cycle(ns);
+  for (auto i : c) {
+    v.push_back(i);
+    ++count;
+    if (count == ns.size() * 2) {
+      break;
+    }
+  }
+
+  auto vc = ns;
+  vc.insert(std::end(vc), std::begin(ns), std::end(ns));
+  REQUIRE(v == vc);
+}
+
+TEST_CASE("cycle: const iterators can be compared to non-const iterators",
+    "[cycle][const]") {
+  auto c = cycle(std::vector<int>{});
+  const auto& cc = c;
+  (void)(std::begin(c) == std::end(cc));
+}
+
 TEST_CASE("cycle: Works with different begin and end types", "[cycle]") {
   constexpr auto sz = 'd' - 'a';
   CharRange cr{'d'};

From 171d4e17754adbed6f484e81a5ed769b9d540fce Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 5 Oct 2017 14:06:18 -0500
Subject: [PATCH 1624/1866] Adds support for const iteration to cycle

---
 cycle.hpp | 37 +++++++++++++++++++++++++------------
 1 file changed, 25 insertions(+), 12 deletions(-)

diff --git a/cycle.hpp b/cycle.hpp
index cd058335..21a92872 100644
--- a/cycle.hpp
+++ b/cycle.hpp
@@ -30,25 +30,28 @@ class iter::impl::Cycler {
 
  public:
   Cycler(Cycler&&) = default;
+  template <typename ContainerT>
   class Iterator : public std::iterator<std::input_iterator_tag,
-                       iterator_traits_deref<Container>> {
+                       iterator_traits_deref<ContainerT>> {
    private:
-    IteratorWrapper<Container> sub_iter_;
-    IteratorWrapper<Container> sub_begin_;
-    IteratorWrapper<Container> sub_end_;
+    template <typename>
+    friend class Iterator;
+    IteratorWrapper<ContainerT> sub_iter_;
+    IteratorWrapper<ContainerT> sub_begin_;
+    IteratorWrapper<ContainerT> sub_end_;
 
    public:
-    Iterator(IteratorWrapper<Container>&& sub_iter,
-        IteratorWrapper<Container>&& sub_end)
+    Iterator(IteratorWrapper<ContainerT>&& sub_iter,
+        IteratorWrapper<ContainerT>&& sub_end)
         : sub_iter_{sub_iter},
           sub_begin_{sub_iter},
           sub_end_{std::move(sub_end)} {}
 
-    iterator_deref<Container> operator*() {
+    iterator_deref<ContainerT> operator*() {
       return *sub_iter_;
     }
 
-    iterator_arrow<Container> operator->() {
+    iterator_arrow<ContainerT> operator->() {
       return apply_arrow(sub_iter_);
     }
 
@@ -67,22 +70,32 @@ class iter::impl::Cycler {
       return ret;
     }
 
-    bool operator!=(const Iterator& other) const {
+    template <typename T>
+    bool operator!=(const Iterator<T>& other) const {
       return sub_iter_ != other.sub_iter_;
     }
 
-    bool operator==(const Iterator& other) const {
+    template <typename T>
+    bool operator==(const Iterator<T>& other) const {
       return !(*this != other);
     }
   };
 
-  Iterator begin() {
+  Iterator<Container> begin() {
     return {get_begin(container_), get_end(container_)};
   }
 
-  Iterator end() {
+  Iterator<Container> end() {
     return {get_end(container_), get_end(container_)};
   }
+
+  Iterator<AsConst<Container>> begin() const {
+    return {get_begin(as_const(container_)), get_end(as_const(container_))};
+  }
+
+  Iterator<AsConst<Container>> end() const {
+    return {get_end(as_const(container_)), get_end(as_const(container_))};
+  }
 };
 
 #endif

From ef97f2460ab47022e44be9040b86a56a8eff5826 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 5 Oct 2017 14:18:06 -0500
Subject: [PATCH 1625/1866] Tests const iteration in slice

---
 test/test_slice.cpp | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/test/test_slice.cpp b/test/test_slice.cpp
index 385e6c12..38386b73 100644
--- a/test/test_slice.cpp
+++ b/test/test_slice.cpp
@@ -27,6 +27,23 @@ TEST_CASE("slice: take from beginning", "[slice]") {
   REQUIRE(v == vc);
 }
 
+TEST_CASE("slice: const iteration", "[slice][const]") {
+  Vec ns = {10, 11, 12, 13, 14, 15, 16, 17, 18, 19};
+
+  const auto sl = slice(ns, 5);
+  Vec v(std::begin(sl), std::end(sl));
+
+  Vec vc = {10, 11, 12, 13, 14};
+  REQUIRE(v == vc);
+}
+
+TEST_CASE("slice: const iterator can be compared to non-const iterator",
+    "[slice][const]") {
+  auto sl = slice(Vec{}, 1);
+  const auto& csl = sl;
+  (void)(std::begin(sl) == std::end(csl));
+}
+
 TEST_CASE("slice: start and stop", "[slice]") {
   Vec ns = {10, 11, 12, 13, 14, 15, 16, 17, 18, 19};
 

From d59bbd1f7dca233f792cad26a4ad2cfd9abe3320 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 5 Oct 2017 14:18:31 -0500
Subject: [PATCH 1626/1866] Adds support for const iteration in slice

---
 slice.hpp | 45 +++++++++++++++++++++++++++++++--------------
 1 file changed, 31 insertions(+), 14 deletions(-)

diff --git a/slice.hpp b/slice.hpp
index 1ee4252a..4ac9e1a0 100644
--- a/slice.hpp
+++ b/slice.hpp
@@ -35,18 +35,21 @@ class iter::impl::Sliced {
 
  public:
   Sliced(Sliced&&) = default;
+  template <typename ContainerT>
   class Iterator : public std::iterator<std::input_iterator_tag,
-                       iterator_traits_deref<Container>> {
+                       iterator_traits_deref<ContainerT>> {
    private:
-    IteratorWrapper<Container> sub_iter_;
-    IteratorWrapper<Container> sub_end_;
+    template <typename>
+    friend class Iterator;
+    IteratorWrapper<ContainerT> sub_iter_;
+    IteratorWrapper<ContainerT> sub_end_;
     DifferenceType current_;
     DifferenceType stop_;
     DifferenceType step_;
 
    public:
-    Iterator(IteratorWrapper<Container>&& sub_iter,
-        IteratorWrapper<Container>&& sub_end, DifferenceType start,
+    Iterator(IteratorWrapper<ContainerT>&& sub_iter,
+        IteratorWrapper<ContainerT>&& sub_end, DifferenceType start,
         DifferenceType stop, DifferenceType step)
         : sub_iter_{std::move(sub_iter)},
           sub_end_{std::move(sub_end)},
@@ -54,11 +57,11 @@ class iter::impl::Sliced {
           stop_{stop},
           step_{step} {}
 
-    iterator_deref<Container> operator*() {
+    iterator_deref<ContainerT> operator*() {
       return *sub_iter_;
     }
 
-    iterator_arrow<Container> operator->() {
+    iterator_arrow<ContainerT> operator->() {
       return apply_arrow(sub_iter_);
     }
 
@@ -77,24 +80,37 @@ class iter::impl::Sliced {
       return ret;
     }
 
-    bool operator!=(const Iterator& other) const {
+    template <typename T>
+    bool operator!=(const Iterator<T>& other) const {
       return sub_iter_ != other.sub_iter_ && current_ != other.current_;
     }
 
-    bool operator==(const Iterator& other) const {
+    template <typename T>
+    bool operator==(const Iterator<T>& other) const {
       return !(*this != other);
     }
   };
 
-  Iterator begin() {
+  Iterator<Container> begin() {
     auto it = get_begin(container_);
     dumb_advance(it, get_end(container_), start_);
     return {std::move(it), get_end(container_), start_, stop_, step_};
   }
 
-  Iterator end() {
+  Iterator<Container> end() {
     return {get_end(container_), get_end(container_), stop_, stop_, step_};
   }
+
+  Iterator<AsConst<Container>> begin() const {
+    auto it = get_begin(as_const(container_));
+    dumb_advance(it, get_end(as_const(container_)), start_);
+    return {std::move(it), get_end(as_const(container_)), start_, stop_, step_};
+  }
+
+  Iterator<AsConst<Container>> end() const {
+    return {get_end(as_const(container_)), get_end(as_const(container_)), stop_,
+        stop_, step_};
+  }
 };
 
 struct iter::impl::SliceFn {
@@ -109,9 +125,10 @@ struct iter::impl::SliceFn {
 
    private:
     friend SliceFn;
-    constexpr FnPartial(
-        DifferenceType start, DifferenceType stop, DifferenceType step) noexcept
-        : start_{start}, stop_{stop}, step_{step} {}
+    constexpr FnPartial(DifferenceType start, DifferenceType stop,
+        DifferenceType step) noexcept : start_{start},
+                                        stop_{stop},
+                                        step_{step} {}
     DifferenceType start_;
     DifferenceType stop_;
     DifferenceType step_;

From 0d5f2e3c7fbe51a5eb9dbac866ce1ff157f02390 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 5 Oct 2017 14:45:27 -0500
Subject: [PATCH 1627/1866] Test reversed with const iteration

---
 test/test_reversed.cpp | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/test/test_reversed.cpp b/test/test_reversed.cpp
index 81ea1d4f..530a17fc 100644
--- a/test/test_reversed.cpp
+++ b/test/test_reversed.cpp
@@ -31,6 +31,21 @@ TEST_CASE("reversed: can reverse a vector", "[reversed]") {
   REQUIRE(v == vc);
 }
 
+TEST_CASE("reversed: const iteration", "[reversed][const]") {
+  Vec ns = {10, 20, 30, 40};
+  const auto r = reversed(ns);
+  Vec v(std::begin(r), std::end(r));
+  Vec vc = {40, 30, 20, 10};
+  REQUIRE(v == vc);
+}
+
+TEST_CASE("reversed: const iterators can be compared to non-const iterators",
+    "[reversed][const]") {
+  auto r = reversed(Vec{});
+  const auto& cr = r;
+  (void)(std::begin(r) == std::end(cr));
+}
+
 #if 0
 TEST_CASE("reversed: Works with different begin and end types",
     "[reversed]") {

From 9d106985798a6431fe1013307161576044d1fa54 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 5 Oct 2017 14:45:38 -0500
Subject: [PATCH 1628/1866] Adds support for const iteration to reversed

---
 reversed.hpp | 45 +++++++++++++++++++++++++++++++--------------
 1 file changed, 31 insertions(+), 14 deletions(-)

diff --git a/reversed.hpp b/reversed.hpp
index 987b0cd5..4f3004e2 100644
--- a/reversed.hpp
+++ b/reversed.hpp
@@ -36,7 +36,9 @@ namespace iter {
     using ReverseIteratorWrapper =
         typename ReverseIteratorWrapperImplType<Container,
             std::is_same<impl::reverse_iterator_type<Container>,
-                impl::reverse_iterator_end_type<Container>>{}>::type;
+                                                    impl::
+                                                        reverse_iterator_end_type<Container>>{}>::
+            type;
 
     template <typename Container>
     class Reverser;
@@ -55,31 +57,36 @@ class iter::impl::Reverser {
   Reverser(Container&& container)
       : container_(std::forward<Container>(container)) {}
 
+  template <typename T>
   using reverse_iterator_deref =
-      decltype(*std::declval<reverse_iterator_type<Container>&>());
+      decltype(*std::declval<reverse_iterator_type<T>&>());
 
+  template <typename T>
   using reverse_iterator_traits_deref =
-      std::remove_reference_t<reverse_iterator_deref>;
+      std::remove_reference_t<reverse_iterator_deref<T>>;
 
-  using reverse_iterator_arrow =
-      detail::arrow<reverse_iterator_type<Container>>;
+  template <typename T>
+  using reverse_iterator_arrow = detail::arrow<reverse_iterator_type<T>>;
 
  public:
   Reverser(Reverser&&) = default;
+  template <typename ContainerT>
   class Iterator : public std::iterator<std::input_iterator_tag,
-                       reverse_iterator_traits_deref> {
+                       reverse_iterator_traits_deref<ContainerT>> {
    private:
-    ReverseIteratorWrapper<Container> sub_iter_;
+    template <typename>
+    friend class Iterator;
+    ReverseIteratorWrapper<ContainerT> sub_iter_;
 
    public:
-    Iterator(ReverseIteratorWrapper<Container>&& sub_iter)
+    Iterator(ReverseIteratorWrapper<ContainerT>&& sub_iter)
         : sub_iter_{std::move(sub_iter)} {}
 
-    reverse_iterator_deref operator*() {
+    reverse_iterator_deref<ContainerT> operator*() {
       return *sub_iter_;
     }
 
-    reverse_iterator_arrow operator->() {
+    reverse_iterator_arrow<ContainerT> operator->() {
       return apply_arrow(sub_iter_);
     }
 
@@ -94,22 +101,32 @@ class iter::impl::Reverser {
       return ret;
     }
 
-    bool operator!=(const Iterator& other) const {
+    template <typename T>
+    bool operator!=(const Iterator<T>& other) const {
       return sub_iter_ != other.sub_iter_;
     }
 
-    bool operator==(const Iterator& other) const {
+    template <typename T>
+    bool operator==(const Iterator<T>& other) const {
       return !(*this != other);
     }
   };
 
-  Iterator begin() {
+  Iterator<Container> begin() {
     return {std::rbegin(container_)};
   }
 
-  Iterator end() {
+  Iterator<Container> end() {
     return {std::rend(container_)};
   }
+
+  Iterator<AsConst<Container>> begin() const {
+    return {std::rbegin(as_const(container_))};
+  }
+
+  Iterator<AsConst<Container>> end() const {
+    return {std::rend(as_const(container_))};
+  }
 };
 
 #endif

From 7e774a3ee21bba98761378e200ec682ecfa3325c Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 5 Oct 2017 14:58:25 -0500
Subject: [PATCH 1629/1866] Tests const iteration in sliding_window

---
 test/test_sliding_window.cpp | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/test/test_sliding_window.cpp b/test/test_sliding_window.cpp
index 21d93679..9c0b6a70 100644
--- a/test/test_sliding_window.cpp
+++ b/test/test_sliding_window.cpp
@@ -28,6 +28,23 @@ TEST_CASE("sliding_window: window of size 3", "[sliding_window]") {
   REQUIRE(v == vc);
 }
 
+TEST_CASE("sliding_window: const iteration", "[sliding_window][const]") {
+  Vec ns = {10, 20, 30, 40, 50};
+  std::vector<std::vector<int>> vc = {{10, 20, 30}, {20, 30, 40}, {30, 40, 50}};
+  std::vector<std::vector<int>> v;
+  const auto sw = sliding_window(ns, 3);
+  for (auto&& win : sw) {
+    v.emplace_back(std::begin(win), std::end(win));
+  }
+  REQUIRE(v == vc);
+}
+
+TEST_CASE("sliding_window: const iterators can be compared to non-const iterators", "[sliding_window][const]") {
+  auto sw = sliding_window(Vec{}, 2);
+  const auto& csw = sw;
+  (void)(std::begin(sw) == std::end(csw));
+}
+
 TEST_CASE("sliding_window: Works with different begin and end types",
     "[sliding_window]") {
   CharRange cr{'f'};

From dd5c6147913666bda3a4aef46ab50478f3e2928b Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 5 Oct 2017 14:58:43 -0500
Subject: [PATCH 1630/1866] Adds support for const iteration to sliding_window

---
 sliding_window.hpp | 43 ++++++++++++++++++++++++++++++-------------
 1 file changed, 30 insertions(+), 13 deletions(-)

diff --git a/sliding_window.hpp b/sliding_window.hpp
index 84c0e4b1..e8b2204d 100644
--- a/sliding_window.hpp
+++ b/sliding_window.hpp
@@ -29,19 +29,23 @@ class iter::impl::WindowSlider {
   WindowSlider(Container&& container, std::size_t win_sz)
       : container_(std::forward<Container>(container)), window_size_{win_sz} {}
 
-  using IndexVector = std::deque<IteratorWrapper<Container>>;
-  using DerefVec = IterIterWrapper<IndexVector>;
+  template <typename T>
+  using IndexVector = std::deque<IteratorWrapper<T>>;
+  template <typename T>
+  using DerefVec = IterIterWrapper<IndexVector<T>>;
 
  public:
   WindowSlider(WindowSlider&&) = default;
-  class Iterator : public std::iterator<std::input_iterator_tag, DerefVec> {
+  template <typename ContainerT>
+  class Iterator : public std::iterator<std::input_iterator_tag, DerefVec<ContainerT>> {
    private:
-    IteratorWrapper<Container> sub_iter_;
-    DerefVec window_;
+     template <typename> friend class Iterator;
+    IteratorWrapper<ContainerT> sub_iter_;
+    DerefVec<ContainerT> window_;
 
    public:
-    Iterator(IteratorWrapper<Container>&& sub_iter,
-        IteratorWrapper<Container>&& sub_end, std::size_t window_sz)
+    Iterator(IteratorWrapper<ContainerT>&& sub_iter,
+        IteratorWrapper<ContainerT>&& sub_end, std::size_t window_sz)
         : sub_iter_(std::move(sub_iter)) {
       std::size_t i{0};
       while (i < window_sz && sub_iter_ != sub_end) {
@@ -53,19 +57,21 @@ class iter::impl::WindowSlider {
       }
     }
 
-    bool operator!=(const Iterator& other) const {
+    template <typename T>
+    bool operator!=(const Iterator<T>& other) const {
       return sub_iter_ != other.sub_iter_;
     }
 
-    bool operator==(const Iterator& other) const {
+    template <typename T>
+    bool operator==(const Iterator<T>& other) const {
       return !(*this != other);
     }
 
-    DerefVec& operator*() {
+    DerefVec<ContainerT>& operator*() {
       return window_;
     }
 
-    DerefVec* operator->() {
+    DerefVec<ContainerT>* operator->() {
       return window_;
     }
 
@@ -83,16 +89,27 @@ class iter::impl::WindowSlider {
     }
   };
 
-  Iterator begin() {
+  Iterator<Container> begin() {
     return {
         (window_size_ != 0 ? IteratorWrapper<Container>{get_begin(container_)}
                            : IteratorWrapper<Container>{get_end(container_)}),
         get_end(container_), window_size_};
   }
 
-  Iterator end() {
+  Iterator<Container> end() {
     return {get_end(container_), get_end(container_), window_size_};
   }
+
+  Iterator<AsConst<Container>> begin() const {
+    return {
+        (window_size_ != 0 ? IteratorWrapper<AsConst<Container>>{get_begin(as_const(container_))}
+                           : IteratorWrapper<AsConst<Container>>{get_end(as_const(container_))}),
+        get_end(as_const(container_)), window_size_};
+  }
+
+  Iterator<AsConst<Container>> end() const {
+    return {get_end(as_const(container_)), get_end(as_const(container_)), window_size_};
+  }
 };
 
 #endif

From 826970713926d9eb0ebc70e98d9b830f021acbd3 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 5 Oct 2017 15:03:16 -0500
Subject: [PATCH 1631/1866] formatting

---
 sliding_window.hpp           | 16 ++++++++++------
 test/test_sliding_window.cpp |  4 +++-
 2 files changed, 13 insertions(+), 7 deletions(-)

diff --git a/sliding_window.hpp b/sliding_window.hpp
index e8b2204d..7c3135f5 100644
--- a/sliding_window.hpp
+++ b/sliding_window.hpp
@@ -37,9 +37,11 @@ class iter::impl::WindowSlider {
  public:
   WindowSlider(WindowSlider&&) = default;
   template <typename ContainerT>
-  class Iterator : public std::iterator<std::input_iterator_tag, DerefVec<ContainerT>> {
+  class Iterator
+      : public std::iterator<std::input_iterator_tag, DerefVec<ContainerT>> {
    private:
-     template <typename> friend class Iterator;
+    template <typename>
+    friend class Iterator;
     IteratorWrapper<ContainerT> sub_iter_;
     DerefVec<ContainerT> window_;
 
@@ -101,14 +103,16 @@ class iter::impl::WindowSlider {
   }
 
   Iterator<AsConst<Container>> begin() const {
-    return {
-        (window_size_ != 0 ? IteratorWrapper<AsConst<Container>>{get_begin(as_const(container_))}
-                           : IteratorWrapper<AsConst<Container>>{get_end(as_const(container_))}),
+    return {(window_size_ != 0 ? IteratorWrapper<AsConst<Container>>{get_begin(
+                                     as_const(container_))}
+                               : IteratorWrapper<AsConst<Container>>{get_end(
+                                     as_const(container_))}),
         get_end(as_const(container_)), window_size_};
   }
 
   Iterator<AsConst<Container>> end() const {
-    return {get_end(as_const(container_)), get_end(as_const(container_)), window_size_};
+    return {get_end(as_const(container_)), get_end(as_const(container_)),
+        window_size_};
   }
 };
 
diff --git a/test/test_sliding_window.cpp b/test/test_sliding_window.cpp
index 9c0b6a70..a302e1dc 100644
--- a/test/test_sliding_window.cpp
+++ b/test/test_sliding_window.cpp
@@ -39,7 +39,9 @@ TEST_CASE("sliding_window: const iteration", "[sliding_window][const]") {
   REQUIRE(v == vc);
 }
 
-TEST_CASE("sliding_window: const iterators can be compared to non-const iterators", "[sliding_window][const]") {
+TEST_CASE(
+    "sliding_window: const iterators can be compared to non-const iterators",
+    "[sliding_window][const]") {
   auto sw = sliding_window(Vec{}, 2);
   const auto& csw = sw;
   (void)(std::begin(sw) == std::end(csw));

From 9f6634999c777e7291c6ba29c8df23b937f36c58 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 5 Oct 2017 20:57:16 -0500
Subject: [PATCH 1632/1866] Makes IteratorIterators comparable to each other

---
 internal/iteratoriterator.hpp | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/internal/iteratoriterator.hpp b/internal/iteratoriterator.hpp
index 23bde9d5..70d63481 100644
--- a/internal/iteratoriterator.hpp
+++ b/internal/iteratoriterator.hpp
@@ -27,6 +27,7 @@ namespace iter {
         : public std::iterator<std::random_access_iterator_tag,
               typename std::remove_reference<decltype(
                   **std::declval<TopIter>())>::type> {
+      template <typename> friend class IteratorIterator;
       using Diff = std::ptrdiff_t;
       static_assert(
           std::is_same<
@@ -41,11 +42,17 @@ namespace iter {
       IteratorIterator() = default;
       IteratorIterator(const TopIter& it) : sub_iter{it} {}
 
-      bool operator==(const IteratorIterator& other) const {
+      const TopIter& get() const {
+        return sub_iter;
+      }
+
+      template <typename T>
+      bool operator==(const IteratorIterator<T>& other) const {
         return !(*this != other);
       }
 
-      bool operator!=(const IteratorIterator& other) const {
+      template <typename T>
+      bool operator!=(const IteratorIterator<T>& other) const {
         return this->sub_iter != other.sub_iter;
       }
 

From 441bc37e4107847b9313019387203fef27c03279 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 5 Oct 2017 20:59:48 -0500
Subject: [PATCH 1633/1866] Tests sorted with const iteration

---
 test/test_sorted.cpp | 17 ++++++++++++++++-
 1 file changed, 16 insertions(+), 1 deletion(-)

diff --git a/test/test_sorted.cpp b/test/test_sorted.cpp
index 054b1eda..930ca4f8 100644
--- a/test/test_sorted.cpp
+++ b/test/test_sorted.cpp
@@ -29,6 +29,21 @@ TEST_CASE("sorted: iterates through a vector in sorted order", "[sorted]") {
   REQUIRE(v == vc);
 }
 
+TEST_CASE("sorted: const iteration", "[sorted][const]") {
+  Vec ns = {4, 0, 5, 1, 6, 7, 9, 3, 2, 8};
+  const auto s = sorted(ns);
+  Vec v(std::begin(s), std::end(s));
+  Vec vc = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+  REQUIRE(v == vc);
+}
+
+TEST_CASE("sorted: const iterators can be compared to non-const iterators",
+    "[sorted][const]") {
+  auto s = sorted(Vec{});
+  const auto& cs = s;
+  (void)(std::begin(s) == std::end(cs));
+}
+
 TEST_CASE("sorted: can modify elements through sorted", "[sorted]") {
   std::vector<int> ns(3, 9);
   for (auto&& n : sorted(ns)) {
@@ -193,7 +208,7 @@ TEST_CASE("sorted: moves rvalues and binds to lvalues", "[sorted]") {
 TEST_CASE("sorted: doesn't move or copy elements of iterable", "[sorted]") {
   using itertest::SolidInt;
   constexpr SolidInt arr[] = {{6}, {7}, {8}};
-  for (auto &&i : sorted(arr, [](const SolidInt&lhs, const SolidInt&rhs) {
+  for (auto &&i : sorted(arr, [](const SolidInt &lhs, const SolidInt &rhs) {
          return lhs.getint() < rhs.getint();
        })) {
     (void)i;

From 320e72315096d4952018e96a1c5d696677cd867f Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 5 Oct 2017 21:06:02 -0500
Subject: [PATCH 1634/1866] Adds support for const iteration to sorted

---
 sorted.hpp | 140 +++++++++++++++++++++++++++++++++++++++++++++--------
 1 file changed, 119 insertions(+), 21 deletions(-)

diff --git a/sorted.hpp b/sorted.hpp
index d5fdf050..3554d893 100644
--- a/sorted.hpp
+++ b/sorted.hpp
@@ -20,38 +20,136 @@ namespace iter {
 template <typename Container, typename CompareFunc>
 class iter::impl::SortedView {
  private:
-  using IterIterWrap = IterIterWrapper<std::vector<iterator_type<Container>>>;
-  using ItIt = iterator_type<IterIterWrap>;
+  template <typename ContainerT, typename = void>
+  class SortedItersHolder {
+   public:
+    using IterIterWrap =
+        IterIterWrapper<std::vector<iterator_type<ContainerT>>>;
+    using ItIt = iterator_type<IterIterWrap>;
+    using ConstItIt = void;
+
+   private:
+    ContainerT container_;
+    IterIterWrap sorted_iters_;
+
+   public:
+    SortedItersHolder(ContainerT&& container, CompareFunc compare_func)
+        : container_(std::forward<ContainerT>(container)) {
+      // Fill the sorted_iters_ vector with an iterator to each
+      // element in the container_
+      for (auto iter = get_begin(container_); iter != get_end(container_);
+           ++iter) {
+        sorted_iters_.get().push_back(iter);
+      }
+
+      // sort by comparing the elements that the iterators point to
+      std::sort(get_begin(sorted_iters_.get()), get_end(sorted_iters_.get()),
+          [compare_func](iterator_type<Container> it1,
+                    iterator_type<Container> it2) {
+            return compare_func(*it1, *it2);
+          });
+    }
+
+    ItIt begin() {
+      return sorted_iters_.begin();
+    }
+
+    ItIt end() {
+      return sorted_iters_.end();
+    }
+  };
+
+  template <typename ContainerT>
+  class SortedItersHolder<ContainerT,
+      void_t<decltype(std::begin(std::declval<AsConst<ContainerT>&>()))>> {
+   public:
+    using IterIterWrap =
+        IterIterWrapper<std::vector<iterator_type<ContainerT>>>;
+    using ItIt = iterator_type<IterIterWrap>;
+
+    using ConstIterIterWrap =
+        IterIterWrapper<std::vector<iterator_type<AsConst<ContainerT>>>>;
+    using ConstItIt = iterator_type<AsConst<ConstIterIterWrap>>;
+
+   private:
+    ContainerT container_;
+    IterIterWrap sorted_iters_;
+    ConstIterIterWrap const_sorted_iters_;
+
+   public:
+    SortedItersHolder(ContainerT&& container, CompareFunc compare_func)
+        : container_(std::forward<ContainerT>(container)) {
+      // TODO sort lazily
+      // Fill the sorted_iters_ vector with an iterator to each
+      // element in the container_
+      for (auto iter = get_begin(container_); iter != get_end(container_);
+           ++iter) {
+        sorted_iters_.get().push_back(iter);
+      }
+
+      // sort by comparing the elements that the iterators point to
+      std::sort(get_begin(sorted_iters_.get()), get_end(sorted_iters_.get()),
+          [compare_func](iterator_type<ContainerT> it1,
+                    iterator_type<ContainerT> it2) {
+            return compare_func(*it1, *it2);
+          });
+
+      for (auto iter = get_begin(as_const(container_));
+           iter != get_end(as_const(container_)); ++iter) {
+        const_sorted_iters_.get().push_back(iter);
+      }
+
+      // sort by comparing the elements that the iterators point to
+      std::sort(get_begin(const_sorted_iters_.get()),
+          get_end(const_sorted_iters_.get()),
+          [compare_func](iterator_type<AsConst<ContainerT>> it1,
+                    iterator_type<AsConst<ContainerT>> it2) {
+            return compare_func(*it1, *it2);
+          });
+    }
+
+    ItIt begin() {
+      return sorted_iters_.begin();
+    }
+
+    ItIt end() {
+      return sorted_iters_.end();
+    }
+
+    ConstItIt begin() const {
+      return const_sorted_iters_.begin();
+    }
+
+    ConstItIt end() const {
+      return const_sorted_iters_.end();
+    }
+  };
 
   friend SortedFn;
 
-  Container container_;
-  IterIterWrap sorted_iters_;
+  SortedItersHolder<Container> sorted_iters_holder_;
 
   SortedView(Container&& container, CompareFunc compare_func)
-      : container_(std::forward<Container>(container)) {
-    // Fill the sorted_iters_ vector with an iterator to each
-    // element in the container_
-    for (auto iter = get_begin(container_); iter != get_end(container_);
-         ++iter) {
-      sorted_iters_.get().push_back(iter);
-    }
-
-    // sort by comparing the elements that the iterators point to
-    std::sort(get_begin(sorted_iters_.get()), get_end(sorted_iters_.get()),
-        [compare_func](iterator_type<Container> it1,
-            iterator_type<Container> it2) { return compare_func(*it1, *it2); });
-  }
+      : sorted_iters_holder_{
+            std::forward<Container>(container), std::move(compare_func)} {}
 
  public:
   SortedView(SortedView&&) = default;
 
-  ItIt begin() {
-    return get_begin(sorted_iters_);
+  typename SortedItersHolder<Container>::ItIt begin() {
+    return sorted_iters_holder_.begin();
+  }
+
+  typename SortedItersHolder<Container>::ItIt end() {
+    return sorted_iters_holder_.end();
+  }
+
+  typename SortedItersHolder<Container>::ConstItIt begin() const {
+    return sorted_iters_holder_.begin();
   }
 
-  ItIt end() {
-    return get_end(sorted_iters_);
+  typename SortedItersHolder<Container>::ConstItIt end() const {
+    return sorted_iters_holder_.end();
   }
 };
 

From 18ccc55f677ec8f295de66b213129e0e3c87cd37 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 5 Oct 2017 21:43:27 -0500
Subject: [PATCH 1635/1866] Test zip with const iteration

---
 test/test_zip.cpp | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/test/test_zip.cpp b/test/test_zip.cpp
index b0312e1e..0b039c14 100644
--- a/test/test_zip.cpp
+++ b/test/test_zip.cpp
@@ -28,6 +28,27 @@ TEST_CASE("zip: Simple case, same length", "[zip]") {
   REQUIRE(v == vc);
 }
 
+TEST_CASE("zip: const iteration", "[zip][const]") {
+  using Tu = std::tuple<int, char, double>;
+  using ResVec = const std::vector<Tu>;
+  std::vector<int> iv{10, 20, 30};
+  std::string s{"hey"};
+  double arr[] = {1.0, 2.0, 4.0};
+
+  const auto z = zip(iv, s, arr);
+  ResVec v(std::begin(z), std::end(z));
+  ResVec vc{Tu{10, 'h', 1.0}, Tu{20, 'e', 2.0}, Tu{30, 'y', 4.0}};
+  REQUIRE(v == vc);
+}
+
+TEST_CASE("zip: const iterators can be compared to non-const iterators", "[zip][const]") {
+  std::vector<int> v;
+  std::string s;
+  auto z = zip(v, s);
+  const auto& cz = z;
+  (void)(std::begin(z) == std::end(cz));
+}
+
 TEST_CASE(
     "zip: three sequences, one sequence has different begin and end", "[zip]") {
   using Tu = std::tuple<int, char, double>;

From c62dc0919e9dc2e795264fd48ad94254aa29fe45 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 5 Oct 2017 21:43:40 -0500
Subject: [PATCH 1636/1866] Adds support for const iteration to zip

---
 zip.hpp | 35 +++++++++++++++++++++++++----------
 1 file changed, 25 insertions(+), 10 deletions(-)

diff --git a/zip.hpp b/zip.hpp
index c5142cc4..ffad6663 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -29,18 +29,21 @@ class iter::impl::Zipped {
   friend Zipped iter::impl::zip_impl<TupleType, Is...>(
       TupleType&&, std::index_sequence<Is...>);
 
-  using ZipIterDeref = iterator_deref_tuple<TupleType>;
+  template <typename TupleTypeT>
+  using ZipIterDeref = iterator_deref_tuple<TupleTypeT>;
 
   Zipped(TupleType&& containers) : containers_(std::move(containers)) {}
 
  public:
   Zipped(Zipped&&) = default;
-  class Iterator : public std::iterator<std::input_iterator_tag, ZipIterDeref> {
+  template <typename TupleTypeT>
+  class Iterator : public std::iterator<std::input_iterator_tag, ZipIterDeref<TupleTypeT>> {
    private:
-    iterator_tuple_type<TupleType> iters_;
+    template <typename> friend class Iterator;
+    iterator_tuple_type<TupleTypeT> iters_;
 
    public:
-    Iterator(iterator_tuple_type<TupleType>&& iters)
+    Iterator(iterator_tuple_type<TupleTypeT>&& iters)
         : iters_(std::move(iters)) {}
 
     Iterator& operator++() {
@@ -54,7 +57,8 @@ class iter::impl::Zipped {
       return ret;
     }
 
-    bool operator!=(const Iterator& other) const {
+    template <typename T>
+    bool operator!=(const Iterator<T>& other) const {
       if (sizeof...(Is) == 0) return false;
 
       bool results[] = {
@@ -63,12 +67,13 @@ class iter::impl::Zipped {
           get_begin(results), get_end(results), [](bool b) { return b; });
     }
 
-    bool operator==(const Iterator& other) const {
+    template <typename T>
+    bool operator==(const Iterator<T>& other) const {
       return !(*this != other);
     }
 
-    ZipIterDeref operator*() {
-      return ZipIterDeref{(*std::get<Is>(iters_))...};
+    ZipIterDeref<TupleTypeT> operator*() {
+      return ZipIterDeref<TupleTypeT>{(*std::get<Is>(iters_))...};
     }
 
     auto operator-> () -> ArrowProxy<decltype(**this)> {
@@ -76,15 +81,25 @@ class iter::impl::Zipped {
     }
   };
 
-  Iterator begin() {
+  Iterator<TupleType> begin() {
     return {iterator_tuple_type<TupleType>{
         get_begin(std::get<Is>(containers_))...}};
   }
 
-  Iterator end() {
+  Iterator<TupleType> end() {
     return {
         iterator_tuple_type<TupleType>{get_end(std::get<Is>(containers_))...}};
   }
+
+  Iterator<AsConst<TupleType>> begin() const {
+    return {iterator_tuple_type<AsConst<TupleType>>{
+        get_begin(std::get<Is>(as_const(containers_)))...}};
+  }
+
+  Iterator<AsConst<TupleType>> end() const {
+    return {
+        iterator_tuple_type<AsConst<TupleType>>{get_end(std::get<Is>(as_const(containers_)))...}};
+  }
 };
 
 template <typename TupleType, std::size_t... Is>

From f9f595c01b5ff33ec24a947633a51994ce2c02ef Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 5 Oct 2017 21:43:54 -0500
Subject: [PATCH 1637/1866] Tests imap with const iteration

---
 test/test_imap.cpp | 18 ++++++++++++++++++
 zip.hpp            | 10 ++++++----
 2 files changed, 24 insertions(+), 4 deletions(-)

diff --git a/test/test_imap.cpp b/test/test_imap.cpp
index e7c2bcd2..db37d3f5 100644
--- a/test/test_imap.cpp
+++ b/test/test_imap.cpp
@@ -61,6 +61,24 @@ TEST_CASE("imap: works with lambda, callable, and function", "[imap]") {
   REQUIRE(v == vc);
 }
 
+// TODO enable once zip supports const
+#if 0
+TEST_CASE("imap: supports const iteration", "[imap][const]") {
+  Vec ns = {10, 20, 30};
+  const auto m = imap(PlusOner{}, ns);
+  Vec v(std::begin(m), std::end(m));
+  Vec vc = {11, 21, 31};
+  REQUIRE(v == vc);
+}
+
+TEST_CASE("imap: const iterators can be compared to non-const iterators", "[imap][const]") {
+  auto m = imap(PlusOner{}, Vec{});
+  const auto& cm = m;
+  (void)(std::begin(m) == std::end(cm));
+}
+#endif
+  
+
 TEST_CASE("imap: Works with different begin and end types", "[imap]") {
   CharRange cr{'d'};
   auto m = imap([](char c) { return std::toupper(c); }, cr);
diff --git a/zip.hpp b/zip.hpp
index ffad6663..5cf73135 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -37,9 +37,11 @@ class iter::impl::Zipped {
  public:
   Zipped(Zipped&&) = default;
   template <typename TupleTypeT>
-  class Iterator : public std::iterator<std::input_iterator_tag, ZipIterDeref<TupleTypeT>> {
+  class Iterator : public std::iterator<std::input_iterator_tag,
+                       ZipIterDeref<TupleTypeT>> {
    private:
-    template <typename> friend class Iterator;
+    template <typename>
+    friend class Iterator;
     iterator_tuple_type<TupleTypeT> iters_;
 
    public:
@@ -97,8 +99,8 @@ class iter::impl::Zipped {
   }
 
   Iterator<AsConst<TupleType>> end() const {
-    return {
-        iterator_tuple_type<AsConst<TupleType>>{get_end(std::get<Is>(as_const(containers_)))...}};
+    return {iterator_tuple_type<AsConst<TupleType>>{
+        get_end(std::get<Is>(as_const(containers_)))...}};
   }
 };
 

From 0d401eb459a21acbe117c48e6702e229de753871 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 5 Oct 2017 21:46:16 -0500
Subject: [PATCH 1638/1866] formatting

---
 test/test_zip.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/test/test_zip.cpp b/test/test_zip.cpp
index 0b039c14..7b18712c 100644
--- a/test/test_zip.cpp
+++ b/test/test_zip.cpp
@@ -41,7 +41,8 @@ TEST_CASE("zip: const iteration", "[zip][const]") {
   REQUIRE(v == vc);
 }
 
-TEST_CASE("zip: const iterators can be compared to non-const iterators", "[zip][const]") {
+TEST_CASE("zip: const iterators can be compared to non-const iterators",
+    "[zip][const]") {
   std::vector<int> v;
   std::string s;
   auto z = zip(v, s);

From f4c298db5437977f962ce182e36614ad0d9a07cb Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 6 Oct 2017 17:37:49 -0500
Subject: [PATCH 1639/1866] Tests zip with an rvalue right and const iteration

---
 test/test_zip.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/test/test_zip.cpp b/test/test_zip.cpp
index 7b18712c..74538cfa 100644
--- a/test/test_zip.cpp
+++ b/test/test_zip.cpp
@@ -36,6 +36,7 @@ TEST_CASE("zip: const iteration", "[zip][const]") {
   double arr[] = {1.0, 2.0, 4.0};
 
   const auto z = zip(iv, s, arr);
+
   ResVec v(std::begin(z), std::end(z));
   ResVec vc{Tu{10, 'h', 1.0}, Tu{20, 'e', 2.0}, Tu{30, 'y', 4.0}};
   REQUIRE(v == vc);
@@ -45,7 +46,7 @@ TEST_CASE("zip: const iterators can be compared to non-const iterators",
     "[zip][const]") {
   std::vector<int> v;
   std::string s;
-  auto z = zip(v, s);
+  auto z = zip(std::vector<int>{}, s);
   const auto& cz = z;
   (void)(std::begin(z) == std::end(cz));
 }

From 41e31a89260bc75dd39dbb6d3d0fe0e61ae7da20 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 6 Oct 2017 17:39:46 -0500
Subject: [PATCH 1640/1866] Fixes zip with const iteration

---
 internal/iter_tuples.hpp | 18 +++++++++++--
 zip.hpp                  | 56 +++++++++++++++++++++++-----------------
 2 files changed, 48 insertions(+), 26 deletions(-)

diff --git a/internal/iter_tuples.hpp b/internal/iter_tuples.hpp
index cfba2cf3..99fdfffe 100644
--- a/internal/iter_tuples.hpp
+++ b/internal/iter_tuples.hpp
@@ -10,12 +10,18 @@ namespace iter {
       template <typename... Ts>
       std::tuple<iterator_deref<Ts>...> iterator_tuple_deref_helper(
           const std::tuple<Ts...>&);
-    }
 
-    namespace detail {
       template <typename... Ts>
       std::tuple<IteratorWrapper<Ts>...> iterator_tuple_type_helper(
           const std::tuple<Ts...>&);
+
+      template <typename... Ts>
+      std::tuple<iterator_deref<const std::remove_reference_t<Ts>>...>
+      const_iterator_tuple_deref_helper(const std::tuple<Ts...>&);
+
+      template <typename... Ts>
+      std::tuple<IteratorWrapper<const std::remove_reference_t<Ts>>...>
+      const_iterator_tuple_type_helper(const std::tuple<Ts...>&);
     }
     // Given a tuple template argument, evaluates to a tuple of iterators
     // for the template argument's contained types.
@@ -23,6 +29,10 @@ namespace iter {
     using iterator_tuple_type =
         decltype(detail::iterator_tuple_type_helper(std::declval<TupleType>()));
 
+    template <typename TupleType>
+    using const_iterator_tuple_type = decltype(
+        detail::const_iterator_tuple_type_helper(std::declval<TupleType>()));
+
     // Given a tuple template argument, evaluates to a tuple of
     // what the iterators for the template argument's contained types
     // dereference to
@@ -30,6 +40,10 @@ namespace iter {
     using iterator_deref_tuple = decltype(
         detail::iterator_tuple_deref_helper(std::declval<TupleType>()));
 
+    template <typename TupleType>
+    using const_iterator_deref_tuple = decltype(
+        detail::const_iterator_tuple_deref_helper(std::declval<TupleType>()));
+
     // function absorbing all arguments passed to it. used when
     // applying a function to a parameter pack but not passing the evaluated
     // results anywhere
diff --git a/zip.hpp b/zip.hpp
index 5cf73135..7958234b 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -29,24 +29,26 @@ class iter::impl::Zipped {
   friend Zipped iter::impl::zip_impl<TupleType, Is...>(
       TupleType&&, std::index_sequence<Is...>);
 
-  template <typename TupleTypeT>
-  using ZipIterDeref = iterator_deref_tuple<TupleTypeT>;
-
   Zipped(TupleType&& containers) : containers_(std::move(containers)) {}
 
  public:
   Zipped(Zipped&&) = default;
-  template <typename TupleTypeT>
-  class Iterator : public std::iterator<std::input_iterator_tag,
-                       ZipIterDeref<TupleTypeT>> {
+
+  // template templates here because I need to defer evaluation in the const
+  // iteration case for types that don't have non-const begin() and end(). If I
+  // passed in the actual types of the tuples of iterators and the type for
+  // deref they'd need to be known in the function declarations below.
+  template <typename TupleTypeT, template <typename> class IteratorTuple,
+      template <typename> class TupleDeref>
+  class Iterator
+      : public std::iterator<std::input_iterator_tag, TupleDeref<TupleTypeT>> {
    private:
-    template <typename>
+    template <typename, template <typename> class, template <typename> class>
     friend class Iterator;
-    iterator_tuple_type<TupleTypeT> iters_;
+    IteratorTuple<TupleTypeT> iters_;
 
    public:
-    Iterator(iterator_tuple_type<TupleTypeT>&& iters)
-        : iters_(std::move(iters)) {}
+    Iterator(IteratorTuple<TupleTypeT>&& iters) : iters_(std::move(iters)) {}
 
     Iterator& operator++() {
       absorb(++std::get<Is>(iters_)...);
@@ -59,8 +61,9 @@ class iter::impl::Zipped {
       return ret;
     }
 
-    template <typename T>
-    bool operator!=(const Iterator<T>& other) const {
+    template <typename T, template <typename> class IT,
+        template <typename> class TD>
+    bool operator!=(const Iterator<T, IT, TD>& other) const {
       if (sizeof...(Is) == 0) return false;
 
       bool results[] = {
@@ -69,13 +72,14 @@ class iter::impl::Zipped {
           get_begin(results), get_end(results), [](bool b) { return b; });
     }
 
-    template <typename T>
-    bool operator==(const Iterator<T>& other) const {
+    template <typename T, template <typename> class IT,
+        template <typename> class TD>
+    bool operator==(const Iterator<T, IT, TD>& other) const {
       return !(*this != other);
     }
 
-    ZipIterDeref<TupleTypeT> operator*() {
-      return ZipIterDeref<TupleTypeT>{(*std::get<Is>(iters_))...};
+    TupleDeref<TupleTypeT> operator*() {
+      return TupleDeref<TupleTypeT>{(*std::get<Is>(iters_))...};
     }
 
     auto operator-> () -> ArrowProxy<decltype(**this)> {
@@ -83,24 +87,28 @@ class iter::impl::Zipped {
     }
   };
 
-  Iterator<TupleType> begin() {
+  Iterator<TupleType, iterator_tuple_type, iterator_deref_tuple> begin() {
     return {iterator_tuple_type<TupleType>{
         get_begin(std::get<Is>(containers_))...}};
   }
 
-  Iterator<TupleType> end() {
+  Iterator<TupleType, iterator_tuple_type, iterator_deref_tuple> end() {
     return {
         iterator_tuple_type<TupleType>{get_end(std::get<Is>(containers_))...}};
   }
 
-  Iterator<AsConst<TupleType>> begin() const {
-    return {iterator_tuple_type<AsConst<TupleType>>{
-        get_begin(std::get<Is>(as_const(containers_)))...}};
+  Iterator<AsConst<TupleType>, const_iterator_tuple_type,
+      const_iterator_deref_tuple>
+  begin() const {
+    return {const_iterator_tuple_type<AsConst<TupleType>>{
+        get_begin(as_const(std::get<Is>(containers_)))...}};
   }
 
-  Iterator<AsConst<TupleType>> end() const {
-    return {iterator_tuple_type<AsConst<TupleType>>{
-        get_end(std::get<Is>(as_const(containers_)))...}};
+  Iterator<AsConst<TupleType>, const_iterator_tuple_type,
+      const_iterator_deref_tuple>
+  end() const {
+    return {const_iterator_tuple_type<AsConst<TupleType>>{
+        get_end(as_const(std::get<Is>(containers_)))...}};
   }
 };
 

From 409daa57457e594fbd1f2053afa6eac3013dff41 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 6 Oct 2017 20:03:06 -0500
Subject: [PATCH 1641/1866] Tests zip_longst with const iteration

---
 test/test_zip_longest.cpp | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/test/test_zip_longest.cpp b/test/test_zip_longest.cpp
index 85b8ee31..be6091f5 100644
--- a/test/test_zip_longest.cpp
+++ b/test/test_zip_longest.cpp
@@ -97,6 +97,32 @@ TEST_CASE(
   REQUIRE(v == vc);
 }
 
+TEST_CASE("zip_longest: const iteration", "[zip_longest][const]") {
+  // using TP = const_opt_tuple</*int,*/ char>;
+  using TP = std::tuple<int, char>;
+  using ResVec = std::vector<TP>;
+
+  char cr[] = {'a', 'b'};
+
+  ResVec v;
+  const auto zl = zip_longest(std::vector<int>{10, 20}, cr);
+
+  for (auto&& p : zl) {
+    v.push_back(TP{*std::get<0>(p), *std::get<1>(p)});
+  }
+  ResVec vc{TP{10, 'a'}, TP{20, 'b'}};
+  REQUIRE(v == vc);
+}
+
+TEST_CASE("zip_longest: const iterators can be compared to non-const iterators",
+    "[zip_longest][const]") {
+  auto zl = zip_longest(std::vector<int>{});
+  const auto& czl = zl;
+  std::begin(zl);
+  std::begin(czl);
+  (void)(std::begin(zl) == std::end(czl));
+}
+
 TEST_CASE(
     "zip longest: when all are empty, terminates right away", "[zip_longest]") {
   const std::vector<int> ivec{};

From 59da248945848e2d126238c27a587f73db9561cf Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 6 Oct 2017 20:03:52 -0500
Subject: [PATCH 1642/1866] Adds support for const iteration to zip_longest

---
 internal/iterbase.hpp | 10 +++++++
 zip_longest.hpp       | 67 ++++++++++++++++++++++++++++++++-----------
 2 files changed, 60 insertions(+), 17 deletions(-)

diff --git a/internal/iterbase.hpp b/internal/iterbase.hpp
index 3ac7409f..2b0ec98d 100644
--- a/internal/iterbase.hpp
+++ b/internal/iterbase.hpp
@@ -74,6 +74,11 @@ namespace iter {
     template <typename Container>
     using iterator_type = decltype(get_begin(std::declval<Container&>()));
 
+    // iterator_type<C> is the type of C's iterator
+    template <typename Container>
+    using const_iterator_type = decltype(
+        get_begin(std::declval<const std::remove_reference_t<Container>&>()));
+
     // iterator_deref<C> is the type obtained by dereferencing an iterator
     // to an object of type C
     template <typename Container>
@@ -86,6 +91,11 @@ namespace iter {
     using const_iterator_deref =
         decltype(*std::declval<const iterator_type<Container>&>());
 
+    // the type of dereferencing a const_iterator
+    template <typename Container>
+    using const_iterator_type_deref =
+        decltype(*std::declval<const_iterator_type<Container>&>());
+
     template <typename Container>
     using iterator_traits_deref =
         std::remove_reference_t<iterator_deref<Container>>;
diff --git a/zip_longest.hpp b/zip_longest.hpp
index 00c15cbd..428751c0 100644
--- a/zip_longest.hpp
+++ b/zip_longest.hpp
@@ -30,24 +30,36 @@ class iter::impl::ZippedLongest {
   friend ZippedLongest zip_longest_impl<TupleType, Is...>(
       TupleType&&, std::index_sequence<Is...>);
 
-  template <std::size_t I>
-  using OptType =
-      boost::optional<iterator_deref<std::tuple_element_t<I, TupleType>>>;
+  template <std::size_t I, typename TupleTypeT>
+  using OptType = boost::optional<iterator_deref<std::tuple_element_t<I,
+      std::remove_reference_t<TupleTypeT>>>>;
 
-  using ZipIterDeref = std::tuple<OptType<Is>...>;
+  template <std::size_t I, typename TupleTypeT>
+  using ConstOptType =
+      boost::optional<const_iterator_type_deref<std::tuple_element_t<I,
+          std::remove_reference_t<TupleTypeT>>>>;
+
+  template <typename TupleTypeT,
+      template <std::size_t, typename> class OptTempl>
+  using ZipIterDeref = std::tuple<OptTempl<Is, TupleTypeT>...>;
 
   ZippedLongest(TupleType&& containers) : containers_(std::move(containers)) {}
 
  public:
   ZippedLongest(ZippedLongest&&) = default;
-  class Iterator : public std::iterator<std::input_iterator_tag, ZipIterDeref> {
+  template <typename TupleTypeT, template <typename> class IterTuple,
+      template <std::size_t, typename> class OptTempl>
+  class Iterator : public std::iterator<std::input_iterator_tag,
+                       ZipIterDeref<TupleTypeT, OptTempl>> {
    private:
-    iterator_tuple_type<TupleType> iters_;
-    iterator_tuple_type<TupleType> ends_;
+    template <typename, template <typename> class,
+        template <std::size_t, typename> class>
+    friend class Iterator;
+    IterTuple<TupleTypeT> iters_;
+    IterTuple<TupleTypeT> ends_;
 
    public:
-    Iterator(iterator_tuple_type<TupleType>&& iters,
-        iterator_tuple_type<TupleType>&& ends)
+    Iterator(IterTuple<TupleTypeT>&& iters, IterTuple<TupleTypeT>&& ends)
         : iters_(std::move(iters)), ends_(std::move(ends)) {}
 
     Iterator& operator++() {
@@ -65,7 +77,9 @@ class iter::impl::ZippedLongest {
       return ret;
     }
 
-    bool operator!=(const Iterator& other) const {
+    template <typename T, template <typename> class TT,
+        template <std::size_t, typename> class TU>
+    bool operator!=(const Iterator<T, TT, TU>& other) const {
       if (sizeof...(Is) == 0) return false;
 
       bool results[] = {
@@ -74,14 +88,17 @@ class iter::impl::ZippedLongest {
           get_begin(results), get_end(results), [](bool b) { return b; });
     }
 
-    bool operator==(const Iterator& other) const {
+    template <typename T, template <typename> class TT,
+        template <std::size_t, typename> class TU>
+    bool operator==(const Iterator<T, TT, TU>& other) const {
       return !(*this != other);
     }
 
-    ZipIterDeref operator*() {
-      return ZipIterDeref{((std::get<Is>(iters_) != std::get<Is>(ends_))
-                               ? OptType<Is>{*std::get<Is>(iters_)}
-                               : OptType<Is>{})...};
+    ZipIterDeref<TupleTypeT, OptTempl> operator*() {
+      return ZipIterDeref<TupleTypeT, OptTempl>{
+          ((std::get<Is>(iters_) != std::get<Is>(ends_))
+                  ? OptTempl<Is, TupleTypeT>{*std::get<Is>(iters_)}
+                  : OptTempl<Is, TupleTypeT>{})...};
     }
 
     auto operator-> () -> ArrowProxy<decltype(**this)> {
@@ -89,17 +106,33 @@ class iter::impl::ZippedLongest {
     }
   };
 
-  Iterator begin() {
+  Iterator<TupleType, iterator_tuple_type, OptType> begin() {
     return {
         iterator_tuple_type<TupleType>{get_begin(std::get<Is>(containers_))...},
         iterator_tuple_type<TupleType>{get_end(std::get<Is>(containers_))...}};
   }
 
-  Iterator end() {
+  Iterator<TupleType, iterator_tuple_type, OptType> end() {
     return {
         iterator_tuple_type<TupleType>{get_end(std::get<Is>(containers_))...},
         iterator_tuple_type<TupleType>{get_end(std::get<Is>(containers_))...}};
   }
+
+  Iterator<AsConst<TupleType>, const_iterator_tuple_type, ConstOptType> begin()
+      const {
+    return {const_iterator_tuple_type<AsConst<TupleType>>{
+                get_begin(as_const(std::get<Is>(containers_)))...},
+        const_iterator_tuple_type<AsConst<TupleType>>{
+            get_end(as_const(std::get<Is>(containers_)))...}};
+  }
+
+  Iterator<AsConst<TupleType>, const_iterator_tuple_type, ConstOptType> end()
+      const {
+    return {const_iterator_tuple_type<AsConst<TupleType>>{
+                get_end(as_const(std::get<Is>(containers_)))...},
+        const_iterator_tuple_type<AsConst<TupleType>>{
+            get_end(as_const(std::get<Is>(containers_)))...}};
+  }
 };
 
 template <typename TupleType, std::size_t... Is>

From 846f31231b5b97a528648d702ae94e92a77bb864 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 12 Oct 2017 11:33:46 -0500
Subject: [PATCH 1643/1866] Lazily evaluates sorted iterators.

This way if the sorted view is only used in a const or a non-const
context, but not both, it will only do the sorting for the one it needs.
---
 sorted.hpp | 38 +++++++++++++++++++++++++++-----------
 1 file changed, 27 insertions(+), 11 deletions(-)

diff --git a/sorted.hpp b/sorted.hpp
index 3554d893..fa6f7c19 100644
--- a/sorted.hpp
+++ b/sorted.hpp
@@ -69,17 +69,19 @@ class iter::impl::SortedView {
 
     using ConstIterIterWrap =
         IterIterWrapper<std::vector<iterator_type<AsConst<ContainerT>>>>;
-    using ConstItIt = iterator_type<AsConst<ConstIterIterWrap>>;
+    using ConstItIt = iterator_type<ConstIterIterWrap>;
 
    private:
     ContainerT container_;
+    mutable CompareFunc compare_func_;
     IterIterWrap sorted_iters_;
-    ConstIterIterWrap const_sorted_iters_;
+    mutable ConstIterIterWrap const_sorted_iters_;
 
-   public:
-    SortedItersHolder(ContainerT&& container, CompareFunc compare_func)
-        : container_(std::forward<ContainerT>(container)) {
-      // TODO sort lazily
+    void populate_sorted_iters() const = delete;
+    void populate_sorted_iters() {
+      if (!sorted_iters_.empty()) {
+        return;
+      }
       // Fill the sorted_iters_ vector with an iterator to each
       // element in the container_
       for (auto iter = get_begin(container_); iter != get_end(container_);
@@ -89,11 +91,16 @@ class iter::impl::SortedView {
 
       // sort by comparing the elements that the iterators point to
       std::sort(get_begin(sorted_iters_.get()), get_end(sorted_iters_.get()),
-          [compare_func](iterator_type<ContainerT> it1,
-                    iterator_type<ContainerT> it2) {
-            return compare_func(*it1, *it2);
+          [this](iterator_type<ContainerT> it1, iterator_type<ContainerT> it2) {
+            return compare_func_(*it1, *it2);
           });
+    }
 
+    void populate_const_sorted_iters() = delete;
+    void populate_const_sorted_iters() const {
+      if (!const_sorted_iters_.empty()) {
+        return;
+      }
       for (auto iter = get_begin(as_const(container_));
            iter != get_end(as_const(container_)); ++iter) {
         const_sorted_iters_.get().push_back(iter);
@@ -102,25 +109,34 @@ class iter::impl::SortedView {
       // sort by comparing the elements that the iterators point to
       std::sort(get_begin(const_sorted_iters_.get()),
           get_end(const_sorted_iters_.get()),
-          [compare_func](iterator_type<AsConst<ContainerT>> it1,
+          [this](iterator_type<AsConst<ContainerT>> it1,
                     iterator_type<AsConst<ContainerT>> it2) {
-            return compare_func(*it1, *it2);
+            return compare_func_(*it1, *it2);
           });
     }
 
+   public:
+    SortedItersHolder(ContainerT&& container, CompareFunc compare_func)
+        : container_(std::forward<ContainerT>(container)),
+          compare_func_(std::move(compare_func)) {}
+
     ItIt begin() {
+      populate_sorted_iters();
       return sorted_iters_.begin();
     }
 
     ItIt end() {
+      populate_sorted_iters();
       return sorted_iters_.end();
     }
 
     ConstItIt begin() const {
+      populate_const_sorted_iters();
       return const_sorted_iters_.begin();
     }
 
     ConstItIt end() const {
+      populate_const_sorted_iters();
       return const_sorted_iters_.end();
     }
   };

From 0c0f61b9a8bf37fdf9b6c29de920f2e18a0e3b72 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 15 Oct 2017 16:51:08 -0500
Subject: [PATCH 1644/1866] Tests combinations with const iteration

---
 test/test_combinations.cpp | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/test/test_combinations.cpp b/test/test_combinations.cpp
index 974b0798..f5c153cf 100644
--- a/test/test_combinations.cpp
+++ b/test/test_combinations.cpp
@@ -37,6 +37,28 @@ TEST_CASE("combinations: Simple combination of 4", "[combinations]") {
   REQUIRE(ans == sc);
 }
 
+TEST_CASE("combinations: const iteration", "[combinations][const]") {
+  std::string s{"ABCD"};
+  CharCombSet sc;
+  const auto comb = combinations(s, 2);
+  for (auto&& v : comb) {
+    sc.emplace_back(std::begin(v), std::end(v));
+  }
+
+  CharCombSet ans = {
+      {'A', 'B'}, {'A', 'C'}, {'A', 'D'}, {'B', 'C'}, {'B', 'D'}, {'C', 'D'}};
+  REQUIRE(ans == sc);
+}
+
+TEST_CASE(
+    "combinations: const iterators can be compared to non-const iterators",
+    "[combinations][const]") {
+  std::string s{"ABC"};
+  auto c = combinations(s, 2);
+  const auto& cc = c;
+  (void)(std::begin(c) == std::end(cc));
+}
+
 TEST_CASE("combinations: Works with different begin and end types",
     "[combinations]") {
   CharRange cr{'e'};

From 79280d25191cd2c9166ad2a4c668c5ab7439b08b Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 15 Oct 2017 16:51:27 -0500
Subject: [PATCH 1645/1866] Adds support for const iteration to combinations

---
 combinations.hpp | 41 ++++++++++++++++++++++++++++-------------
 1 file changed, 28 insertions(+), 13 deletions(-)

diff --git a/combinations.hpp b/combinations.hpp
index fe6c31ac..f32f00d5 100644
--- a/combinations.hpp
+++ b/combinations.hpp
@@ -29,21 +29,26 @@ class iter::impl::Combinator {
   Combinator(Container&& container, std::size_t length)
       : container_(std::forward<Container>(container)), length_{length} {}
 
-  using IndexVector = std::vector<iterator_type<Container>>;
-  using CombIteratorDeref = IterIterWrapper<IndexVector>;
+  template <typename T>
+  using IndexVector = std::vector<iterator_type<T>>;
+  template <typename T>
+  using CombIteratorDeref = IterIterWrapper<IndexVector<T>>;
 
  public:
   Combinator(Combinator&&) = default;
-  class Iterator
-      : public std::iterator<std::input_iterator_tag, CombIteratorDeref> {
+  template <typename ContainerT>
+  class Iterator : public std::iterator<std::input_iterator_tag,
+                       CombIteratorDeref<ContainerT>> {
    private:
+    template <typename>
+    friend class Iterator;
     constexpr static const int COMPLETE = -1;
-    std::remove_reference_t<Container>* container_p_;
-    CombIteratorDeref indices_;
+    std::remove_reference_t<ContainerT>* container_p_;
+    CombIteratorDeref<ContainerT> indices_;
     int steps_{};
 
    public:
-    Iterator(Container& container, std::size_t n)
+    Iterator(ContainerT& container, std::size_t n)
         : container_p_{&container}, indices_{n} {
       if (n == 0) {
         steps_ = COMPLETE;
@@ -63,11 +68,11 @@ class iter::impl::Combinator {
       }
     }
 
-    CombIteratorDeref& operator*() {
+    CombIteratorDeref<ContainerT>& operator*() {
       return indices_;
     }
 
-    CombIteratorDeref* operator->() {
+    CombIteratorDeref<ContainerT>* operator->() {
       return &indices_;
     }
 
@@ -111,22 +116,32 @@ class iter::impl::Combinator {
       return ret;
     }
 
-    bool operator!=(const Iterator& other) const {
+    template <typename T>
+    bool operator!=(const Iterator<T>& other) const {
       return !(*this == other);
     }
 
-    bool operator==(const Iterator& other) const {
+    template <typename T>
+    bool operator==(const Iterator<T>& other) const {
       return steps_ == other.steps_;
     }
   };
 
-  Iterator begin() {
+  Iterator<Container> begin() {
     return {container_, length_};
   }
 
-  Iterator end() {
+  Iterator<Container> end() {
     return {container_, 0};
   }
+
+  Iterator<AsConst<Container>> begin() const {
+    return {as_const(container_), length_};
+  }
+
+  Iterator<AsConst<Container>> end() const {
+    return {as_const(container_), 0};
+  }
 };
 
 #endif

From 54071024bfa2f3b024183433f84858a551959543 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 15 Oct 2017 17:01:21 -0500
Subject: [PATCH 1646/1866] Tests comb_w_repl with const iteration

---
 test/test_combinations_with_replacement.cpp | 23 +++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/test/test_combinations_with_replacement.cpp b/test/test_combinations_with_replacement.cpp
index 905450f5..61f30120 100644
--- a/test/test_combinations_with_replacement.cpp
+++ b/test/test_combinations_with_replacement.cpp
@@ -33,6 +33,29 @@ TEST_CASE("combinations_with_replacement: Simple combination",
   REQUIRE(ans == sc);
 }
 
+TEST_CASE("combinations_with_replacement: const iteration",
+    "[combinations_with_replacement]") {
+  std::string s{"ABC"};
+  CharCombSet sc;
+  const auto cwr = combinations_with_replacement(s, 2);
+  for (auto v : cwr) {
+    sc.emplace_back(std::begin(v), std::end(v));
+  }
+  CharCombSet ans = {
+      {'A', 'A'}, {'A', 'B'}, {'A', 'C'}, {'B', 'B'}, {'B', 'C'}, {'C', 'C'}};
+  REQUIRE(ans == sc);
+}
+
+TEST_CASE(
+    "combinations_with_replacement: const iterators can be compared to "
+    "non-const iterators",
+    "[combinations_with_replacement][const]") {
+  std::string s{"AB"};
+  auto cwr = combinations_with_replacement(s, 2);
+  const auto& ccwr = cwr;
+  (void)(std::begin(cwr) == std::end(ccwr));
+}
+
 TEST_CASE(
     "combinations_with_replacement: Works with different begin and end types",
     "[combinations_with_replacement]") {

From 83426af6d7cc46783154a84f88b178d329d930ed Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 15 Oct 2017 17:03:27 -0500
Subject: [PATCH 1647/1866] Adds support for const iteration to comb_w_repl

---
 combinations_with_replacement.hpp | 41 +++++++++++++++++++++----------
 1 file changed, 28 insertions(+), 13 deletions(-)

diff --git a/combinations_with_replacement.hpp b/combinations_with_replacement.hpp
index 0467147c..dab28c9a 100644
--- a/combinations_with_replacement.hpp
+++ b/combinations_with_replacement.hpp
@@ -29,32 +29,37 @@ class iter::impl::CombinatorWithReplacement {
   CombinatorWithReplacement(Container&& container, std::size_t n)
       : container_(std::forward<Container>(container)), length_{n} {}
 
-  using IndexVector = std::vector<iterator_type<Container>>;
-  using CombIteratorDeref = IterIterWrapper<IndexVector>;
+  template <typename T>
+  using IndexVector = std::vector<iterator_type<T>>;
+  template <typename T>
+  using CombIteratorDeref = IterIterWrapper<IndexVector<T>>;
 
  public:
   CombinatorWithReplacement(CombinatorWithReplacement&&) = default;
-  class Iterator
-      : public std::iterator<std::input_iterator_tag, CombIteratorDeref> {
+  template <typename ContainerT>
+  class Iterator : public std::iterator<std::input_iterator_tag,
+                       CombIteratorDeref<ContainerT>> {
    private:
+    template <typename>
+    friend class Iterator;
     constexpr static const int COMPLETE = -1;
-    std::remove_reference_t<Container>* container_p_;
-    CombIteratorDeref indices_;
+    std::remove_reference_t<ContainerT>* container_p_;
+    CombIteratorDeref<ContainerT> indices_;
     int steps_;
 
    public:
-    Iterator(Container& in_container, std::size_t n)
+    Iterator(ContainerT& in_container, std::size_t n)
         : container_p_{&in_container},
           indices_(n, get_begin(in_container)),
           steps_{(get_begin(in_container) != get_end(in_container) && n)
                      ? 0
                      : COMPLETE} {}
 
-    CombIteratorDeref& operator*() {
+    CombIteratorDeref<ContainerT>& operator*() {
       return indices_;
     }
 
-    CombIteratorDeref* operator->() {
+    CombIteratorDeref<ContainerT>* operator->() {
       return &indices_;
     }
 
@@ -90,22 +95,32 @@ class iter::impl::CombinatorWithReplacement {
       return ret;
     }
 
-    bool operator!=(const Iterator& other) const {
+    template <typename T>
+    bool operator!=(const Iterator<T>& other) const {
       return !(*this == other);
     }
 
-    bool operator==(const Iterator& other) const {
+    template <typename T>
+    bool operator==(const Iterator<T>& other) const {
       return steps_ == other.steps_;
     }
   };
 
-  Iterator begin() {
+  Iterator<Container> begin() {
     return {container_, length_};
   }
 
-  Iterator end() {
+  Iterator<Container> end() {
     return {container_, 0};
   }
+
+  Iterator<AsConst<Container>> begin() const {
+    return {as_const(container_), length_};
+  }
+
+  Iterator<AsConst<Container>> end() const {
+    return {as_const(container_), 0};
+  }
 };
 
 #endif

From 735a0ed3f38642c6ad8b10bea359e44688c22221 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 15 Oct 2017 17:14:18 -0500
Subject: [PATCH 1648/1866] Tests permutations with const iteration

---
 test/test_permutations.cpp | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/test/test_permutations.cpp b/test/test_permutations.cpp
index d07c6ffd..b6b6fdae 100644
--- a/test/test_permutations.cpp
+++ b/test/test_permutations.cpp
@@ -31,6 +31,27 @@ TEST_CASE("permutations: basic test, 3 element sequence", "[permutations]") {
   REQUIRE(v == vc);
 }
 
+TEST_CASE("permutations: const iteration", "[permutations][const]") {
+  const std::vector<int> ns = {1, 7, 9};
+
+  IntPermSet v;
+  const auto perm = permutations(ns);
+  for (auto&& st : perm) {
+    v.emplace(std::begin(st), std::end(st));
+  }
+  const IntPermSet vc = {
+      {1, 7, 9}, {1, 9, 7}, {7, 1, 9}, {7, 9, 1}, {9, 1, 7}, {9, 7, 1}};
+  REQUIRE(v == vc);
+}
+
+TEST_CASE(
+    "permutations: const iterators can be compared to non-const iteration",
+    "[permutations][const]") {
+  auto p = permutations(std::vector<int>{});
+  const auto& cp = p;
+  (void)(std::begin(p) == std::end(cp));
+}
+
 TEST_CASE("permutations: Works with different begin and end types",
     "[permutations]") {
   CharRange cr{'d'};

From e99c784fc0a296c02b7b37fe4b554e8f85be4f67 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 15 Oct 2017 17:14:59 -0500
Subject: [PATCH 1649/1866] Adds support for permutations with const iteration

---
 permutations.hpp | 44 ++++++++++++++++++++++++++++++--------------
 1 file changed, 30 insertions(+), 14 deletions(-)

diff --git a/permutations.hpp b/permutations.hpp
index 540ae62b..faae1fe2 100644
--- a/permutations.hpp
+++ b/permutations.hpp
@@ -26,8 +26,10 @@ class iter::impl::Permuter {
   friend PermutationsFn;
   Container container_;
 
-  using IndexVector = std::vector<IteratorWrapper<Container>>;
-  using Permutable = IterIterWrapper<IndexVector>;
+  template <typename T>
+  using IndexVector = std::vector<IteratorWrapper<T>>;
+  template <typename T>
+  using Permutable = IterIterWrapper<IndexVector<T>>;
 
   Permuter(Container&& container)
       : container_(std::forward<Container>(container)) {}
@@ -35,20 +37,24 @@ class iter::impl::Permuter {
  public:
   Permuter(Permuter&&) = default;
 
-  class Iterator : public std::iterator<std::input_iterator_tag, Permutable> {
+  template <typename ContainerT>
+  class Iterator
+      : public std::iterator<std::input_iterator_tag, Permutable<ContainerT>> {
    private:
+    template <typename>
+    friend class Iterator;
     static constexpr const int COMPLETE = -1;
-    static bool cmp_iters(IteratorWrapper<Container> lhs,
-        IteratorWrapper<Container> rhs) noexcept {
+    static bool cmp_iters(IteratorWrapper<ContainerT> lhs,
+        IteratorWrapper<ContainerT> rhs) noexcept {
       return *lhs < *rhs;
     }
 
-    Permutable working_set_;
+    Permutable<ContainerT> working_set_;
     int steps_{};
 
    public:
-    Iterator(IteratorWrapper<Container>&& sub_iter,
-        IteratorWrapper<Container>&& sub_end)
+    Iterator(IteratorWrapper<ContainerT>&& sub_iter,
+        IteratorWrapper<ContainerT>&& sub_end)
         : steps_{sub_iter != sub_end ? 0 : COMPLETE} {
       // done like this instead of using vector ctor with
       // two iterators because that causes a substitution
@@ -61,11 +67,11 @@ class iter::impl::Permuter {
           cmp_iters);
     }
 
-    Permutable& operator*() {
+    Permutable<ContainerT>& operator*() {
       return working_set_;
     }
 
-    Permutable* operator->() {
+    Permutable<ContainerT>* operator->() {
       return &working_set_;
     }
 
@@ -84,22 +90,32 @@ class iter::impl::Permuter {
       return ret;
     }
 
-    bool operator!=(const Iterator& other) const {
+    template <typename T>
+    bool operator!=(const Iterator<T>& other) const {
       return !(*this == other);
     }
 
-    bool operator==(const Iterator& other) const {
+    template <typename T>
+    bool operator==(const Iterator<T>& other) const {
       return steps_ == other.steps_;
     }
   };
 
-  Iterator begin() {
+  Iterator<Container> begin() {
     return {get_begin(container_), get_end(container_)};
   }
 
-  Iterator end() {
+  Iterator<Container> end() {
     return {get_end(container_), get_end(container_)};
   }
+
+  Iterator<AsConst<Container>> begin() const {
+    return {get_begin(as_const(container_)), get_end(as_const(container_))};
+  }
+
+  Iterator<AsConst<Container>> end() const {
+    return {get_end(as_const(container_)), get_end(as_const(container_))};
+  }
 };
 
 #endif

From e3c142a758d625cfc65b4f5e6f41cc5221819e62 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 15 Oct 2017 17:34:15 -0500
Subject: [PATCH 1650/1866] Tests powerset with const iteration

---
 test/test_powerset.cpp | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/test/test_powerset.cpp b/test/test_powerset.cpp
index cfc8515d..b56d43e0 100644
--- a/test/test_powerset.cpp
+++ b/test/test_powerset.cpp
@@ -32,6 +32,29 @@ TEST_CASE("powerset: basic test, [1, 2, 3]", "[powerset]") {
   REQUIRE(v == vc);
 }
 
+TEST_CASE("powerset: const iteration", "[powerset][const]") {
+  const std::vector<int> ns = {1, 2, 3};
+  IntPermSet v;
+  const auto ps = powerset(ns);
+  for (auto&& st : ps) {
+    v.emplace(std::begin(st), std::end(st));
+  }
+
+  const IntPermSet vc = {
+      std::multiset<int>{}, {1}, {2}, {3}, {1, 2}, {1, 3}, {2, 3}, {1, 2, 3}};
+  REQUIRE(v == vc);
+}
+
+// TODO this doesn't work because two different Powersetter::Iterator types use
+// two different Combinator types
+#if 0
+TEST_CASE("powerset: const iterators can be compared to non-const iterators", "[powerset][const]") {
+  auto ps = powerset(std::vector<int>{});
+  const auto& cps = ps;
+  (void)(std::begin(ps) == std::end(cps));
+}
+#endif
+
 TEST_CASE("powerset: Works with different begin and end types", "[powerset]") {
   CharRange cr{'d'};
   using CharPermSet = std::multiset<std::vector<char>>;

From 3041ccf2f0621830db0022a7161d1fbe04ae24f3 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 15 Oct 2017 17:34:30 -0500
Subject: [PATCH 1651/1866] Adds support for const iteration to powerset

You can't compare const iterators to non-const iterators due to the
issue described in the test_powerset.cpp TODO
---
 powerset.hpp | 53 ++++++++++++++++++++++++++++++++++++++--------------
 1 file changed, 39 insertions(+), 14 deletions(-)

diff --git a/powerset.hpp b/powerset.hpp
index 9c369e98..2997d569 100644
--- a/powerset.hpp
+++ b/powerset.hpp
@@ -25,7 +25,8 @@ template <typename Container>
 class iter::impl::Powersetter {
  private:
   Container container_;
-  using CombinatorType = decltype(combinations(std::declval<Container&>(), 0));
+  template <typename T>
+  using CombinatorType = decltype(combinations(std::declval<T&>(), 0));
 
   friend PowersetFn;
 
@@ -35,20 +36,25 @@ class iter::impl::Powersetter {
  public:
   Powersetter(Powersetter&&) = default;
 
-  class Iterator
-      : public std::iterator<std::input_iterator_tag, CombinatorType> {
+  template <typename ContainerT>
+  class Iterator : public std::iterator<std::input_iterator_tag,
+                       CombinatorType<ContainerT>> {
    private:
-    std::remove_reference_t<Container>* container_p_;
+#if 0
+    template <typename> friend class Iterator;
+#endif
+    std::remove_reference_t<ContainerT>* container_p_;
     std::size_t set_size_{};
-    std::shared_ptr<CombinatorType> comb_;
-    iterator_type<CombinatorType> comb_iter_;
-    iterator_type<CombinatorType> comb_end_;
+    std::shared_ptr<CombinatorType<ContainerT>> comb_;
+    iterator_type<CombinatorType<ContainerT>> comb_iter_;
+    iterator_type<CombinatorType<ContainerT>> comb_end_;
 
    public:
-    Iterator(Container& container, std::size_t sz)
+    Iterator(ContainerT& container, std::size_t sz)
         : container_p_{&container},
           set_size_{sz},
-          comb_{std::make_shared<CombinatorType>(combinations(container, sz))},
+          comb_{std::make_shared<CombinatorType<ContainerT>>(
+              combinations(container, sz))},
           comb_iter_{get_begin(*comb_)},
           comb_end_{get_end(*comb_)} {}
 
@@ -56,7 +62,7 @@ class iter::impl::Powersetter {
       ++comb_iter_;
       if (comb_iter_ == comb_end_) {
         ++set_size_;
-        comb_ = std::make_shared<CombinatorType>(
+        comb_ = std::make_shared<CombinatorType<ContainerT>>(
             combinations(*container_p_, set_size_));
 
         comb_iter_ = get_begin(*comb_);
@@ -71,11 +77,11 @@ class iter::impl::Powersetter {
       return ret;
     }
 
-    iterator_deref<CombinatorType> operator*() {
+    iterator_deref<CombinatorType<ContainerT>> operator*() {
       return *comb_iter_;
     }
 
-    iterator_arrow<CombinatorType> operator->() {
+    iterator_arrow<CombinatorType<ContainerT>> operator->() {
       apply_arrow(comb_iter_);
     }
 
@@ -86,15 +92,34 @@ class iter::impl::Powersetter {
     bool operator==(const Iterator& other) const {
       return set_size_ == other.set_size_ && comb_iter_ == other.comb_iter_;
     }
+#if 0
+    template <typename T>
+    bool operator!=(const Iterator<T>& other) const {
+      return !(*this == other);
+    }
+
+    template <typename T>
+    bool operator==(const Iterator<T>& other) const {
+      return set_size_ == other.set_size_ && comb_iter_ == other.comb_iter_;
+    }
+#endif
   };
 
-  Iterator begin() {
+  Iterator<Container> begin() {
     return {container_, 0};
   }
 
-  Iterator end() {
+  Iterator<Container> end() {
     return {container_, dumb_size(container_) + 1};
   }
+
+  Iterator<AsConst<Container>> begin() const {
+    return {as_const(container_), 0};
+  }
+
+  Iterator<AsConst<Container>> end() const {
+    return {as_const(container_), dumb_size(as_const(container_)) + 1};
+  }
 };
 
 #endif

From c41ef5a7cf7a5acfbd833c391f1ae8d5ec8e783e Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 15 Oct 2017 20:34:21 -0500
Subject: [PATCH 1652/1866] Tests unique_everseen with const iteration

---
 test/test_unique_everseen.cpp | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/test/test_unique_everseen.cpp b/test/test_unique_everseen.cpp
index 03bc6439..c34bb74d 100644
--- a/test/test_unique_everseen.cpp
+++ b/test/test_unique_everseen.cpp
@@ -20,6 +20,22 @@ TEST_CASE("unique everseen: adjacent repeating values", "[unique_everseen]") {
   REQUIRE(v == vc);
 }
 
+TEST_CASE("unique everseen: const iteration", "[unique_everseen][const]") {
+  Vec ns = {1, 1, 1, 2, 2, 3, 4, 4, 5, 6, 7, 8, 8, 8, 8, 9, 9};
+  const auto ue = unique_everseen(ns);
+  Vec v(std::begin(ue), std::end(ue));
+  Vec vc = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+  REQUIRE(v == vc);
+}
+
+TEST_CASE(
+    "unique everseen: const iterators can be compared to non-const iterators",
+    "[unique_everseen][const]") {
+  auto ue = unique_everseen(std::vector<int>{});
+  const auto& cue = ue;
+  (void)(std::begin(ue) == std::end(cue));
+}
+
 TEST_CASE(
     "unique everseen: nonadjacent repeating values", "[unique_everseen]") {
   Vec ns = {1, 2, 3, 4, 3, 2, 1, 5, 6};

From aa411cccbe530d953ac96caf1c1b951c74ca5c52 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 15 Oct 2017 20:34:35 -0500
Subject: [PATCH 1653/1866] Fixes const reference build

can't do const T&, needs const std::remove_reference_t<T>&
The intricacies of this aliasing will never cease to hurt me.
---
 unique_everseen.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/unique_everseen.hpp b/unique_everseen.hpp
index 3db10b99..35322ca8 100644
--- a/unique_everseen.hpp
+++ b/unique_everseen.hpp
@@ -17,7 +17,7 @@ namespace iter {
       auto operator()(Container&& container) const {
         using elem_type = impl::iterator_deref<Container>;
         auto func = [elem_seen = std::unordered_set<std::decay_t<elem_type>>()](
-            const elem_type& e) mutable {
+            const std::remove_reference_t<elem_type>& e) mutable {
           return elem_seen.insert(e).second;
         };
         return filter(func, std::forward<Container>(container));

From fd53ed368cc63a7c91dd29e1187e046963c42db8 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 15 Oct 2017 21:02:33 -0500
Subject: [PATCH 1654/1866] Tests groupby with const iteration

---
 test/test_groupby.cpp | 47 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 47 insertions(+)

diff --git a/test/test_groupby.cpp b/test/test_groupby.cpp
index cc1b824a..1089f210 100644
--- a/test/test_groupby.cpp
+++ b/test/test_groupby.cpp
@@ -69,6 +69,53 @@ TEST_CASE("groupby: works with lambda, callable, and function pointer") {
   REQUIRE(groups == gc);
 }
 
+TEST_CASE("groupby: const iteration", "[groupby][const]") {
+  std::vector<int> keys;
+  std::vector<std::vector<std::string>> groups;
+
+  SECTION("Function pointer") {
+    SECTION("lvalue") {
+      const auto g = groupby(vec, length);
+      for (auto&& gb : g) {
+        keys.push_back(gb.first);
+        groups.emplace_back(std::begin(gb.second), std::end(gb.second));
+      }
+    }
+    SECTION("rvalue") {
+      const auto g = groupby(std::vector<std::string>(vec), length);
+      for (auto&& gb : g) {
+        keys.push_back(gb.first);
+        groups.emplace_back(std::begin(gb.second), std::end(gb.second));
+      }
+    }
+  }
+
+  SECTION("Callable object") {
+    const auto g = groupby(vec, Sizer{});
+    for (auto&& gb : g) {
+      keys.push_back(gb.first);
+      groups.emplace_back(std::begin(gb.second), std::end(gb.second));
+    }
+  }
+
+  SECTION("lambda function") {
+    const auto g = groupby(vec, [](const std::string& s) { return s.size(); });
+    for (auto&& gb : g) {
+      keys.push_back(gb.first);
+      groups.emplace_back(std::begin(gb.second), std::end(gb.second));
+    }
+  }
+
+  const std::vector<int> kc = {2, 3, 5};
+  REQUIRE(keys == kc);
+
+  const std::vector<std::vector<std::string>> gc = {
+      {"hi", "ab", "ho"}, {"abc", "def"}, {"abcde", "efghi"},
+  };
+
+  REQUIRE(groups == gc);
+}
+
 TEST_CASE("groupby: Works with different begin and end types", "[groupby]") {
   CharRange cr{'f'};
   std::vector<bool> keys;

From 52764e47a1bad69d881194f9c95dd132376e7588 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 15 Oct 2017 21:03:36 -0500
Subject: [PATCH 1655/1866] Supports const iteration in groupby

---
 groupby.hpp | 85 ++++++++++++++++++++++++++++++++++-------------------
 1 file changed, 54 insertions(+), 31 deletions(-)

diff --git a/groupby.hpp b/groupby.hpp
index 1a06e60f..5bc555f0 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -32,11 +32,12 @@ template <typename Container, typename KeyFunc>
 class iter::impl::GroupProducer {
  private:
   Container container_;
-  KeyFunc key_func_;
+  mutable KeyFunc key_func_;
 
   friend GroupByFn;
 
-  using key_func_ret = std::result_of_t<KeyFunc(iterator_deref<Container>)>;
+  template <typename T>
+  using key_func_ret = std::result_of_t<KeyFunc(iterator_deref<T>)>;
 
   GroupProducer(Container&& container, KeyFunc key_func)
       : container_(std::forward<Container>(container)), key_func_(key_func) {}
@@ -44,25 +45,31 @@ class iter::impl::GroupProducer {
  public:
   GroupProducer(GroupProducer&&) = default;
 
+  template <typename T>
   class Iterator;
+  template <typename T>
   class Group;
 
  private:
-  using KeyGroupPair = std::pair<key_func_ret, Group>;
-  using Holder = DerefHolder<iterator_deref<Container>>;
+  template <typename T>
+  using KeyGroupPair = std::pair<key_func_ret<T>, Group<T>>;
+  template <typename T>
+  using Holder = DerefHolder<iterator_deref<T>>;
 
  public:
-  class Iterator : public std::iterator<std::input_iterator_tag, KeyGroupPair> {
+  template <typename ContainerT>
+  class Iterator : public std::iterator<std::input_iterator_tag,
+                       KeyGroupPair<ContainerT>> {
    private:
-    IteratorWrapper<Container> sub_iter_;
-    IteratorWrapper<Container> sub_end_;
-    Holder item_;
+    IteratorWrapper<ContainerT> sub_iter_;
+    IteratorWrapper<ContainerT> sub_end_;
+    Holder<ContainerT> item_;
     KeyFunc* key_func_;
-    std::unique_ptr<KeyGroupPair> current_key_group_pair_;
+    std::unique_ptr<KeyGroupPair<ContainerT>> current_key_group_pair_;
 
    public:
-    Iterator(IteratorWrapper<Container>&& sub_iter,
-        IteratorWrapper<Container>&& sub_end, KeyFunc& key_func)
+    Iterator(IteratorWrapper<ContainerT>&& sub_iter,
+        IteratorWrapper<ContainerT>&& sub_end, KeyFunc& key_func)
         : sub_iter_{std::move(sub_iter)},
           sub_end_{std::move(sub_end)},
           key_func_(&key_func) {
@@ -94,12 +101,12 @@ class iter::impl::GroupProducer {
     // NOTE the implicitly generated move constructor would
     // be wrong
 
-    KeyGroupPair& operator*() {
+    KeyGroupPair<ContainerT>& operator*() {
       set_key_group_pair();
       return *current_key_group_pair_;
     }
 
-    KeyGroupPair* operator->() {
+    KeyGroupPair<ContainerT>* operator->() {
       set_key_group_pair();
       return current_key_group_pair_.get();
     }
@@ -118,6 +125,7 @@ class iter::impl::GroupProducer {
       return ret;
     }
 
+    // TODO template
     bool operator!=(const Iterator& other) const {
       return sub_iter_ != other.sub_iter_;
     }
@@ -139,32 +147,34 @@ class iter::impl::GroupProducer {
       return !(sub_iter_ != sub_end_);
     }
 
-    typename Holder::reference get() {
+    typename Holder<ContainerT>::reference get() {
       return item_.get();
     }
 
-    typename Holder::pointer get_ptr() {
+    typename Holder<ContainerT>::pointer get_ptr() {
       return item_.get_ptr();
     }
 
-    key_func_ret next_key() {
+    key_func_ret<ContainerT> next_key() {
       return (*key_func_)(item_.get());
     }
 
     void set_key_group_pair() {
       if (!current_key_group_pair_) {
-        current_key_group_pair_ = std::make_unique<KeyGroupPair>(
-            (*key_func_)(item_.get()), Group{*this, next_key()});
+        current_key_group_pair_ = std::make_unique<KeyGroupPair<ContainerT>>(
+            (*key_func_)(item_.get()), Group<ContainerT>{*this, next_key()});
       }
     }
   };
 
+  template <typename ContainerT>
   class Group {
    private:
-    friend Iterator;
+    template <typename>
+    friend class Iterator;
     friend class GroupIterator;
-    Iterator& owner_;
-    key_func_ret key_;
+    Iterator<ContainerT>& owner_;
+    key_func_ret<ContainerT> key_;
 
     // completed is set if a Group is iterated through
     // completely.  It is checked in the destructor, and
@@ -177,7 +187,8 @@ class iter::impl::GroupProducer {
     // when called.
     bool completed = false;
 
-    Group(Iterator& owner, key_func_ret key) : owner_(owner), key_(key) {}
+    Group(Iterator<ContainerT>& owner, key_func_ret<ContainerT> key)
+        : owner_(owner), key_(key) {}
 
    public:
     ~Group() {
@@ -188,15 +199,16 @@ class iter::impl::GroupProducer {
     }
 
     // move-constructible, non-copy-constructible, non-assignable
-    Group(Group&& other) noexcept
-        : owner_(other.owner_), key_{other.key_}, completed{other.completed} {
+    Group(Group&& other) noexcept : owner_(other.owner_),
+                                    key_{other.key_},
+                                    completed{other.completed} {
       other.completed = true;
     }
 
     class GroupIterator : public std::iterator<std::input_iterator_tag,
-                              iterator_traits_deref<Container>> {
+                              iterator_traits_deref<ContainerT>> {
      private:
-      std::remove_reference_t<key_func_ret>* key_;
+      std::remove_reference_t<key_func_ret<ContainerT>>* key_;
       Group* group_p_;
 
       bool not_at_end() {
@@ -205,7 +217,8 @@ class iter::impl::GroupProducer {
       }
 
      public:
-      GroupIterator(Group* group_p, key_func_ret& key)
+      // TODO template this? idk if it's relevant here
+      GroupIterator(Group* group_p, key_func_ret<ContainerT>& key)
           : key_{&key}, group_p_{group_p} {}
 
       bool operator!=(const GroupIterator& other) const {
@@ -231,11 +244,11 @@ class iter::impl::GroupProducer {
         return ret;
       }
 
-      iterator_deref<Container> operator*() {
+      iterator_deref<ContainerT> operator*() {
         return group_p_->owner_.get();
       }
 
-      typename Holder::pointer operator->() {
+      typename Holder<ContainerT>::pointer operator->() {
         return group_p_->owner_.get_ptr();
       }
     };
@@ -249,13 +262,23 @@ class iter::impl::GroupProducer {
     }
   };
 
-  Iterator begin() {
+  Iterator<Container> begin() {
     return {get_begin(container_), get_end(container_), key_func_};
   }
 
-  Iterator end() {
+  Iterator<Container> end() {
     return {get_end(container_), get_end(container_), key_func_};
   }
+
+  Iterator<AsConst<Container>> begin() const {
+    return {get_begin(as_const(container_)), get_end(as_const(container_)),
+        key_func_};
+  }
+
+  Iterator<AsConst<Container>> end() const {
+    return {get_end(as_const(container_)), get_end(as_const(container_)),
+        key_func_};
+  }
 };
 
 #endif

From 923cd77b3f5c17578ae3dbe89e341767d9f44730 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 15 Oct 2017 21:17:56 -0500
Subject: [PATCH 1656/1866] Tests groupby const and nonconst iterators compare

---
 test/test_groupby.cpp | 20 +++++++++++++++++++-
 1 file changed, 19 insertions(+), 1 deletion(-)

diff --git a/test/test_groupby.cpp b/test/test_groupby.cpp
index 1089f210..d6d508fa 100644
--- a/test/test_groupby.cpp
+++ b/test/test_groupby.cpp
@@ -75,7 +75,8 @@ TEST_CASE("groupby: const iteration", "[groupby][const]") {
 
   SECTION("Function pointer") {
     SECTION("lvalue") {
-      const auto g = groupby(vec, length);
+      std::vector<std::string> local_vec(vec);
+      const auto g = groupby(local_vec, length);
       for (auto&& gb : g) {
         keys.push_back(gb.first);
         groups.emplace_back(std::begin(gb.second), std::end(gb.second));
@@ -116,6 +117,23 @@ TEST_CASE("groupby: const iteration", "[groupby][const]") {
   REQUIRE(groups == gc);
 }
 
+TEST_CASE("groupby: iterators compare equal to non-const iterators",
+    "[groupby][const]") {
+  auto gb = groupby(std::vector<std::string>{"hi"}, length);
+  const auto& cgb = gb;
+
+  auto gb_it = std::begin(gb);
+  (void)(gb_it == std::end(cgb));
+
+// TODO figure out how to make GroupIterator<Container> and
+// GroupIterator<AsConst<Container>> comparable
+#if 0
+  auto group = std::begin(gb_it->second);
+  const auto& cgroup = group;
+  (void)(std::begin(group) == std::begin(cgroup));
+#endif
+}
+
 TEST_CASE("groupby: Works with different begin and end types", "[groupby]") {
   CharRange cr{'f'};
   std::vector<bool> keys;

From 34f373d7f71135add8c72d093610c30ae2de9379 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 15 Oct 2017 21:18:54 -0500
Subject: [PATCH 1657/1866] Supports const iter == non-const iter

---
 groupby.hpp | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/groupby.hpp b/groupby.hpp
index 5bc555f0..f25d145b 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -61,6 +61,8 @@ class iter::impl::GroupProducer {
   class Iterator : public std::iterator<std::input_iterator_tag,
                        KeyGroupPair<ContainerT>> {
    private:
+    template <typename>
+    friend class Iterator;
     IteratorWrapper<ContainerT> sub_iter_;
     IteratorWrapper<ContainerT> sub_end_;
     Holder<ContainerT> item_;
@@ -125,12 +127,13 @@ class iter::impl::GroupProducer {
       return ret;
     }
 
-    // TODO template
-    bool operator!=(const Iterator& other) const {
+    template <typename T>
+    bool operator!=(const Iterator<T>& other) const {
       return sub_iter_ != other.sub_iter_;
     }
 
-    bool operator==(const Iterator& other) const {
+    template <typename T>
+    bool operator==(const Iterator<T>& other) const {
       return !(*this != other);
     }
 

From 7d4349b197c758a6b4f8676ba5049f659a4d83e9 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 15 Oct 2017 21:37:56 -0500
Subject: [PATCH 1658/1866] Tests unique_justseen with const iteration

---
 test/test_unique_justseen.cpp | 18 +++++++++++++++++-
 1 file changed, 17 insertions(+), 1 deletion(-)

diff --git a/test/test_unique_justseen.cpp b/test/test_unique_justseen.cpp
index 3d7dabc7..2614aa89 100644
--- a/test/test_unique_justseen.cpp
+++ b/test/test_unique_justseen.cpp
@@ -10,7 +10,7 @@
 
 using iter::unique_justseen;
 
-using Vec = const std::vector<int>;
+using Vec = std::vector<int>;
 
 TEST_CASE("unique justseen: adjacent repeating values", "[unique_justseen]") {
   Vec ns = {1, 1, 1, 2, 2, 3, 4, 4, 5, 6, 7, 8, 8, 8, 8, 9, 9};
@@ -20,6 +20,22 @@ TEST_CASE("unique justseen: adjacent repeating values", "[unique_justseen]") {
   REQUIRE(v == vc);
 }
 
+TEST_CASE("unique justseen: const iteration", "[unique_justseen][const]") {
+  Vec ns = {1, 1, 1, 2, 2, 3, 4, 4, 5, 6, 7, 8, 8, 8, 8, 9, 9};
+  const auto uj = unique_justseen(ns);
+  Vec v(std::begin(uj), std::end(uj));
+  Vec vc = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+  REQUIRE(v == vc);
+}
+
+TEST_CASE(
+    "unique justseen: const iterator can be compared to non-const iterators",
+    "[unique_justseen][const]") {
+  auto uj = unique_justseen(Vec{});
+  const auto& cuj = uj;
+  (void)(std::begin(uj) == std::begin(cuj));
+}
+
 TEST_CASE("unique justseen: some repeating values", "[unique_justseen]") {
   Vec ns = {1, 2, 2, 3, 4, 4, 5, 6, 6};
   std::vector<int> v;

From dc392622b6fc9aa0bc2da8ec5fdb358201205a94 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 15 Oct 2017 21:38:12 -0500
Subject: [PATCH 1659/1866] Supports for const iteration to unique_justseen

---
 unique_justseen.hpp | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/unique_justseen.hpp b/unique_justseen.hpp
index 5e5e3170..2d63b7ea 100644
--- a/unique_justseen.hpp
+++ b/unique_justseen.hpp
@@ -12,11 +12,9 @@ namespace iter {
     struct UniqueJustseenFn : Pipeable<UniqueJustseenFn> {
       template <typename Container>
       auto operator()(Container&& container) const {
-        // explicit return type in lambda so reference types are preserved
-        return imap(
-            [](auto&& group) -> impl::iterator_deref<Container> {
-              return *get_begin(group.second);
-            },
+        // decltype(auto) return type in lambda so reference types are preserved
+        return imap([](auto&& group) -> decltype(
+                        auto) { return *get_begin(group.second); },
             groupby(std::forward<Container>(container)));
       }
     };

From 9d177cc29a6352c84e8aae36915aa2f897e363e6 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 16 Oct 2017 12:11:13 -0500
Subject: [PATCH 1660/1866] Tests const iteration of product

---
 test/test_product.cpp | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/test/test_product.cpp b/test/test_product.cpp
index 5f7e701d..d7c113d9 100644
--- a/test/test_product.cpp
+++ b/test/test_product.cpp
@@ -30,6 +30,29 @@ TEST_CASE("product: basic test, two sequences", "[product]") {
   REQUIRE(v == vc);
 }
 
+TEST_CASE("product: const iteration", "[product][const]") {
+  using TP = std::tuple<int, char>;
+  using ResType = std::vector<TP>;
+
+  Vec n1 = {0, 1};
+  const std::string s{"abc"};
+
+  const auto p = product(n1, s);
+  ResType v(std::begin(p), std::end(p));
+  ResType vc = {
+      TP{0, 'a'}, TP{0, 'b'}, TP{0, 'c'}, TP{1, 'a'}, TP{1, 'b'}, TP{1, 'c'}};
+
+  REQUIRE(v == vc);
+}
+
+TEST_CASE("product: const iterators can be compared to non-const iterators",
+    "[product][const]") {
+  std::string s;
+  auto p = product(Vec{}, s);
+  const auto& cp = p;
+  (void)(std::begin(p) == std::end(cp));
+}
+
 TEST_CASE("product: two sequences where one has different begin and end",
     "[product]") {
   using TP = std::tuple<int, char>;

From eaa08e0e3ac281e36900ef712c41a7e8ee1cce18 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 16 Oct 2017 12:12:33 -0500
Subject: [PATCH 1661/1866] Supports const iteration in product

---
 product.hpp | 62 ++++++++++++++++++++++++++++++++++++++++-------------
 1 file changed, 47 insertions(+), 15 deletions(-)

diff --git a/product.hpp b/product.hpp
index 6a8c9bbe..941eddae 100644
--- a/product.hpp
+++ b/product.hpp
@@ -34,8 +34,9 @@ class iter::impl::Productor<Container, RestContainers...> {
   template <typename... RC>
   friend class Productor;
 
+  template <typename T>
   using ProdIterDeref =
-      std::tuple<iterator_deref<Container>, iterator_deref<RestContainers>...>;
+      std::tuple<iterator_deref<T>, iterator_deref<RestContainers>...>;
 
  private:
   Container container_;
@@ -46,20 +47,23 @@ class iter::impl::Productor<Container, RestContainers...> {
 
  public:
   Productor(Productor&&) = default;
-  class Iterator
-      : public std::iterator<std::input_iterator_tag, ProdIterDeref> {
-   private:
-    using RestIter = typename Productor<RestContainers...>::Iterator;
 
-    IteratorWrapper<Container> sub_iter_;
-    IteratorWrapper<Container> sub_begin_;
+ private:
+  template <typename ContainerT, typename RestIter>
+  class IteratorTempl : public std::iterator<std::input_iterator_tag,
+                            ProdIterDeref<ContainerT>> {
+   private:
+    template <typename, typename>
+    friend class IteratorTempl;
+    IteratorWrapper<ContainerT> sub_iter_;
+    IteratorWrapper<ContainerT> sub_begin_;
 
     RestIter rest_iter_;
     RestIter rest_end_;
 
    public:
     constexpr static const bool is_base_iter = false;
-    Iterator(IteratorWrapper<Container>&& sub_iter, RestIter&& rest_iter,
+    IteratorTempl(IteratorWrapper<ContainerT>&& sub_iter, RestIter&& rest_iter,
         RestIter&& rest_end)
         : sub_iter_{sub_iter},
           sub_begin_{sub_iter},
@@ -70,7 +74,7 @@ class iter::impl::Productor<Container, RestContainers...> {
       sub_iter_ = sub_begin_;
     }
 
-    Iterator& operator++() {
+    IteratorTempl& operator++() {
       ++rest_iter_;
       if (!(rest_iter_ != rest_end_)) {
         rest_iter_.reset();
@@ -79,31 +83,40 @@ class iter::impl::Productor<Container, RestContainers...> {
       return *this;
     }
 
-    Iterator operator++(int) {
+    IteratorTempl operator++(int) {
       auto ret = *this;
       ++*this;
       return ret;
     }
 
-    bool operator!=(const Iterator& other) const {
+    template <typename T, typename U>
+    bool operator!=(const IteratorTempl<T, U>& other) const {
       return sub_iter_ != other.sub_iter_
              && (RestIter::is_base_iter || rest_iter_ != other.rest_iter_);
     }
 
-    bool operator==(const Iterator& other) const {
+    template <typename T, typename U>
+    bool operator==(const IteratorTempl<T, U>& other) const {
       return !(*this != other);
     }
 
-    ProdIterDeref operator*() {
+    ProdIterDeref<ContainerT> operator*() {
       return std::tuple_cat(
-          std::tuple<iterator_deref<Container>>{*sub_iter_}, *rest_iter_);
+          std::tuple<iterator_deref<ContainerT>>{*sub_iter_}, *rest_iter_);
     }
 
-    ArrowProxy<ProdIterDeref> operator->() {
+    ArrowProxy<ProdIterDeref<ContainerT>> operator->() {
       return {**this};
     }
   };
 
+  using RestIter = typename Productor<RestContainers...>::Iterator;
+  using RestConstIter = typename Productor<RestContainers...>::ConstIterator;
+
+ public:
+  using Iterator = IteratorTempl<Container, RestIter>;
+  using ConstIterator = IteratorTempl<AsConst<Container>, RestConstIter>;
+
   Iterator begin() {
     return {get_begin(container_), get_begin(rest_products_),
         get_end(rest_products_)};
@@ -113,6 +126,16 @@ class iter::impl::Productor<Container, RestContainers...> {
     return {
         get_end(container_), get_end(rest_products_), get_end(rest_products_)};
   }
+
+  ConstIterator begin() const {
+    return {get_begin(as_const(container_)),
+        get_begin(as_const(rest_products_)), get_end(as_const(rest_products_))};
+  }
+
+  ConstIterator end() const {
+    return {get_end(as_const(container_)), get_end(as_const(rest_products_)),
+        get_end(as_const(rest_products_))};
+  }
 };
 
 template <>
@@ -148,6 +171,7 @@ class iter::impl::Productor<> {
       return {};
     }
   };
+  using ConstIterator = Iterator;
 
   Iterator begin() {
     return {};
@@ -156,6 +180,14 @@ class iter::impl::Productor<> {
   Iterator end() {
     return {};
   }
+
+  ConstIterator begin() const {
+    return {};
+  }
+
+  ConstIterator end() const {
+    return {};
+  }
 };
 
 template <typename... Containers>

From a828a722feb3adca053343d7596cf851a3446e13 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 16 Oct 2017 13:57:54 -0500
Subject: [PATCH 1662/1866] Tests chain with const iteration

---
 test/test_chain.cpp | 36 ++++++++++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)

diff --git a/test/test_chain.cpp b/test/test_chain.cpp
index fbb28cc4..00701495 100644
--- a/test/test_chain.cpp
+++ b/test/test_chain.cpp
@@ -26,6 +26,25 @@ TEST_CASE("chain: three strings", "[chain]") {
   REQUIRE(v == vc);
 }
 
+TEST_CASE("chain: const iteration", "[chain][const]") {
+  std::string s1{"abc"};
+  /* const */ std::string s2{"mno"};
+  auto ch = chain(s1, s2, std::string{"xyz"});
+
+  Vec v(std::begin(ch), std::end(ch));
+  Vec vc{'a', 'b', 'c', 'm', 'n', 'o', 'x', 'y', 'z'};
+
+  REQUIRE(v == vc);
+}
+
+#if 0
+TEST_CASE("chain: const iterators can be compared to non-const itertors", "[chain][const]") {
+  auto ch = chain(std::string{}, std::string{});
+  const auto& cch = ch;
+  (void)(std::begin(ch) == std::end(cch));
+}
+#endif
+
 TEST_CASE("chain: with different container types", "[chain]") {
   std::string s1{"abc"};
   std::list<char> li{'m', 'n', 'o'};
@@ -184,6 +203,23 @@ TEST_CASE("chain.from_iterable: basic test", "[chain.from_iterable]") {
   REQUIRE(v == vc);
 }
 
+#if 0
+TEST_CASE("chain.from_iterable: const iteration", "[chain.from_iterable][const]") {
+  std::vector<std::string> sv{"abc", "xyz"};
+  const auto ch = chain.from_iterable(sv);
+  std::vector<char> v(std::begin(ch), std::end(ch));
+
+  std::vector<char> vc{'a', 'b', 'c', 'x', 'y', 'z'};
+  REQUIRE(v == vc);
+}
+
+TEST_CASE("chain.from_iterable: const iterators can be compared to non-const iterators", "[chain.from_iterable][const]") {
+  auto ch = chain.from_iterable(std::vector<int>{});
+  const auto& cch = ch;
+  (void)(std::begin(ch) == std::end(cch));
+}
+#endif
+
 TEST_CASE("chain.fromm_iterable: Works with different begin and end types",
     "[chain.from_iterable]") {
   std::vector<CharRange> crv = {{'c'}, {'d'}};

From c09a13eb501cf2d1dd25ab60b7ada3bdf7f3cbf4 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 16 Oct 2017 13:59:00 -0500
Subject: [PATCH 1663/1866] Adds support for const iteration to chain

---
 chain.hpp           | 175 +++++++++++++++++++++++++++-----------------
 test/test_chain.cpp |   1 +
 2 files changed, 108 insertions(+), 68 deletions(-)

diff --git a/chain.hpp b/chain.hpp
index 90f553e1..ae7e74ef 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -33,95 +33,105 @@ class iter::impl::Chained {
  private:
   friend ChainMaker;
 
-  static_assert(std::tuple_size<std::decay_t<TupType>>::value == sizeof...(Is),
-      "tuple size != sizeof Is");
-
-  static_assert(
-      are_same<iterator_deref<std::tuple_element_t<Is, TupType>>...>::value,
-      "All chained iterables must have iterators that "
-      "dereference to the same type, including cv-qualifiers "
-      "and references.");
-
-  using IterTupType = iterator_tuple_type<TupType>;
-  using DerefType = iterator_deref<std::tuple_element_t<0, TupType>>;
-  using ArrowType = iterator_arrow<std::tuple_element_t<0, TupType>>;
-
-  template <std::size_t Idx>
-  static DerefType get_and_deref(IterTupType& iters) {
-    return *std::get<Idx>(iters);
-  }
+  template <typename TupTypeT>
+  class IteratorData {
+    IteratorData() = delete;
+    static_assert(
+        std::tuple_size<std::decay_t<TupTypeT>>::value == sizeof...(Is),
+        "tuple size != sizeof Is");
+
+    static_assert(
+        are_same<iterator_deref<std::tuple_element_t<Is, TupTypeT>>...>::value,
+        "All chained iterables must have iterators that "
+        "dereference to the same type, including cv-qualifiers "
+        "and references.");
 
-  template <std::size_t Idx>
-  static ArrowType get_and_arrow(IterTupType& iters) {
-    return apply_arrow(std::get<Idx>(iters));
-  }
+   public:
+    using IterTupType = iterator_tuple_type<TupTypeT>;
+    using DerefType = iterator_deref<std::tuple_element_t<0, TupTypeT>>;
+    using ArrowType = iterator_arrow<std::tuple_element_t<0, TupTypeT>>;
 
-  template <std::size_t Idx>
-  static void get_and_increment(IterTupType& iters) {
-    ++std::get<Idx>(iters);
-  }
+    template <std::size_t Idx>
+    static DerefType get_and_deref(IterTupType& iters) {
+      return *std::get<Idx>(iters);
+    }
 
-  template <std::size_t Idx>
-  static bool get_and_check_not_equal(
-      const IterTupType& lhs, const IterTupType& rhs) {
-    return std::get<Idx>(lhs) != std::get<Idx>(rhs);
-  }
+    template <std::size_t Idx>
+    static ArrowType get_and_arrow(IterTupType& iters) {
+      return apply_arrow(std::get<Idx>(iters));
+    }
 
-  using DerefFunc = DerefType (*)(IterTupType&);
-  using ArrowFunc = ArrowType (*)(IterTupType&);
-  using IncFunc = void (*)(IterTupType&);
-  using NeqFunc = bool (*)(const IterTupType&, const IterTupType&);
+    template <std::size_t Idx>
+    static void get_and_increment(IterTupType& iters) {
+      ++std::get<Idx>(iters);
+    }
 
-  constexpr static std::array<DerefFunc, sizeof...(Is)> derefers{
-      {get_and_deref<Is>...}};
+    template <std::size_t Idx>
+    static bool get_and_check_not_equal(
+        const IterTupType& lhs, const IterTupType& rhs) {
+      return std::get<Idx>(lhs) != std::get<Idx>(rhs);
+    }
 
-  constexpr static std::array<ArrowFunc, sizeof...(Is)> arrowers{
-      {get_and_arrow<Is>...}};
+    using DerefFunc = DerefType (*)(IterTupType&);
+    using ArrowFunc = ArrowType (*)(IterTupType&);
+    using IncFunc = void (*)(IterTupType&);
+    using NeqFunc = bool (*)(const IterTupType&, const IterTupType&);
 
-  constexpr static std::array<IncFunc, sizeof...(Is)> incrementers{
-      {get_and_increment<Is>...}};
+    constexpr static std::array<DerefFunc, sizeof...(Is)> derefers{
+        {get_and_deref<Is>...}};
 
-  constexpr static std::array<NeqFunc, sizeof...(Is)> neq_comparers{
-      {get_and_check_not_equal<Is>...}};
+    constexpr static std::array<ArrowFunc, sizeof...(Is)> arrowers{
+        {get_and_arrow<Is>...}};
 
-  using TraitsValue = iterator_traits_deref<std::tuple_element_t<0, TupType>>;
+    constexpr static std::array<IncFunc, sizeof...(Is)> incrementers{
+        {get_and_increment<Is>...}};
+
+    constexpr static std::array<NeqFunc, sizeof...(Is)> neq_comparers{
+        {get_and_check_not_equal<Is>...}};
+
+    using TraitsValue =
+        iterator_traits_deref<std::tuple_element_t<0, TupTypeT>>;
+  };
 
- private:
   Chained(TupType&& t) : tup_(std::move(t)) {}
   TupType tup_;
 
  public:
   Chained(Chained&&) = default;
 
-  class Iterator : public std::iterator<std::input_iterator_tag, TraitsValue> {
+  template <typename TupTypeT>
+  class Iterator : public std::iterator<std::input_iterator_tag,
+                       typename IteratorData<TupTypeT>::TraitsValue> {
    private:
+    using IterData = IteratorData<TupTypeT>;
     std::size_t index_;
-    IterTupType iters_;
-    IterTupType ends_;
+    typename IterData::IterTupType iters_;
+    typename IterData::IterTupType ends_;
 
     void check_for_end_and_adjust() {
-      while (
-          index_ < sizeof...(Is) && !(neq_comparers[index_](iters_, ends_))) {
+      while (index_ < sizeof...(Is)
+             && !(IterData::neq_comparers[index_](iters_, ends_))) {
         ++index_;
       }
     }
 
    public:
-    Iterator(std::size_t i, IterTupType&& iters, IterTupType&& ends)
+    Iterator(std::size_t i, typename IterData::IterTupType&& iters,
+        typename IterData::IterTupType&& ends)
         : index_{i}, iters_(std::move(iters)), ends_(std::move(ends)) {
       check_for_end_and_adjust();
     }
 
     decltype(auto) operator*() {
-      return derefers[index_](iters_);
+      return IterData::derefers[index_](iters_);
     }
 
     decltype(auto) operator-> () {
-      return arrowers[index_](iters_);
+      return IterData::arrowers[index_](iters_);
     }
 
     Iterator& operator++() {
-      incrementers[index_](iters_);
+      IterData::incrementers[index_](iters_);
       check_for_end_and_adjust();
       return *this;
     }
@@ -132,10 +142,11 @@ class iter::impl::Chained {
       return ret;
     }
 
+    // TODO make const and non-const iterators comparable
     bool operator!=(const Iterator& other) const {
       return index_ != other.index_
              || (index_ != sizeof...(Is)
-                    && neq_comparers[index_](iters_, other.iters_));
+                    && IterData::neq_comparers[index_](iters_, other.iters_));
     }
 
     bool operator==(const Iterator& other) const {
@@ -143,36 +154,64 @@ class iter::impl::Chained {
     }
   };
 
-  Iterator begin() {
-    return {0, IterTupType{get_begin(std::get<Is>(tup_))...},
-        IterTupType{get_end(std::get<Is>(tup_))...}};
+  Iterator<TupType> begin() {
+    return {0, typename IteratorData<TupType>::IterTupType{get_begin(
+                   std::get<Is>(tup_))...},
+        typename IteratorData<TupType>::IterTupType{
+            get_end(std::get<Is>(tup_))...}};
   }
 
-  Iterator end() {
-    return {sizeof...(Is), IterTupType{get_end(std::get<Is>(tup_))...},
-        IterTupType{get_end(std::get<Is>(tup_))...}};
+  Iterator<TupType> end() {
+    return {sizeof...(Is), typename IteratorData<TupType>::IterTupType{get_end(
+                               std::get<Is>(tup_))...},
+        typename IteratorData<TupType>::IterTupType{
+            get_end(std::get<Is>(tup_))...}};
+  }
+
+  Iterator<AsConst<TupType>> begin() const {
+    return {0, typename IteratorData<AsConst<TupType>>::IterTupType{get_begin(
+                   as_const(std::get<Is>(tup_)))...},
+        typename IteratorData<AsConst<TupType>>::IterTupType{
+            get_end(as_const(std::get<Is>(tup_)))...}};
+  }
+
+  Iterator<AsConst<TupType>> end() const {
+    return {sizeof...(Is),
+        typename IteratorData<AsConst<TupType>>::IterTupType{
+            get_end(as_const(std::get<Is>(tup_)))...},
+        typename IteratorData<AsConst<TupType>>::IterTupType{
+            get_end(as_const(std::get<Is>(tup_)))...}};
   }
 };
 
+// jesus christ. what have I done.
 template <typename TupType, std::size_t... Is>
-constexpr std::array<typename iter::impl::Chained<TupType, Is...>::DerefFunc,
+template <typename TupTypeT>
+constexpr std::array<typename iter::impl::Chained<TupType,
+                         Is...>::template IteratorData<TupTypeT>::DerefFunc,
     sizeof...(Is)>
-    iter::impl::Chained<TupType, Is...>::derefers;
+    iter::impl::Chained<TupType, Is...>::IteratorData<TupTypeT>::derefers;
 
 template <typename TupType, std::size_t... Is>
-constexpr std::array<typename iter::impl::Chained<TupType, Is...>::ArrowFunc,
+template <typename TupTypeT>
+constexpr std::array<typename iter::impl::Chained<TupType,
+                         Is...>::template IteratorData<TupTypeT>::ArrowFunc,
     sizeof...(Is)>
-    iter::impl::Chained<TupType, Is...>::arrowers;
+    iter::impl::Chained<TupType, Is...>::IteratorData<TupTypeT>::arrowers;
 
 template <typename TupType, std::size_t... Is>
-constexpr std::array<typename iter::impl::Chained<TupType, Is...>::IncFunc,
+template <typename TupTypeT>
+constexpr std::array<typename iter::impl::Chained<TupType,
+                         Is...>::template IteratorData<TupTypeT>::IncFunc,
     sizeof...(Is)>
-    iter::impl::Chained<TupType, Is...>::incrementers;
+    iter::impl::Chained<TupType, Is...>::IteratorData<TupTypeT>::incrementers;
 
 template <typename TupType, std::size_t... Is>
-constexpr std::array<typename iter::impl::Chained<TupType, Is...>::NeqFunc,
+template <typename TupTypeT>
+constexpr std::array<typename iter::impl::Chained<TupType,
+                         Is...>::template IteratorData<TupTypeT>::NeqFunc,
     sizeof...(Is)>
-    iter::impl::Chained<TupType, Is...>::neq_comparers;
+    iter::impl::Chained<TupType, Is...>::IteratorData<TupTypeT>::neq_comparers;
 
 template <typename Container>
 class iter::impl::ChainedFromIterable {
diff --git a/test/test_chain.cpp b/test/test_chain.cpp
index 00701495..8213c2cc 100644
--- a/test/test_chain.cpp
+++ b/test/test_chain.cpp
@@ -37,6 +37,7 @@ TEST_CASE("chain: const iteration", "[chain][const]") {
   REQUIRE(v == vc);
 }
 
+// TODO make this work
 #if 0
 TEST_CASE("chain: const iterators can be compared to non-const itertors", "[chain][const]") {
   auto ch = chain(std::string{}, std::string{});

From 92992d0b2e8b1cec6c3b8be66f119737b07d4910 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 16 Oct 2017 19:36:38 -0500
Subject: [PATCH 1664/1866] Tests chain.from_iterable with const iteration

---
 test/test_chain.cpp | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/test/test_chain.cpp b/test/test_chain.cpp
index 8213c2cc..32b9f184 100644
--- a/test/test_chain.cpp
+++ b/test/test_chain.cpp
@@ -204,8 +204,8 @@ TEST_CASE("chain.from_iterable: basic test", "[chain.from_iterable]") {
   REQUIRE(v == vc);
 }
 
-#if 0
-TEST_CASE("chain.from_iterable: const iteration", "[chain.from_iterable][const]") {
+TEST_CASE(
+    "chain.from_iterable: const iteration", "[chain.from_iterable][const]") {
   std::vector<std::string> sv{"abc", "xyz"};
   const auto ch = chain.from_iterable(sv);
   std::vector<char> v(std::begin(ch), std::end(ch));
@@ -214,12 +214,15 @@ TEST_CASE("chain.from_iterable: const iteration", "[chain.from_iterable][const]"
   REQUIRE(v == vc);
 }
 
-TEST_CASE("chain.from_iterable: const iterators can be compared to non-const iterators", "[chain.from_iterable][const]") {
-  auto ch = chain.from_iterable(std::vector<int>{});
+TEST_CASE(
+    "chain.from_iterable: const iterators can be compared to non-const "
+    "iterators",
+    "[chain.from_iterable][const]") {
+  std::vector<std::vector<int>> v{};
+  auto ch = chain.from_iterable(v);
   const auto& cch = ch;
   (void)(std::begin(ch) == std::end(cch));
 }
-#endif
 
 TEST_CASE("chain.fromm_iterable: Works with different begin and end types",
     "[chain.from_iterable]") {

From e64c3b56bf9fd10940a88cda23866f25db88da56 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 16 Oct 2017 19:36:53 -0500
Subject: [PATCH 1665/1866] Adds support for const iteration to
 chain.from_iterable

---
 chain.hpp | 44 ++++++++++++++++++++++++++++++--------------
 1 file changed, 30 insertions(+), 14 deletions(-)

diff --git a/chain.hpp b/chain.hpp
index ae7e74ef..11be814f 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -223,14 +223,17 @@ class iter::impl::ChainedFromIterable {
 
  public:
   ChainedFromIterable(ChainedFromIterable&&) = default;
+  template <typename ContainerT>
   class Iterator : public std::iterator<std::input_iterator_tag,
-                       iterator_traits_deref<iterator_deref<Container>>> {
+                       iterator_traits_deref<iterator_deref<ContainerT>>> {
    private:
-    using SubContainer = iterator_deref<Container>;
+    template <typename>
+    friend class Iterator;
+    using SubContainer = iterator_deref<ContainerT>;
     using SubIter = IteratorWrapper<SubContainer>;
 
-    IteratorWrapper<Container> top_level_iter_;
-    IteratorWrapper<Container> top_level_end_;
+    IteratorWrapper<ContainerT> top_level_iter_;
+    IteratorWrapper<ContainerT> top_level_end_;
     std::unique_ptr<SubIter> sub_iter_p_;
     std::unique_ptr<SubIter> sub_end_p_;
 
@@ -238,8 +241,11 @@ class iter::impl::ChainedFromIterable {
       return sub_iter ? std::make_unique<SubIter>(*sub_iter) : nullptr;
     }
 
-    bool sub_iters_differ(const Iterator& other) const {
-      if (sub_iter_p_ == other.sub_iter_p_) {
+    template <typename T>
+    bool sub_iters_differ(const Iterator<T>& other) const {
+      // checking if they're the same also handles them both being nullptr
+      if (static_cast<const void*>(sub_iter_p_.get())
+          == static_cast<const void*>(other.sub_iter_p_.get())) {
         return false;
       }
       if (sub_iter_p_ == nullptr || other.sub_iter_p_ == nullptr) {
@@ -251,8 +257,8 @@ class iter::impl::ChainedFromIterable {
     }
 
    public:
-    Iterator(IteratorWrapper<Container>&& top_iter,
-        IteratorWrapper<Container>&& top_end)
+    Iterator(IteratorWrapper<ContainerT>&& top_iter,
+        IteratorWrapper<ContainerT>&& top_end)
         : top_level_iter_{std::move(top_iter)},
           top_level_end_{std::move(top_end)},
           sub_iter_p_{!(top_iter != top_end)
@@ -308,31 +314,41 @@ class iter::impl::ChainedFromIterable {
       return ret;
     }
 
-    bool operator!=(const Iterator& other) const {
+    template <typename T>
+    bool operator!=(const Iterator<T>& other) const {
       return top_level_iter_ != other.top_level_iter_
              || sub_iters_differ(other);
     }
 
-    bool operator==(const Iterator& other) const {
+    template <typename T>
+    bool operator==(const Iterator<T>& other) const {
       return !(*this != other);
     }
 
-    iterator_deref<iterator_deref<Container>> operator*() {
+    iterator_deref<iterator_deref<ContainerT>> operator*() {
       return **sub_iter_p_;
     }
 
-    iterator_arrow<iterator_deref<Container>> operator->() {
+    iterator_arrow<iterator_deref<ContainerT>> operator->() {
       return apply_arrow(*sub_iter_p_);
     }
   };
 
-  Iterator begin() {
+  Iterator<Container> begin() {
     return {get_begin(container_), get_end(container_)};
   }
 
-  Iterator end() {
+  Iterator<Container> end() {
     return {get_end(container_), get_end(container_)};
   }
+
+  Iterator<AsConst<Container>> begin() const {
+    return {get_begin(as_const(container_)), get_end(as_const(container_))};
+  }
+
+  Iterator<AsConst<Container>> end() const {
+    return {get_end(as_const(container_)), get_end(as_const(container_))};
+  }
 };
 
 class iter::impl::ChainMaker {

From e8d6cc5d9c2f73cb5fea48cecd340dde70d76e0b Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 16 Oct 2017 19:43:07 -0500
Subject: [PATCH 1666/1866] Some iterator type disagreement thing

---
 test/helpers.hpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/test/helpers.hpp b/test/helpers.hpp
index 76b4c359..e1d5a3cf 100644
--- a/test/helpers.hpp
+++ b/test/helpers.hpp
@@ -110,7 +110,8 @@ namespace itertest {
     BasicIterable(const BasicIterable& other)
         : data{new T[other.size]}, size{other.size} {
       other.was_copied_from_ = true;
-      for (auto it = begin(*this), o_it = begin(other); o_it != end(other);
+      auto o_it = begin(other);
+      for (auto it = begin(*this); o_it != end(other);
            ++it, ++o_it) {
         *it = *o_it;
       }

From 0cecd1618acf2a9fdf925a99a3dcfa6ca7524208 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 20 Oct 2017 16:32:43 -0500
Subject: [PATCH 1667/1866] fixes include imap.hpp -> starmap.hpp

---
 test/test_starmap.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/test_starmap.cpp b/test/test_starmap.cpp
index 1b284738..210694f5 100644
--- a/test/test_starmap.cpp
+++ b/test/test_starmap.cpp
@@ -1,4 +1,4 @@
-#include <imap.hpp>
+#include <starmap.hpp>
 
 #include "helpers.hpp"
 

From 3b0034677a351a3d4406856858c2ea01abdc83f8 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 26 Oct 2017 12:58:48 -0500
Subject: [PATCH 1668/1866] qualifies calls to as_const with ::impl

ADL is screwing me on this in C++17, it doesn't know whether to use
iter::impl::as_const or std::as_const when the argument is std::anything
---
 accumulate.hpp                    |  4 ++--
 chain.hpp                         | 12 ++++++------
 chunked.hpp                       |  4 ++--
 combinations.hpp                  |  4 ++--
 combinations_with_replacement.hpp |  4 ++--
 compress.hpp                      |  8 ++++----
 cycle.hpp                         |  4 ++--
 dropwhile.hpp                     |  4 ++--
 enumerate.hpp                     |  4 ++--
 filter.hpp                        |  4 ++--
 groupby.hpp                       |  4 ++--
 internal/iterbase.hpp             |  2 +-
 permutations.hpp                  |  4 ++--
 powerset.hpp                      |  4 ++--
 product.hpp                       |  8 ++++----
 reversed.hpp                      |  4 ++--
 slice.hpp                         |  8 ++++----
 sliding_window.hpp                |  8 ++++----
 sorted.hpp                        |  4 ++--
 starmap.hpp                       |  8 ++++----
 takewhile.hpp                     |  4 ++--
 zip.hpp                           |  4 ++--
 zip_longest.hpp                   |  8 ++++----
 23 files changed, 61 insertions(+), 61 deletions(-)

diff --git a/accumulate.hpp b/accumulate.hpp
index d533a8d7..f67d87f5 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -119,12 +119,12 @@ class iter::impl::Accumulator {
     return {get_end(container_), get_end(container_), accumulate_func_};
   }
   Iterator<AsConst<Container>> begin() const {
-    return {get_begin(as_const(container_)), get_end(as_const(container_)),
+    return {get_begin(impl::as_const(container_)), get_end(impl::as_const(container_)),
         accumulate_func_};
   }
 
   Iterator<AsConst<Container>> end() const {
-    return {get_end(as_const(container_)), get_end(as_const(container_)),
+    return {get_end(impl::as_const(container_)), get_end(impl::as_const(container_)),
         accumulate_func_};
   }
 };
diff --git a/chain.hpp b/chain.hpp
index 11be814f..6ae9b245 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -170,17 +170,17 @@ class iter::impl::Chained {
 
   Iterator<AsConst<TupType>> begin() const {
     return {0, typename IteratorData<AsConst<TupType>>::IterTupType{get_begin(
-                   as_const(std::get<Is>(tup_)))...},
+                   impl::as_const(std::get<Is>(tup_)))...},
         typename IteratorData<AsConst<TupType>>::IterTupType{
-            get_end(as_const(std::get<Is>(tup_)))...}};
+            get_end(impl::as_const(std::get<Is>(tup_)))...}};
   }
 
   Iterator<AsConst<TupType>> end() const {
     return {sizeof...(Is),
         typename IteratorData<AsConst<TupType>>::IterTupType{
-            get_end(as_const(std::get<Is>(tup_)))...},
+            get_end(impl::as_const(std::get<Is>(tup_)))...},
         typename IteratorData<AsConst<TupType>>::IterTupType{
-            get_end(as_const(std::get<Is>(tup_)))...}};
+            get_end(impl::as_const(std::get<Is>(tup_)))...}};
   }
 };
 
@@ -343,11 +343,11 @@ class iter::impl::ChainedFromIterable {
   }
 
   Iterator<AsConst<Container>> begin() const {
-    return {get_begin(as_const(container_)), get_end(as_const(container_))};
+    return {get_begin(impl::as_const(container_)), get_end(impl::as_const(container_))};
   }
 
   Iterator<AsConst<Container>> end() const {
-    return {get_end(as_const(container_)), get_end(as_const(container_))};
+    return {get_end(impl::as_const(container_)), get_end(impl::as_const(container_))};
   }
 };
 
diff --git a/chunked.hpp b/chunked.hpp
index bf152a3f..316a3a17 100644
--- a/chunked.hpp
+++ b/chunked.hpp
@@ -115,12 +115,12 @@ class iter::impl::Chunker {
   }
 
   Iterator<AsConst<Container>> begin() const {
-    return {get_begin(as_const(container_)), get_end(as_const(container_)),
+    return {get_begin(impl::as_const(container_)), get_end(impl::as_const(container_)),
         chunk_size_};
   }
 
   Iterator<AsConst<Container>> end() const {
-    return {get_end(as_const(container_)), get_end(as_const(container_)),
+    return {get_end(impl::as_const(container_)), get_end(impl::as_const(container_)),
         chunk_size_};
   }
 };
diff --git a/combinations.hpp b/combinations.hpp
index f32f00d5..163fa678 100644
--- a/combinations.hpp
+++ b/combinations.hpp
@@ -136,11 +136,11 @@ class iter::impl::Combinator {
   }
 
   Iterator<AsConst<Container>> begin() const {
-    return {as_const(container_), length_};
+    return {impl::as_const(container_), length_};
   }
 
   Iterator<AsConst<Container>> end() const {
-    return {as_const(container_), 0};
+    return {impl::as_const(container_), 0};
   }
 };
 
diff --git a/combinations_with_replacement.hpp b/combinations_with_replacement.hpp
index dab28c9a..cc76e250 100644
--- a/combinations_with_replacement.hpp
+++ b/combinations_with_replacement.hpp
@@ -115,11 +115,11 @@ class iter::impl::CombinatorWithReplacement {
   }
 
   Iterator<AsConst<Container>> begin() const {
-    return {as_const(container_), length_};
+    return {impl::as_const(container_), length_};
   }
 
   Iterator<AsConst<Container>> end() const {
-    return {as_const(container_), 0};
+    return {impl::as_const(container_), 0};
   }
 };
 
diff --git a/compress.hpp b/compress.hpp
index 9c511215..50e64017 100644
--- a/compress.hpp
+++ b/compress.hpp
@@ -111,13 +111,13 @@ class iter::impl::Compressed {
   }
 
   Iterator<AsConst<Container>, AsConst<Selector>> begin() const {
-    return {get_begin(as_const(container_)), get_end(as_const(container_)),
-        get_begin(as_const(selectors_)), get_end(as_const(selectors_))};
+    return {get_begin(impl::as_const(container_)), get_end(impl::as_const(container_)),
+        get_begin(impl::as_const(selectors_)), get_end(impl::as_const(selectors_))};
   }
 
   Iterator<AsConst<Container>, AsConst<Selector>> end() const {
-    return {get_end(as_const(container_)), get_end(as_const(container_)),
-        get_end(as_const(selectors_)), get_end(as_const(selectors_))};
+    return {get_end(impl::as_const(container_)), get_end(impl::as_const(container_)),
+        get_end(impl::as_const(selectors_)), get_end(impl::as_const(selectors_))};
   }
 };
 
diff --git a/cycle.hpp b/cycle.hpp
index 21a92872..06988870 100644
--- a/cycle.hpp
+++ b/cycle.hpp
@@ -90,11 +90,11 @@ class iter::impl::Cycler {
   }
 
   Iterator<AsConst<Container>> begin() const {
-    return {get_begin(as_const(container_)), get_end(as_const(container_))};
+    return {get_begin(impl::as_const(container_)), get_end(impl::as_const(container_))};
   }
 
   Iterator<AsConst<Container>> end() const {
-    return {get_end(as_const(container_)), get_end(as_const(container_))};
+    return {get_end(impl::as_const(container_)), get_end(impl::as_const(container_))};
   }
 };
 
diff --git a/dropwhile.hpp b/dropwhile.hpp
index 1c9c5737..dc2432cf 100644
--- a/dropwhile.hpp
+++ b/dropwhile.hpp
@@ -109,12 +109,12 @@ class iter::impl::Dropper {
   }
 
   Iterator<AsConst<Container>> begin() const {
-    return {get_begin(as_const(container_)), get_end(as_const(container_)),
+    return {get_begin(impl::as_const(container_)), get_end(impl::as_const(container_)),
         filter_func_};
   }
 
   Iterator<AsConst<Container>> end() const {
-    return {get_end(as_const(container_)), get_end(as_const(container_)),
+    return {get_end(impl::as_const(container_)), get_end(impl::as_const(container_)),
         filter_func_};
   }
 };
diff --git a/enumerate.hpp b/enumerate.hpp
index a79c1a41..05230525 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -120,11 +120,11 @@ class iter::impl::Enumerable {
   }
 
   Iterator<AsConst<Container>> begin() const {
-    return {get_begin(as_const(container_)), start_};
+    return {get_begin(impl::as_const(container_)), start_};
   }
 
   Iterator<AsConst<Container>> end() const {
-    return {get_end(as_const(container_)), start_};
+    return {get_end(impl::as_const(container_)), start_};
   }
 };
 #endif
diff --git a/filter.hpp b/filter.hpp
index 4b450b14..8a3502e8 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -122,12 +122,12 @@ class iter::impl::Filtered {
   }
 
   Iterator<AsConst<Container>> begin() const {
-    return {get_begin(as_const(container_)), get_end(as_const(container_)),
+    return {get_begin(impl::as_const(container_)), get_end(impl::as_const(container_)),
         filter_func_};
   }
 
   Iterator<AsConst<Container>> end() const {
-    return {get_end(as_const(container_)), get_end(as_const(container_)),
+    return {get_end(impl::as_const(container_)), get_end(impl::as_const(container_)),
         filter_func_};
   }
 };
diff --git a/groupby.hpp b/groupby.hpp
index f25d145b..ac8ba01f 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -274,12 +274,12 @@ class iter::impl::GroupProducer {
   }
 
   Iterator<AsConst<Container>> begin() const {
-    return {get_begin(as_const(container_)), get_end(as_const(container_)),
+    return {get_begin(impl::as_const(container_)), get_end(impl::as_const(container_)),
         key_func_};
   }
 
   Iterator<AsConst<Container>> end() const {
-    return {get_end(as_const(container_)), get_end(as_const(container_)),
+    return {get_end(impl::as_const(container_)), get_end(impl::as_const(container_)),
         key_func_};
   }
 };
diff --git a/internal/iterbase.hpp b/internal/iterbase.hpp
index 2b0ec98d..88d487ba 100644
--- a/internal/iterbase.hpp
+++ b/internal/iterbase.hpp
@@ -60,7 +60,7 @@ namespace iter {
     void as_const(T&&) = delete;
 
     template <typename T>
-    using AsConst = decltype(as_const(std::declval<T&>()));
+    using AsConst = decltype(impl::as_const(std::declval<T&>()));
 
     // gcc CWG 1558
     template <typename...>
diff --git a/permutations.hpp b/permutations.hpp
index faae1fe2..b10f898d 100644
--- a/permutations.hpp
+++ b/permutations.hpp
@@ -110,11 +110,11 @@ class iter::impl::Permuter {
   }
 
   Iterator<AsConst<Container>> begin() const {
-    return {get_begin(as_const(container_)), get_end(as_const(container_))};
+    return {get_begin(impl::as_const(container_)), get_end(impl::as_const(container_))};
   }
 
   Iterator<AsConst<Container>> end() const {
-    return {get_end(as_const(container_)), get_end(as_const(container_))};
+    return {get_end(impl::as_const(container_)), get_end(impl::as_const(container_))};
   }
 };
 
diff --git a/powerset.hpp b/powerset.hpp
index 2997d569..d5c56619 100644
--- a/powerset.hpp
+++ b/powerset.hpp
@@ -114,11 +114,11 @@ class iter::impl::Powersetter {
   }
 
   Iterator<AsConst<Container>> begin() const {
-    return {as_const(container_), 0};
+    return {impl::as_const(container_), 0};
   }
 
   Iterator<AsConst<Container>> end() const {
-    return {as_const(container_), dumb_size(as_const(container_)) + 1};
+    return {impl::as_const(container_), dumb_size(impl::as_const(container_)) + 1};
   }
 };
 
diff --git a/product.hpp b/product.hpp
index 941eddae..7f569632 100644
--- a/product.hpp
+++ b/product.hpp
@@ -128,13 +128,13 @@ class iter::impl::Productor<Container, RestContainers...> {
   }
 
   ConstIterator begin() const {
-    return {get_begin(as_const(container_)),
-        get_begin(as_const(rest_products_)), get_end(as_const(rest_products_))};
+    return {get_begin(impl::as_const(container_)),
+        get_begin(impl::as_const(rest_products_)), get_end(impl::as_const(rest_products_))};
   }
 
   ConstIterator end() const {
-    return {get_end(as_const(container_)), get_end(as_const(rest_products_)),
-        get_end(as_const(rest_products_))};
+    return {get_end(impl::as_const(container_)), get_end(impl::as_const(rest_products_)),
+        get_end(impl::as_const(rest_products_))};
   }
 };
 
diff --git a/reversed.hpp b/reversed.hpp
index 4f3004e2..08517fb7 100644
--- a/reversed.hpp
+++ b/reversed.hpp
@@ -121,11 +121,11 @@ class iter::impl::Reverser {
   }
 
   Iterator<AsConst<Container>> begin() const {
-    return {std::rbegin(as_const(container_))};
+    return {std::rbegin(impl::as_const(container_))};
   }
 
   Iterator<AsConst<Container>> end() const {
-    return {std::rend(as_const(container_))};
+    return {std::rend(impl::as_const(container_))};
   }
 };
 
diff --git a/slice.hpp b/slice.hpp
index 4ac9e1a0..f29922d0 100644
--- a/slice.hpp
+++ b/slice.hpp
@@ -102,13 +102,13 @@ class iter::impl::Sliced {
   }
 
   Iterator<AsConst<Container>> begin() const {
-    auto it = get_begin(as_const(container_));
-    dumb_advance(it, get_end(as_const(container_)), start_);
-    return {std::move(it), get_end(as_const(container_)), start_, stop_, step_};
+    auto it = get_begin(impl::as_const(container_));
+    dumb_advance(it, get_end(impl::as_const(container_)), start_);
+    return {std::move(it), get_end(impl::as_const(container_)), start_, stop_, step_};
   }
 
   Iterator<AsConst<Container>> end() const {
-    return {get_end(as_const(container_)), get_end(as_const(container_)), stop_,
+    return {get_end(impl::as_const(container_)), get_end(impl::as_const(container_)), stop_,
         stop_, step_};
   }
 };
diff --git a/sliding_window.hpp b/sliding_window.hpp
index 7c3135f5..62da80d8 100644
--- a/sliding_window.hpp
+++ b/sliding_window.hpp
@@ -104,14 +104,14 @@ class iter::impl::WindowSlider {
 
   Iterator<AsConst<Container>> begin() const {
     return {(window_size_ != 0 ? IteratorWrapper<AsConst<Container>>{get_begin(
-                                     as_const(container_))}
+                                     impl::as_const(container_))}
                                : IteratorWrapper<AsConst<Container>>{get_end(
-                                     as_const(container_))}),
-        get_end(as_const(container_)), window_size_};
+                                     impl::as_const(container_))}),
+        get_end(impl::as_const(container_)), window_size_};
   }
 
   Iterator<AsConst<Container>> end() const {
-    return {get_end(as_const(container_)), get_end(as_const(container_)),
+    return {get_end(impl::as_const(container_)), get_end(impl::as_const(container_)),
         window_size_};
   }
 };
diff --git a/sorted.hpp b/sorted.hpp
index fa6f7c19..24701488 100644
--- a/sorted.hpp
+++ b/sorted.hpp
@@ -101,8 +101,8 @@ class iter::impl::SortedView {
       if (!const_sorted_iters_.empty()) {
         return;
       }
-      for (auto iter = get_begin(as_const(container_));
-           iter != get_end(as_const(container_)); ++iter) {
+      for (auto iter = get_begin(impl::as_const(container_));
+           iter != get_end(impl::as_const(container_)); ++iter) {
         const_sorted_iters_.get().push_back(iter);
       }
 
diff --git a/starmap.hpp b/starmap.hpp
index 4f82d106..27639195 100644
--- a/starmap.hpp
+++ b/starmap.hpp
@@ -95,11 +95,11 @@ class iter::impl::StarMapper {
   }
 
   Iterator<AsConst<Container>> begin() const {
-    return {func_, get_begin(as_const(container_))};
+    return {func_, get_begin(impl::as_const(container_))};
   }
 
   Iterator<AsConst<Container>> end() const {
-    return {func_, get_end(as_const(container_))};
+    return {func_, get_end(impl::as_const(container_))};
   }
 };
 
@@ -194,11 +194,11 @@ class iter::impl::TupleStarMapper {
   }
 
   Iterator<AsConst<TupType>> begin() const {
-    return {func_, as_const(tup_), 0};
+    return {func_, impl::as_const(tup_), 0};
   }
 
   Iterator<AsConst<TupType>> end() const {
-    return {func_, as_const(tup_), sizeof...(Is)};
+    return {func_, impl::as_const(tup_), sizeof...(Is)};
   }
 };
 
diff --git a/takewhile.hpp b/takewhile.hpp
index d4b0e956..8d6694ba 100644
--- a/takewhile.hpp
+++ b/takewhile.hpp
@@ -110,12 +110,12 @@ class iter::impl::Taker {
   }
 
   Iterator<AsConst<Container>> begin() const {
-    return {get_begin(as_const(container_)), get_end(as_const(container_)),
+    return {get_begin(impl::as_const(container_)), get_end(impl::as_const(container_)),
         filter_func_};
   }
 
   Iterator<AsConst<Container>> end() const {
-    return {get_end(as_const(container_)), get_end(as_const(container_)),
+    return {get_end(impl::as_const(container_)), get_end(impl::as_const(container_)),
         filter_func_};
   }
 };
diff --git a/zip.hpp b/zip.hpp
index 7958234b..3bb4ccdb 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -101,14 +101,14 @@ class iter::impl::Zipped {
       const_iterator_deref_tuple>
   begin() const {
     return {const_iterator_tuple_type<AsConst<TupleType>>{
-        get_begin(as_const(std::get<Is>(containers_)))...}};
+        get_begin(impl::as_const(std::get<Is>(containers_)))...}};
   }
 
   Iterator<AsConst<TupleType>, const_iterator_tuple_type,
       const_iterator_deref_tuple>
   end() const {
     return {const_iterator_tuple_type<AsConst<TupleType>>{
-        get_end(as_const(std::get<Is>(containers_)))...}};
+        get_end(impl::as_const(std::get<Is>(containers_)))...}};
   }
 };
 
diff --git a/zip_longest.hpp b/zip_longest.hpp
index 428751c0..eb73aaac 100644
--- a/zip_longest.hpp
+++ b/zip_longest.hpp
@@ -121,17 +121,17 @@ class iter::impl::ZippedLongest {
   Iterator<AsConst<TupleType>, const_iterator_tuple_type, ConstOptType> begin()
       const {
     return {const_iterator_tuple_type<AsConst<TupleType>>{
-                get_begin(as_const(std::get<Is>(containers_)))...},
+                get_begin(impl::as_const(std::get<Is>(containers_)))...},
         const_iterator_tuple_type<AsConst<TupleType>>{
-            get_end(as_const(std::get<Is>(containers_)))...}};
+            get_end(impl::as_const(std::get<Is>(containers_)))...}};
   }
 
   Iterator<AsConst<TupleType>, const_iterator_tuple_type, ConstOptType> end()
       const {
     return {const_iterator_tuple_type<AsConst<TupleType>>{
-                get_end(as_const(std::get<Is>(containers_)))...},
+                get_end(impl::as_const(std::get<Is>(containers_)))...},
         const_iterator_tuple_type<AsConst<TupleType>>{
-            get_end(as_const(std::get<Is>(containers_)))...}};
+            get_end(impl::as_const(std::get<Is>(containers_)))...}};
   }
 };
 

From 22250a8f407cdeecc6459f1f6330f61a62ca9b38 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 26 Oct 2017 13:10:52 -0500
Subject: [PATCH 1669/1866] structed binding declaration in enumerate example

---
 README.md | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/README.md b/README.md
index b7f97e62..ae67923f 100644
--- a/README.md
+++ b/README.md
@@ -221,15 +221,13 @@ enumerate
 ---------
 
 Continually "yields" containers similar to pairs.  They are basic structs with a
-.index and a .element.  Usage appears as:
+.index and a .element, and also work with structured binding declarations.
+Usage appears as:
 
 ```c++
 vector<int> vec{2, 4, 6, 8};
-for (auto&& e : enumerate(vec)) {
-    cout << e.index
-         << ": "
-         << e.element
-         << '\n';
+for (auto&& [i, e] : enumerate(vec)) {
+    cout << i << ": " << e << '\n';
 }
 ```
 

From 67a67b22f17a5a6edf6b8585bf5e6e4f4ecca035 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Thu, 26 Oct 2017 13:11:24 -0500
Subject: [PATCH 1670/1866] formatting

---
 accumulate.hpp     |  8 ++++----
 chain.hpp          |  6 ++++--
 chunked.hpp        |  8 ++++----
 compress.hpp       | 12 ++++++++----
 cycle.hpp          |  6 ++++--
 dropwhile.hpp      |  8 ++++----
 filter.hpp         |  8 ++++----
 groupby.hpp        |  8 ++++----
 permutations.hpp   |  6 ++++--
 powerset.hpp       |  3 ++-
 product.hpp        |  6 ++++--
 range.hpp          | 15 ++++++++++-----
 slice.hpp          |  7 ++++---
 sliding_window.hpp |  4 ++--
 takewhile.hpp      |  8 ++++----
 15 files changed, 66 insertions(+), 47 deletions(-)

diff --git a/accumulate.hpp b/accumulate.hpp
index f67d87f5..25440d58 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -119,13 +119,13 @@ class iter::impl::Accumulator {
     return {get_end(container_), get_end(container_), accumulate_func_};
   }
   Iterator<AsConst<Container>> begin() const {
-    return {get_begin(impl::as_const(container_)), get_end(impl::as_const(container_)),
-        accumulate_func_};
+    return {get_begin(impl::as_const(container_)),
+        get_end(impl::as_const(container_)), accumulate_func_};
   }
 
   Iterator<AsConst<Container>> end() const {
-    return {get_end(impl::as_const(container_)), get_end(impl::as_const(container_)),
-        accumulate_func_};
+    return {get_end(impl::as_const(container_)),
+        get_end(impl::as_const(container_)), accumulate_func_};
   }
 };
 
diff --git a/chain.hpp b/chain.hpp
index 6ae9b245..1f840903 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -343,11 +343,13 @@ class iter::impl::ChainedFromIterable {
   }
 
   Iterator<AsConst<Container>> begin() const {
-    return {get_begin(impl::as_const(container_)), get_end(impl::as_const(container_))};
+    return {get_begin(impl::as_const(container_)),
+        get_end(impl::as_const(container_))};
   }
 
   Iterator<AsConst<Container>> end() const {
-    return {get_end(impl::as_const(container_)), get_end(impl::as_const(container_))};
+    return {get_end(impl::as_const(container_)),
+        get_end(impl::as_const(container_))};
   }
 };
 
diff --git a/chunked.hpp b/chunked.hpp
index 316a3a17..06f0a2aa 100644
--- a/chunked.hpp
+++ b/chunked.hpp
@@ -115,13 +115,13 @@ class iter::impl::Chunker {
   }
 
   Iterator<AsConst<Container>> begin() const {
-    return {get_begin(impl::as_const(container_)), get_end(impl::as_const(container_)),
-        chunk_size_};
+    return {get_begin(impl::as_const(container_)),
+        get_end(impl::as_const(container_)), chunk_size_};
   }
 
   Iterator<AsConst<Container>> end() const {
-    return {get_end(impl::as_const(container_)), get_end(impl::as_const(container_)),
-        chunk_size_};
+    return {get_end(impl::as_const(container_)),
+        get_end(impl::as_const(container_)), chunk_size_};
   }
 };
 
diff --git a/compress.hpp b/compress.hpp
index 50e64017..5ebc97ff 100644
--- a/compress.hpp
+++ b/compress.hpp
@@ -111,13 +111,17 @@ class iter::impl::Compressed {
   }
 
   Iterator<AsConst<Container>, AsConst<Selector>> begin() const {
-    return {get_begin(impl::as_const(container_)), get_end(impl::as_const(container_)),
-        get_begin(impl::as_const(selectors_)), get_end(impl::as_const(selectors_))};
+    return {get_begin(impl::as_const(container_)),
+        get_end(impl::as_const(container_)),
+        get_begin(impl::as_const(selectors_)),
+        get_end(impl::as_const(selectors_))};
   }
 
   Iterator<AsConst<Container>, AsConst<Selector>> end() const {
-    return {get_end(impl::as_const(container_)), get_end(impl::as_const(container_)),
-        get_end(impl::as_const(selectors_)), get_end(impl::as_const(selectors_))};
+    return {get_end(impl::as_const(container_)),
+        get_end(impl::as_const(container_)),
+        get_end(impl::as_const(selectors_)),
+        get_end(impl::as_const(selectors_))};
   }
 };
 
diff --git a/cycle.hpp b/cycle.hpp
index 06988870..c6ee4662 100644
--- a/cycle.hpp
+++ b/cycle.hpp
@@ -90,11 +90,13 @@ class iter::impl::Cycler {
   }
 
   Iterator<AsConst<Container>> begin() const {
-    return {get_begin(impl::as_const(container_)), get_end(impl::as_const(container_))};
+    return {get_begin(impl::as_const(container_)),
+        get_end(impl::as_const(container_))};
   }
 
   Iterator<AsConst<Container>> end() const {
-    return {get_end(impl::as_const(container_)), get_end(impl::as_const(container_))};
+    return {get_end(impl::as_const(container_)),
+        get_end(impl::as_const(container_))};
   }
 };
 
diff --git a/dropwhile.hpp b/dropwhile.hpp
index dc2432cf..1a23c823 100644
--- a/dropwhile.hpp
+++ b/dropwhile.hpp
@@ -109,13 +109,13 @@ class iter::impl::Dropper {
   }
 
   Iterator<AsConst<Container>> begin() const {
-    return {get_begin(impl::as_const(container_)), get_end(impl::as_const(container_)),
-        filter_func_};
+    return {get_begin(impl::as_const(container_)),
+        get_end(impl::as_const(container_)), filter_func_};
   }
 
   Iterator<AsConst<Container>> end() const {
-    return {get_end(impl::as_const(container_)), get_end(impl::as_const(container_)),
-        filter_func_};
+    return {get_end(impl::as_const(container_)),
+        get_end(impl::as_const(container_)), filter_func_};
   }
 };
 
diff --git a/filter.hpp b/filter.hpp
index 8a3502e8..b92c2ce3 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -122,13 +122,13 @@ class iter::impl::Filtered {
   }
 
   Iterator<AsConst<Container>> begin() const {
-    return {get_begin(impl::as_const(container_)), get_end(impl::as_const(container_)),
-        filter_func_};
+    return {get_begin(impl::as_const(container_)),
+        get_end(impl::as_const(container_)), filter_func_};
   }
 
   Iterator<AsConst<Container>> end() const {
-    return {get_end(impl::as_const(container_)), get_end(impl::as_const(container_)),
-        filter_func_};
+    return {get_end(impl::as_const(container_)),
+        get_end(impl::as_const(container_)), filter_func_};
   }
 };
 
diff --git a/groupby.hpp b/groupby.hpp
index ac8ba01f..12a0e471 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -274,13 +274,13 @@ class iter::impl::GroupProducer {
   }
 
   Iterator<AsConst<Container>> begin() const {
-    return {get_begin(impl::as_const(container_)), get_end(impl::as_const(container_)),
-        key_func_};
+    return {get_begin(impl::as_const(container_)),
+        get_end(impl::as_const(container_)), key_func_};
   }
 
   Iterator<AsConst<Container>> end() const {
-    return {get_end(impl::as_const(container_)), get_end(impl::as_const(container_)),
-        key_func_};
+    return {get_end(impl::as_const(container_)),
+        get_end(impl::as_const(container_)), key_func_};
   }
 };
 
diff --git a/permutations.hpp b/permutations.hpp
index b10f898d..39c073e5 100644
--- a/permutations.hpp
+++ b/permutations.hpp
@@ -110,11 +110,13 @@ class iter::impl::Permuter {
   }
 
   Iterator<AsConst<Container>> begin() const {
-    return {get_begin(impl::as_const(container_)), get_end(impl::as_const(container_))};
+    return {get_begin(impl::as_const(container_)),
+        get_end(impl::as_const(container_))};
   }
 
   Iterator<AsConst<Container>> end() const {
-    return {get_end(impl::as_const(container_)), get_end(impl::as_const(container_))};
+    return {get_end(impl::as_const(container_)),
+        get_end(impl::as_const(container_))};
   }
 };
 
diff --git a/powerset.hpp b/powerset.hpp
index d5c56619..8e5278f4 100644
--- a/powerset.hpp
+++ b/powerset.hpp
@@ -118,7 +118,8 @@ class iter::impl::Powersetter {
   }
 
   Iterator<AsConst<Container>> end() const {
-    return {impl::as_const(container_), dumb_size(impl::as_const(container_)) + 1};
+    return {
+        impl::as_const(container_), dumb_size(impl::as_const(container_)) + 1};
   }
 };
 
diff --git a/product.hpp b/product.hpp
index 7f569632..9f4d9dc7 100644
--- a/product.hpp
+++ b/product.hpp
@@ -129,11 +129,13 @@ class iter::impl::Productor<Container, RestContainers...> {
 
   ConstIterator begin() const {
     return {get_begin(impl::as_const(container_)),
-        get_begin(impl::as_const(rest_products_)), get_end(impl::as_const(rest_products_))};
+        get_begin(impl::as_const(rest_products_)),
+        get_end(impl::as_const(rest_products_))};
   }
 
   ConstIterator end() const {
-    return {get_end(impl::as_const(container_)), get_end(impl::as_const(rest_products_)),
+    return {get_end(impl::as_const(container_)),
+        get_end(impl::as_const(rest_products_)),
         get_end(impl::as_const(rest_products_))};
   }
 };
diff --git a/range.hpp b/range.hpp
index 3d2df9b8..348fd9ab 100644
--- a/range.hpp
+++ b/range.hpp
@@ -37,7 +37,8 @@ namespace iter {
      public:
       constexpr RangeIterData() noexcept = default;
       constexpr RangeIterData(T in_value, T in_step) noexcept
-          : value_{in_value}, step_{in_step} {}
+          : value_{in_value},
+            step_{in_step} {}
 
       constexpr T value() const noexcept {
         return value_;
@@ -72,7 +73,9 @@ namespace iter {
      public:
       constexpr RangeIterData() noexcept = default;
       constexpr RangeIterData(T in_start, T in_step) noexcept
-          : start_{in_start}, value_{in_start}, step_{in_step} {}
+          : start_{in_start},
+            value_{in_start},
+            step_{in_step} {}
 
       constexpr T value() const noexcept {
         return value_;
@@ -120,8 +123,9 @@ class iter::impl::Range {
 
   constexpr Range(T stop) noexcept : start_{0}, stop_{stop}, step_{1} {}
 
-  constexpr Range(T start, T stop, T step = 1) noexcept
-      : start_{start}, stop_{stop}, step_{step} {}
+  constexpr Range(T start, T stop, T step = 1) noexcept : start_{start},
+                                                          stop_{stop},
+                                                          step_{step} {}
 
  public:
   // the reference type here is T, which doesn't strictly follow all
@@ -165,7 +169,8 @@ class iter::impl::Range {
     constexpr Iterator() noexcept = default;
 
     constexpr Iterator(T in_value, T in_step, bool in_is_end) noexcept
-        : data(in_value, in_step), is_end{in_is_end} {}
+        : data(in_value, in_step),
+          is_end{in_is_end} {}
 
     constexpr T operator*() const noexcept {
       return data.value();
diff --git a/slice.hpp b/slice.hpp
index f29922d0..59ea7885 100644
--- a/slice.hpp
+++ b/slice.hpp
@@ -104,12 +104,13 @@ class iter::impl::Sliced {
   Iterator<AsConst<Container>> begin() const {
     auto it = get_begin(impl::as_const(container_));
     dumb_advance(it, get_end(impl::as_const(container_)), start_);
-    return {std::move(it), get_end(impl::as_const(container_)), start_, stop_, step_};
+    return {std::move(it), get_end(impl::as_const(container_)), start_, stop_,
+        step_};
   }
 
   Iterator<AsConst<Container>> end() const {
-    return {get_end(impl::as_const(container_)), get_end(impl::as_const(container_)), stop_,
-        stop_, step_};
+    return {get_end(impl::as_const(container_)),
+        get_end(impl::as_const(container_)), stop_, stop_, step_};
   }
 };
 
diff --git a/sliding_window.hpp b/sliding_window.hpp
index 62da80d8..ae478de8 100644
--- a/sliding_window.hpp
+++ b/sliding_window.hpp
@@ -111,8 +111,8 @@ class iter::impl::WindowSlider {
   }
 
   Iterator<AsConst<Container>> end() const {
-    return {get_end(impl::as_const(container_)), get_end(impl::as_const(container_)),
-        window_size_};
+    return {get_end(impl::as_const(container_)),
+        get_end(impl::as_const(container_)), window_size_};
   }
 };
 
diff --git a/takewhile.hpp b/takewhile.hpp
index 8d6694ba..ad823b0d 100644
--- a/takewhile.hpp
+++ b/takewhile.hpp
@@ -110,13 +110,13 @@ class iter::impl::Taker {
   }
 
   Iterator<AsConst<Container>> begin() const {
-    return {get_begin(impl::as_const(container_)), get_end(impl::as_const(container_)),
-        filter_func_};
+    return {get_begin(impl::as_const(container_)),
+        get_end(impl::as_const(container_)), filter_func_};
   }
 
   Iterator<AsConst<Container>> end() const {
-    return {get_end(impl::as_const(container_)), get_end(impl::as_const(container_)),
-        filter_func_};
+    return {get_end(impl::as_const(container_)),
+        get_end(impl::as_const(container_)), filter_func_};
   }
 };
 

From 2bd12d74061a9c3ca92e46e6de0a75e7635fe707 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 18 Nov 2017 10:28:39 -0600
Subject: [PATCH 1671/1866] updates max value description of count()

The doc description of hitting the max was old. fixed.
---
 README.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index 0d138f3d..6bf1907c 100644
--- a/README.md
+++ b/README.md
@@ -380,11 +380,11 @@ step of 1.<br />
 `count(i, st)` will start counting from `i` with a step of `st`.
 
 *Technical limitations*: Unlike Python which can use its long integer
-types when needed, count() will eventually exceed the
+types when needed, count() would eventually exceed the
 maximum possible value for its type (or minimum with a negative step).
-When using a signed type it is up to the API user to ensure this does
-not happen.  If the limit is exceeded for signed types, the result is
-undefined (as per the C++ standard).
+`count` is actually implemented as a `range` with the stopping point
+being the `std::numeric_limits<T>::max()` for the integral type (`long`
+by default)
 
 The below will print `0 1 2` ... etc
 ```c++

From f0f141cb9215f49ec65c0f306bde4c63a17d378c Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Fri, 5 Jan 2018 15:46:43 -0800
Subject: [PATCH 1672/1866] adds missing includes for <set>

---
 test/test_permutations.cpp | 1 +
 test/test_powerset.cpp     | 1 +
 2 files changed, 2 insertions(+)

diff --git a/test/test_permutations.cpp b/test/test_permutations.cpp
index b6b6fdae..5da85fc8 100644
--- a/test/test_permutations.cpp
+++ b/test/test_permutations.cpp
@@ -3,6 +3,7 @@
 #include "helpers.hpp"
 
 #include <iterator>
+#include <set>
 #include <string>
 #include <vector>
 
diff --git a/test/test_powerset.cpp b/test/test_powerset.cpp
index b56d43e0..c18dd1f7 100644
--- a/test/test_powerset.cpp
+++ b/test/test_powerset.cpp
@@ -5,6 +5,7 @@
 #undef CHAR_RANGE_DEFAULT_CONSTRUCTIBLE
 
 #include <iterator>
+#include <set>
 #include <string>
 #include <vector>
 

From f364ebb39f360327911f180cd20b737e98dda42f Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Fri, 5 Jan 2018 15:54:05 -0800
Subject: [PATCH 1673/1866] Adds files for bazel build

I didn't put in a test_all because you can just use bazel test :all
---
 .gitignore          |  1 +
 BUILD               | 42 ++++++++++++++++++++++++++++++++++++++++++
 WORKSPACE           |  0
 test/BUILD          | 39 +++++++++++++++++++++++++++++++++++++++
 test/make_tests.bzl |  8 ++++++++
 5 files changed, 90 insertions(+)
 create mode 100644 .gitignore
 create mode 100644 BUILD
 create mode 100644 WORKSPACE
 create mode 100644 test/BUILD
 create mode 100644 test/make_tests.bzl

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 00000000..ac51a054
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1 @@
+bazel-*
diff --git a/BUILD b/BUILD
new file mode 100644
index 00000000..8b162b86
--- /dev/null
+++ b/BUILD
@@ -0,0 +1,42 @@
+cc_library(
+    name = "cppitertools",
+    hdrs = [
+        "accumulate.hpp",
+        "chain.hpp",
+        "chunked.hpp",
+        "combinations.hpp",
+        "combinations_with_replacement.hpp",
+        "compress.hpp",
+        "count.hpp",
+        "cycle.hpp",
+        "dropwhile.hpp",
+        "enumerate.hpp",
+        "filter.hpp",
+        "filterfalse.hpp",
+        "groupby.hpp",
+        "imap.hpp",
+        "itertools.hpp",
+        "permutations.hpp",
+        "powerset.hpp",
+        "product.hpp",
+        "range.hpp",
+        "repeat.hpp",
+        "reversed.hpp",
+        "slice.hpp",
+        "sliding_window.hpp",
+        "sorted.hpp",
+        "starmap.hpp",
+        "takewhile.hpp",
+        "unique_everseen.hpp",
+        "unique_justseen.hpp",
+        "zip.hpp",
+        "zip_longest.hpp",
+    ],
+    srcs = [
+        "internal/iter_tuples.hpp",
+        "internal/iterator_wrapper.hpp",
+        "internal/iteratoriterator.hpp",
+        "internal/iterbase.hpp",
+    ],
+    visibility = ["//visibility:public"],
+)
diff --git a/WORKSPACE b/WORKSPACE
new file mode 100644
index 00000000..e69de29b
diff --git a/test/BUILD b/test/BUILD
new file mode 100644
index 00000000..c2206754
--- /dev/null
+++ b/test/BUILD
@@ -0,0 +1,39 @@
+load("make_tests", "itertools_tests")
+
+progs = [
+    "accumulate",
+    "chain",
+    "chunked",
+    "combinations",
+    "combinations_with_replacement",
+    "compress",
+    "count",
+    "cycle",
+    "dropwhile",
+    "enumerate",
+    "filter",
+    "filterfalse",
+    "groupby",
+    "imap",
+    "permutations",
+    "powerset",
+    "product",
+    "range",
+    "repeat",
+    "reversed",
+    "slice",
+    "sliding_window",
+    "starmap",
+    "sorted",
+    "takewhile",
+    "unique_everseen",
+    "unique_justseen",
+    "zip",
+    "iteratoriterator",
+    "iterator_wrapper",
+    "iterbase",
+    "mixed",
+    "helpers",
+]
+
+itertools_tests(progs)
diff --git a/test/make_tests.bzl b/test/make_tests.bzl
new file mode 100644
index 00000000..80919522
--- /dev/null
+++ b/test/make_tests.bzl
@@ -0,0 +1,8 @@
+def itertools_tests(progs):
+  for p in progs:
+    native.cc_test(
+        name = "test_{}".format(p),
+        srcs = ["test_{}.cpp".format(p), "test_main.cpp", "catch.hpp", "helpers.hpp"],
+        deps = ["//:cppitertools",],
+        copts = ["-I.",  "-std=c++14", "-Wall", "-Wextra", "-pedantic", "-g"],
+    )

From b8a37d75b05b283c21b18ec0d6c1f65f297dfbef Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Fri, 5 Jan 2018 15:46:43 -0800
Subject: [PATCH 1674/1866] adds missing includes for <set>

---
 test/test_permutations.cpp | 1 +
 test/test_powerset.cpp     | 1 +
 2 files changed, 2 insertions(+)

diff --git a/test/test_permutations.cpp b/test/test_permutations.cpp
index b6b6fdae..5da85fc8 100644
--- a/test/test_permutations.cpp
+++ b/test/test_permutations.cpp
@@ -3,6 +3,7 @@
 #include "helpers.hpp"
 
 #include <iterator>
+#include <set>
 #include <string>
 #include <vector>
 
diff --git a/test/test_powerset.cpp b/test/test_powerset.cpp
index b56d43e0..c18dd1f7 100644
--- a/test/test_powerset.cpp
+++ b/test/test_powerset.cpp
@@ -5,6 +5,7 @@
 #undef CHAR_RANGE_DEFAULT_CONSTRUCTIBLE
 
 #include <iterator>
+#include <set>
 #include <string>
 #include <vector>
 

From 37354c4da95c3c4776e99dc37f52b69cc972fb27 Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Fri, 5 Jan 2018 15:54:05 -0800
Subject: [PATCH 1675/1866] Adds files for bazel build

I didn't put in a test_all because you can just use bazel test :all
---
 .gitignore          |  1 +
 BUILD               | 42 ++++++++++++++++++++++++++++++++++++++++++
 WORKSPACE           |  0
 test/BUILD          | 39 +++++++++++++++++++++++++++++++++++++++
 test/make_tests.bzl |  8 ++++++++
 5 files changed, 90 insertions(+)
 create mode 100644 .gitignore
 create mode 100644 BUILD
 create mode 100644 WORKSPACE
 create mode 100644 test/BUILD
 create mode 100644 test/make_tests.bzl

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 00000000..ac51a054
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1 @@
+bazel-*
diff --git a/BUILD b/BUILD
new file mode 100644
index 00000000..8b162b86
--- /dev/null
+++ b/BUILD
@@ -0,0 +1,42 @@
+cc_library(
+    name = "cppitertools",
+    hdrs = [
+        "accumulate.hpp",
+        "chain.hpp",
+        "chunked.hpp",
+        "combinations.hpp",
+        "combinations_with_replacement.hpp",
+        "compress.hpp",
+        "count.hpp",
+        "cycle.hpp",
+        "dropwhile.hpp",
+        "enumerate.hpp",
+        "filter.hpp",
+        "filterfalse.hpp",
+        "groupby.hpp",
+        "imap.hpp",
+        "itertools.hpp",
+        "permutations.hpp",
+        "powerset.hpp",
+        "product.hpp",
+        "range.hpp",
+        "repeat.hpp",
+        "reversed.hpp",
+        "slice.hpp",
+        "sliding_window.hpp",
+        "sorted.hpp",
+        "starmap.hpp",
+        "takewhile.hpp",
+        "unique_everseen.hpp",
+        "unique_justseen.hpp",
+        "zip.hpp",
+        "zip_longest.hpp",
+    ],
+    srcs = [
+        "internal/iter_tuples.hpp",
+        "internal/iterator_wrapper.hpp",
+        "internal/iteratoriterator.hpp",
+        "internal/iterbase.hpp",
+    ],
+    visibility = ["//visibility:public"],
+)
diff --git a/WORKSPACE b/WORKSPACE
new file mode 100644
index 00000000..e69de29b
diff --git a/test/BUILD b/test/BUILD
new file mode 100644
index 00000000..c2206754
--- /dev/null
+++ b/test/BUILD
@@ -0,0 +1,39 @@
+load("make_tests", "itertools_tests")
+
+progs = [
+    "accumulate",
+    "chain",
+    "chunked",
+    "combinations",
+    "combinations_with_replacement",
+    "compress",
+    "count",
+    "cycle",
+    "dropwhile",
+    "enumerate",
+    "filter",
+    "filterfalse",
+    "groupby",
+    "imap",
+    "permutations",
+    "powerset",
+    "product",
+    "range",
+    "repeat",
+    "reversed",
+    "slice",
+    "sliding_window",
+    "starmap",
+    "sorted",
+    "takewhile",
+    "unique_everseen",
+    "unique_justseen",
+    "zip",
+    "iteratoriterator",
+    "iterator_wrapper",
+    "iterbase",
+    "mixed",
+    "helpers",
+]
+
+itertools_tests(progs)
diff --git a/test/make_tests.bzl b/test/make_tests.bzl
new file mode 100644
index 00000000..80919522
--- /dev/null
+++ b/test/make_tests.bzl
@@ -0,0 +1,8 @@
+def itertools_tests(progs):
+  for p in progs:
+    native.cc_test(
+        name = "test_{}".format(p),
+        srcs = ["test_{}.cpp".format(p), "test_main.cpp", "catch.hpp", "helpers.hpp"],
+        deps = ["//:cppitertools",],
+        copts = ["-I.",  "-std=c++14", "-Wall", "-Wextra", "-pedantic", "-g"],
+    )

From b8ce1c3c4659758fe0a096d743fef66362039868 Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Mon, 8 Jan 2018 09:08:41 -0800
Subject: [PATCH 1676/1866] std=c++17

---
 test/make_tests.bzl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/make_tests.bzl b/test/make_tests.bzl
index 80919522..883f0576 100644
--- a/test/make_tests.bzl
+++ b/test/make_tests.bzl
@@ -4,5 +4,5 @@ def itertools_tests(progs):
         name = "test_{}".format(p),
         srcs = ["test_{}.cpp".format(p), "test_main.cpp", "catch.hpp", "helpers.hpp"],
         deps = ["//:cppitertools",],
-        copts = ["-I.",  "-std=c++14", "-Wall", "-Wextra", "-pedantic", "-g"],
+        copts = ["-I.",  "-std=c++17", "-Wall", "-Wextra", "-pedantic", "-g"],
     )

From f1c222a6a59cf66c0411c3f07966bbd6c2b4befd Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Mon, 8 Jan 2018 09:19:19 -0800
Subject: [PATCH 1677/1866] Switches catch download link to use catchorg

---
 test/download_catch.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/download_catch.sh b/test/download_catch.sh
index f88f5643..2988d1b6 100755
--- a/test/download_catch.sh
+++ b/test/download_catch.sh
@@ -1,2 +1,2 @@
 #!/usr/bin/env sh
-wget -c https://raw.githubusercontent.com/philsquared/Catch/master/single_include/catch.hpp
+wget -c https://github.com/catchorg/Catch2/releases/download/v2.0.1/catch.hpp

From 542b6c1b3a3bdd6416198e5a4128e792654a3a37 Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Mon, 8 Jan 2018 09:19:19 -0800
Subject: [PATCH 1678/1866] Switches catch download link to use catchorg

---
 test/download_catch.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/download_catch.sh b/test/download_catch.sh
index f88f5643..2988d1b6 100755
--- a/test/download_catch.sh
+++ b/test/download_catch.sh
@@ -1,2 +1,2 @@
 #!/usr/bin/env sh
-wget -c https://raw.githubusercontent.com/philsquared/Catch/master/single_include/catch.hpp
+wget -c https://github.com/catchorg/Catch2/releases/download/v2.0.1/catch.hpp

From 16e31a042922e5bc93726a1f66987ebdbd5cd7f0 Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Mon, 8 Jan 2018 10:35:35 -0800
Subject: [PATCH 1679/1866] if constexpr instead of tag dispatch in sign check

also some formatting got in there
---
 range.hpp | 51 ++++++++++++++++++++++-----------------------------
 1 file changed, 22 insertions(+), 29 deletions(-)

diff --git a/range.hpp b/range.hpp
index 348fd9ab..145cdfab 100644
--- a/range.hpp
+++ b/range.hpp
@@ -37,8 +37,7 @@ namespace iter {
      public:
       constexpr RangeIterData() noexcept = default;
       constexpr RangeIterData(T in_value, T in_step) noexcept
-          : value_{in_value},
-            step_{in_step} {}
+          : value_{in_value}, step_{in_step} {}
 
       constexpr T value() const noexcept {
         return value_;
@@ -73,9 +72,7 @@ namespace iter {
      public:
       constexpr RangeIterData() noexcept = default;
       constexpr RangeIterData(T in_start, T in_step) noexcept
-          : start_{in_start},
-            value_{in_start},
-            step_{in_step} {}
+          : start_{in_start}, value_{in_start}, step_{in_step} {}
 
       constexpr T value() const noexcept {
         return value_;
@@ -123,9 +120,8 @@ class iter::impl::Range {
 
   constexpr Range(T stop) noexcept : start_{0}, stop_{stop}, step_{1} {}
 
-  constexpr Range(T start, T stop, T step = 1) noexcept : start_{start},
-                                                          stop_{stop},
-                                                          step_{step} {}
+  constexpr Range(T start, T stop, T step = 1) noexcept
+      : start_{start}, stop_{stop}, step_{step} {}
 
  public:
   // the reference type here is T, which doesn't strictly follow all
@@ -138,39 +134,36 @@ class iter::impl::Range {
     iter::detail::RangeIterData<T> data;
     bool is_end;
 
-    // compare unsigned values
-    static bool not_equal_to_impl(const Iterator& iter,
-        const Iterator& end_iter, std::true_type) noexcept {
-      assert(!iter.is_end);
-      assert(end_iter.is_end);
-      return iter.data.value() < end_iter.data.value();
-    }
-
-    // compare signed values
-    static bool not_equal_to_impl(const Iterator& iter,
-        const Iterator& end_iter, std::false_type) noexcept {
-      assert(!iter.is_end);
-      assert(end_iter.is_end);
-      return !(iter.data.step() > 0
-                 && iter.data.value() >= end_iter.data.value())
-             && !(iter.data.step() < 0
-                    && iter.data.value() <= end_iter.data.value());
+    // first argument must be regular iterator
+    // second argument must be end iterator
+    static bool not_equal_to_impl(
+        const Iterator& lhs, const Iterator& rhs) noexcept {
+      assert(!lhs.is_end);
+      assert(rhs.is_end);
+      if
+        constexpr(std::is_unsigned<T>{}) {
+          return lhs.data.value() < rhs.data.value();
+        }
+      else {
+        return !(lhs.data.step() > 0 && lhs.data.value() >= rhs.data.value())
+               && !(lhs.data.step() < 0
+                      && lhs.data.value() <= rhs.data.value());
+      }
     }
 
     static bool not_equal_to_end(
         const Iterator& lhs, const Iterator& rhs) noexcept {
       if (rhs.is_end) {
-        return not_equal_to_impl(lhs, rhs, std::is_unsigned<T>{});
+        return not_equal_to_impl(lhs, rhs);
       }
-      return not_equal_to_impl(rhs, lhs, std::is_unsigned<T>{});
+      return not_equal_to_impl(rhs, lhs);
     }
 
    public:
     constexpr Iterator() noexcept = default;
 
     constexpr Iterator(T in_value, T in_step, bool in_is_end) noexcept
-        : data(in_value, in_step),
-          is_end{in_is_end} {}
+        : data(in_value, in_step), is_end{in_is_end} {}
 
     constexpr T operator*() const noexcept {
       return data.value();

From bde4cfb44ed44e4b767595c04c45003199e69aa7 Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Mon, 8 Jan 2018 10:52:03 -0800
Subject: [PATCH 1680/1866] if constexpr instead of tag dispatch

Instead of tag dispatching on whether something is tuple-like, constexpr
if on it instead.
---
 starmap.hpp | 29 ++++++++++-------------------
 1 file changed, 10 insertions(+), 19 deletions(-)

diff --git a/starmap.hpp b/starmap.hpp
index 08829d15..e83fbb24 100644
--- a/starmap.hpp
+++ b/starmap.hpp
@@ -217,34 +217,25 @@ struct iter::impl::StarMapFn : PipeableAndBindFirst<StarMapFn> {
     return {std::move(func), std::forward<TupType>(tup)};
   }
 
-  // handles tuple-like types
-  template <typename Func, typename TupType>
-  auto helper(Func func, TupType&& tup, std::true_type) const {
-    return helper_with_tuples(std::move(func), std::forward<TupType>(tup),
-        std::make_index_sequence<std::tuple_size<std::decay_t<TupType>>::
-                                      value>{});
-  }
-
-  // handles everything else
-  template <typename Func, typename Container>
-  StarMapper<Func, Container> helper(
-      Func func, Container&& container, std::false_type) const {
-    return {std::move(func), std::forward<Container>(container)};
-  }
-
   template <typename T, typename = void>
-  struct is_tuple_like : public std::false_type {};
+  struct is_tuple_like : std::false_type {};
 
   template <typename T>
   struct is_tuple_like<T,
       std::void_t<decltype(std::tuple_size<std::decay_t<T>>::value)>>
-      : public std::true_type {};
+      : std::true_type {};
 
  public:
   template <typename Func, typename Seq>
   auto operator()(Func func, Seq&& sequence) const {
-    return helper(
-        std::move(func), std::forward<Seq>(sequence), is_tuple_like<Seq>{});
+    if constexpr (is_tuple_like<Seq>{}) {
+      return helper_with_tuples(std::move(func), std::forward<Seq>(sequence),
+          std::make_index_sequence<std::tuple_size<std::decay_t<Seq>>::
+                  value>{});
+    } else {
+      return StarMapper<Func, Seq>{
+          std::move(func), std::forward<Seq>(sequence)};
+    }
   }
 
   using PipeableAndBindFirst<StarMapFn>::operator();

From e8fe728f123869d1ee4fa70896603c7bfa23368f Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 4 Mar 2018 20:20:16 -0500
Subject: [PATCH 1681/1866] Adds : and .bzl to build rule

---
 test/BUILD | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/BUILD b/test/BUILD
index c2206754..5c7c5d9c 100644
--- a/test/BUILD
+++ b/test/BUILD
@@ -1,4 +1,4 @@
-load("make_tests", "itertools_tests")
+load(":make_tests.bzl", "itertools_tests")
 
 progs = [
     "accumulate",

From 46b625916359f5fc031d16f22559335de25efe34 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 4 Mar 2018 20:20:16 -0500
Subject: [PATCH 1682/1866] Adds : and .bzl to build rule

---
 test/BUILD | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/BUILD b/test/BUILD
index c2206754..5c7c5d9c 100644
--- a/test/BUILD
+++ b/test/BUILD
@@ -1,4 +1,4 @@
-load("make_tests", "itertools_tests")
+load(":make_tests.bzl", "itertools_tests")
 
 progs = [
     "accumulate",

From 940d06716ac7a21d727f8e5d95ba25e35ef3d2d9 Mon Sep 17 00:00:00 2001
From: Nikolas Vanderhoof <nikolasrvanderhoof@gmail.com>
Date: Sun, 4 Mar 2018 22:19:35 -0500
Subject: [PATCH 1683/1866] Remove use of std::iterator

---
 accumulate.hpp                    |  8 +++++++-
 chain.hpp                         | 18 ++++++++++++++----
 chunked.hpp                       |  9 +++++++--
 combinations.hpp                  |  9 +++++++--
 combinations_with_replacement.hpp |  9 +++++++--
 compress.hpp                      |  9 +++++++--
 cycle.hpp                         |  9 +++++++--
 dropwhile.hpp                     |  9 +++++++--
 enumerate.hpp                     |  9 +++++++--
 filter.hpp                        |  9 +++++++--
 groupby.hpp                       | 18 ++++++++++++++----
 internal/iteratoriterator.hpp     | 10 ++++++----
 permutations.hpp                  |  9 +++++++--
 powerset.hpp                      |  9 +++++++--
 product.hpp                       | 17 ++++++++++++++---
 range.hpp                         |  9 +++++++--
 repeat.hpp                        | 16 ++++++++++++++--
 reversed.hpp                      |  9 +++++++--
 slice.hpp                         |  9 +++++++--
 sliding_window.hpp                |  9 +++++++--
 starmap.hpp                       | 18 ++++++++++++++----
 takewhile.hpp                     |  9 +++++++--
 zip.hpp                           |  9 +++++++--
 zip_longest.hpp                   |  9 +++++++--
 24 files changed, 202 insertions(+), 56 deletions(-)

diff --git a/accumulate.hpp b/accumulate.hpp
index 25440d58..3e419d8b 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -39,7 +39,7 @@ class iter::impl::Accumulator {
   Accumulator(Accumulator&&) = default;
 
   template <typename ContainerT>
-  class Iterator : public std::iterator<std::input_iterator_tag, AccumVal> {
+  class Iterator {
    private:
     template <typename>
     friend class Iterator;
@@ -49,6 +49,12 @@ class iter::impl::Accumulator {
     std::unique_ptr<AccumVal> acc_val_;
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = AccumVal;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(IteratorWrapper<ContainerT>&& sub_iter,
         IteratorWrapper<ContainerT>&& sub_end, AccumulateFunc& accumulate_fun)
         : sub_iter_{std::move(sub_iter)},
diff --git a/chain.hpp b/chain.hpp
index 1f840903..64aeb19d 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -100,8 +100,7 @@ class iter::impl::Chained {
   Chained(Chained&&) = default;
 
   template <typename TupTypeT>
-  class Iterator : public std::iterator<std::input_iterator_tag,
-                       typename IteratorData<TupTypeT>::TraitsValue> {
+  class Iterator {
    private:
     using IterData = IteratorData<TupTypeT>;
     std::size_t index_;
@@ -116,6 +115,12 @@ class iter::impl::Chained {
     }
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = typename IteratorData<TupTypeT>::TraitsValue;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(std::size_t i, typename IterData::IterTupType&& iters,
         typename IterData::IterTupType&& ends)
         : index_{i}, iters_(std::move(iters)), ends_(std::move(ends)) {
@@ -224,8 +229,7 @@ class iter::impl::ChainedFromIterable {
  public:
   ChainedFromIterable(ChainedFromIterable&&) = default;
   template <typename ContainerT>
-  class Iterator : public std::iterator<std::input_iterator_tag,
-                       iterator_traits_deref<iterator_deref<ContainerT>>> {
+  class Iterator {
    private:
     template <typename>
     friend class Iterator;
@@ -257,6 +261,12 @@ class iter::impl::ChainedFromIterable {
     }
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = iterator_traits_deref<iterator_deref<ContainerT>>;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(IteratorWrapper<ContainerT>&& top_iter,
         IteratorWrapper<ContainerT>&& top_end)
         : top_level_iter_{std::move(top_iter)},
diff --git a/chunked.hpp b/chunked.hpp
index 06f0a2aa..33d194d1 100644
--- a/chunked.hpp
+++ b/chunked.hpp
@@ -41,8 +41,7 @@ class iter::impl::Chunker {
  public:
   Chunker(Chunker&&) = default;
   template <typename ContainerT>
-  class Iterator
-      : public std::iterator<std::input_iterator_tag, DerefVec<ContainerT>> {
+  class Iterator {
    private:
     template <typename>
     friend class Iterator;
@@ -66,6 +65,12 @@ class iter::impl::Chunker {
     }
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = DerefVec<ContainerT>;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(IteratorWrapper<ContainerT>&& sub_iter,
         IteratorWrapper<ContainerT>&& sub_end, std::size_t s)
         : sub_iter_{std::move(sub_iter)},
diff --git a/combinations.hpp b/combinations.hpp
index 163fa678..afdefe4a 100644
--- a/combinations.hpp
+++ b/combinations.hpp
@@ -37,8 +37,7 @@ class iter::impl::Combinator {
  public:
   Combinator(Combinator&&) = default;
   template <typename ContainerT>
-  class Iterator : public std::iterator<std::input_iterator_tag,
-                       CombIteratorDeref<ContainerT>> {
+  class Iterator {
    private:
     template <typename>
     friend class Iterator;
@@ -48,6 +47,12 @@ class iter::impl::Combinator {
     int steps_{};
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = CombIteratorDeref<ContainerT>;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(ContainerT& container, std::size_t n)
         : container_p_{&container}, indices_{n} {
       if (n == 0) {
diff --git a/combinations_with_replacement.hpp b/combinations_with_replacement.hpp
index cc76e250..5b26f4ed 100644
--- a/combinations_with_replacement.hpp
+++ b/combinations_with_replacement.hpp
@@ -37,8 +37,7 @@ class iter::impl::CombinatorWithReplacement {
  public:
   CombinatorWithReplacement(CombinatorWithReplacement&&) = default;
   template <typename ContainerT>
-  class Iterator : public std::iterator<std::input_iterator_tag,
-                       CombIteratorDeref<ContainerT>> {
+  class Iterator {
    private:
     template <typename>
     friend class Iterator;
@@ -48,6 +47,12 @@ class iter::impl::CombinatorWithReplacement {
     int steps_;
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = CombIteratorDeref<ContainerT>;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(ContainerT& in_container, std::size_t n)
         : container_p_{&in_container},
           indices_(n, get_begin(in_container)),
diff --git a/compress.hpp b/compress.hpp
index 5ebc97ff..60a48244 100644
--- a/compress.hpp
+++ b/compress.hpp
@@ -33,8 +33,7 @@ class iter::impl::Compressed {
  public:
   Compressed(Compressed&&) = default;
   template <typename ContainerT, typename SelectorT>
-  class Iterator : public std::iterator<std::input_iterator_tag,
-                       iterator_traits_deref<ContainerT>> {
+  class Iterator {
    private:
     template <typename, typename>
     friend class Iterator;
@@ -57,6 +56,12 @@ class iter::impl::Compressed {
     }
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = iterator_traits_deref<ContainerT>;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(IteratorWrapper<ContainerT>&& cont_iter,
         IteratorWrapper<ContainerT>&& cont_end,
         IteratorWrapper<SelectorT>&& sel_iter,
diff --git a/cycle.hpp b/cycle.hpp
index c6ee4662..30cbefb0 100644
--- a/cycle.hpp
+++ b/cycle.hpp
@@ -31,8 +31,7 @@ class iter::impl::Cycler {
  public:
   Cycler(Cycler&&) = default;
   template <typename ContainerT>
-  class Iterator : public std::iterator<std::input_iterator_tag,
-                       iterator_traits_deref<ContainerT>> {
+  class Iterator {
    private:
     template <typename>
     friend class Iterator;
@@ -41,6 +40,12 @@ class iter::impl::Cycler {
     IteratorWrapper<ContainerT> sub_end_;
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = iterator_traits_deref<ContainerT>;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(IteratorWrapper<ContainerT>&& sub_iter,
         IteratorWrapper<ContainerT>&& sub_end)
         : sub_iter_{sub_iter},
diff --git a/dropwhile.hpp b/dropwhile.hpp
index 1a23c823..939f696e 100644
--- a/dropwhile.hpp
+++ b/dropwhile.hpp
@@ -33,8 +33,7 @@ class iter::impl::Dropper {
  public:
   Dropper(Dropper&&) = default;
   template <typename ContainerT>
-  class Iterator : public std::iterator<std::input_iterator_tag,
-                       iterator_traits_deref<ContainerT>> {
+  class Iterator {
    private:
     template <typename>
     friend class Iterator;
@@ -59,6 +58,12 @@ class iter::impl::Dropper {
     }
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = iterator_traits_deref<ContainerT>;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(IteratorWrapper<ContainerT>&& sub_iter,
         IteratorWrapper<ContainerT>&& sub_end, FilterFunc& filter_func)
         : sub_iter_{std::move(sub_iter)},
diff --git a/enumerate.hpp b/enumerate.hpp
index 05230525..8a7bc97e 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -68,8 +68,7 @@ class iter::impl::Enumerable {
   //  index_.  Each call to ++ increments both of these data members.
   //  Each dereference returns an IterYield.
   template <typename ContainerT>
-  class Iterator
-      : public std::iterator<std::input_iterator_tag, IterYield<ContainerT>> {
+  class Iterator {
    private:
     template <typename>
     friend class Iterator;
@@ -77,6 +76,12 @@ class iter::impl::Enumerable {
     Index index_;
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = IterYield<ContainerT>;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(IteratorWrapper<ContainerT>&& sub_iter, Index start)
         : sub_iter_{std::move(sub_iter)}, index_{start} {}
 
diff --git a/filter.hpp b/filter.hpp
index b92c2ce3..a8c04004 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -44,8 +44,7 @@ class iter::impl::Filtered {
   Filtered(Filtered&&) = default;
 
   template <typename ContainerT>
-  class Iterator : public std::iterator<std::input_iterator_tag,
-                       iterator_traits_deref<ContainerT>> {
+  class Iterator {
    protected:
     template <typename>
     friend class Iterator;
@@ -71,6 +70,12 @@ class iter::impl::Filtered {
     }
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = iterator_traits_deref<ContainerT>;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(IteratorWrapper<ContainerT>&& sub_iter,
         IteratorWrapper<ContainerT>&& sub_end, FilterFunc& filter_func)
         : sub_iter_{std::move(sub_iter)},
diff --git a/groupby.hpp b/groupby.hpp
index 12a0e471..d0d9276b 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -58,8 +58,7 @@ class iter::impl::GroupProducer {
 
  public:
   template <typename ContainerT>
-  class Iterator : public std::iterator<std::input_iterator_tag,
-                       KeyGroupPair<ContainerT>> {
+  class Iterator {
    private:
     template <typename>
     friend class Iterator;
@@ -70,6 +69,12 @@ class iter::impl::GroupProducer {
     std::unique_ptr<KeyGroupPair<ContainerT>> current_key_group_pair_;
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = KeyGroupPair<ContainerT>;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(IteratorWrapper<ContainerT>&& sub_iter,
         IteratorWrapper<ContainerT>&& sub_end, KeyFunc& key_func)
         : sub_iter_{std::move(sub_iter)},
@@ -208,8 +213,7 @@ class iter::impl::GroupProducer {
       other.completed = true;
     }
 
-    class GroupIterator : public std::iterator<std::input_iterator_tag,
-                              iterator_traits_deref<ContainerT>> {
+    class GroupIterator {
      private:
       std::remove_reference_t<key_func_ret<ContainerT>>* key_;
       Group* group_p_;
@@ -220,6 +224,12 @@ class iter::impl::GroupProducer {
       }
 
      public:
+      using iterator_category = std::input_iterator_tag;
+      using value_type = iterator_traits_deref<ContainerT>;
+      using difference_type = std::ptrdiff_t;
+      using pointer = value_type*;
+      using reference = value_type&;
+
       // TODO template this? idk if it's relevant here
       GroupIterator(Group* group_p, key_func_ret<ContainerT>& key)
           : key_{&key}, group_p_{group_p} {}
diff --git a/internal/iteratoriterator.hpp b/internal/iteratoriterator.hpp
index 70d63481..af7ceefc 100644
--- a/internal/iteratoriterator.hpp
+++ b/internal/iteratoriterator.hpp
@@ -23,10 +23,7 @@ namespace iter {
         : std::true_type {};
 
     template <typename TopIter>
-    class IteratorIterator
-        : public std::iterator<std::random_access_iterator_tag,
-              typename std::remove_reference<decltype(
-                  **std::declval<TopIter>())>::type> {
+    class IteratorIterator {
       template <typename> friend class IteratorIterator;
       using Diff = std::ptrdiff_t;
       static_assert(
@@ -39,6 +36,11 @@ namespace iter {
       TopIter sub_iter;
 
      public:
+      using iterator_category = std::random_access_iterator_tag;
+      using value_type = std::remove_reference_t<decltype(**std::declval<TopIter>())>;
+      using difference_type = std::ptrdiff_t;
+      using pointer = value_type*;
+      using reference = value_type&;
       IteratorIterator() = default;
       IteratorIterator(const TopIter& it) : sub_iter{it} {}
 
diff --git a/permutations.hpp b/permutations.hpp
index 39c073e5..40945040 100644
--- a/permutations.hpp
+++ b/permutations.hpp
@@ -38,8 +38,7 @@ class iter::impl::Permuter {
   Permuter(Permuter&&) = default;
 
   template <typename ContainerT>
-  class Iterator
-      : public std::iterator<std::input_iterator_tag, Permutable<ContainerT>> {
+  class Iterator {
    private:
     template <typename>
     friend class Iterator;
@@ -53,6 +52,12 @@ class iter::impl::Permuter {
     int steps_{};
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = Permutable<ContainerT>;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(IteratorWrapper<ContainerT>&& sub_iter,
         IteratorWrapper<ContainerT>&& sub_end)
         : steps_{sub_iter != sub_end ? 0 : COMPLETE} {
diff --git a/powerset.hpp b/powerset.hpp
index 8e5278f4..af270634 100644
--- a/powerset.hpp
+++ b/powerset.hpp
@@ -37,8 +37,7 @@ class iter::impl::Powersetter {
   Powersetter(Powersetter&&) = default;
 
   template <typename ContainerT>
-  class Iterator : public std::iterator<std::input_iterator_tag,
-                       CombinatorType<ContainerT>> {
+  class Iterator {
    private:
 #if 0
     template <typename> friend class Iterator;
@@ -50,6 +49,12 @@ class iter::impl::Powersetter {
     iterator_type<CombinatorType<ContainerT>> comb_end_;
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = CombinatorType<ContainerT>;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(ContainerT& container, std::size_t sz)
         : container_p_{&container},
           set_size_{sz},
diff --git a/product.hpp b/product.hpp
index 9f4d9dc7..af3deea6 100644
--- a/product.hpp
+++ b/product.hpp
@@ -50,8 +50,7 @@ class iter::impl::Productor<Container, RestContainers...> {
 
  private:
   template <typename ContainerT, typename RestIter>
-  class IteratorTempl : public std::iterator<std::input_iterator_tag,
-                            ProdIterDeref<ContainerT>> {
+  class IteratorTempl {
    private:
     template <typename, typename>
     friend class IteratorTempl;
@@ -62,6 +61,12 @@ class iter::impl::Productor<Container, RestContainers...> {
     RestIter rest_end_;
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = ProdIterDeref<ContainerT>;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     constexpr static const bool is_base_iter = false;
     IteratorTempl(IteratorWrapper<ContainerT>&& sub_iter, RestIter&& rest_iter,
         RestIter&& rest_end)
@@ -144,8 +149,14 @@ template <>
 class iter::impl::Productor<> {
  public:
   Productor(Productor&&) = default;
-  class Iterator : public std::iterator<std::input_iterator_tag, std::tuple<>> {
+  class Iterator {
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = std::tuple<>;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     constexpr static const bool is_base_iter = true;
 
     void reset() {}
diff --git a/range.hpp b/range.hpp
index 348fd9ab..c71a6854 100644
--- a/range.hpp
+++ b/range.hpp
@@ -132,8 +132,7 @@ class iter::impl::Range {
   // of the rules, but std::vector<bool>::iterator::reference isn't
   // a reference type either, this isn't any worse
 
-  class Iterator : public std::iterator<std::forward_iterator_tag, T,
-                       std::ptrdiff_t, T*, T> {
+  class Iterator {
    private:
     iter::detail::RangeIterData<T> data;
     bool is_end;
@@ -166,6 +165,12 @@ class iter::impl::Range {
     }
 
    public:
+    using iterator_category = std::forward_iterator_tag;
+    using value_type = T;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     constexpr Iterator() noexcept = default;
 
     constexpr Iterator(T in_value, T in_step, bool in_is_end) noexcept
diff --git a/repeat.hpp b/repeat.hpp
index 1073d750..01739c6c 100644
--- a/repeat.hpp
+++ b/repeat.hpp
@@ -34,12 +34,18 @@ class iter::impl::RepeaterWithCount {
  public:
   RepeaterWithCount(RepeaterWithCount&&) = default;
 
-  class Iterator : public std::iterator<std::input_iterator_tag, const TPlain> {
+  class Iterator {
    private:
     const TPlain* elem_;
     int count_;
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = const TPlain;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     constexpr Iterator(const TPlain* e, int c) : elem_{e}, count_{c} {}
 
     Iterator& operator++() {
@@ -108,11 +114,17 @@ class iter::impl::Repeater {
  public:
   Repeater(Repeater&&) = default;
 
-  class Iterator : public std::iterator<std::input_iterator_tag, const TPlain> {
+  class Iterator {
    private:
     const TPlain* elem_;
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = const TPlain;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     constexpr Iterator(const TPlain* e) : elem_{e} {}
 
     constexpr const Iterator& operator++() const {
diff --git a/reversed.hpp b/reversed.hpp
index 08517fb7..b76ad801 100644
--- a/reversed.hpp
+++ b/reversed.hpp
@@ -71,14 +71,19 @@ class iter::impl::Reverser {
  public:
   Reverser(Reverser&&) = default;
   template <typename ContainerT>
-  class Iterator : public std::iterator<std::input_iterator_tag,
-                       reverse_iterator_traits_deref<ContainerT>> {
+  class Iterator {
    private:
     template <typename>
     friend class Iterator;
     ReverseIteratorWrapper<ContainerT> sub_iter_;
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = reverse_iterator_traits_deref<ContainerT>;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(ReverseIteratorWrapper<ContainerT>&& sub_iter)
         : sub_iter_{std::move(sub_iter)} {}
 
diff --git a/slice.hpp b/slice.hpp
index 59ea7885..53114943 100644
--- a/slice.hpp
+++ b/slice.hpp
@@ -36,8 +36,7 @@ class iter::impl::Sliced {
  public:
   Sliced(Sliced&&) = default;
   template <typename ContainerT>
-  class Iterator : public std::iterator<std::input_iterator_tag,
-                       iterator_traits_deref<ContainerT>> {
+  class Iterator {
    private:
     template <typename>
     friend class Iterator;
@@ -48,6 +47,12 @@ class iter::impl::Sliced {
     DifferenceType step_;
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = iterator_traits_deref<ContainerT>;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(IteratorWrapper<ContainerT>&& sub_iter,
         IteratorWrapper<ContainerT>&& sub_end, DifferenceType start,
         DifferenceType stop, DifferenceType step)
diff --git a/sliding_window.hpp b/sliding_window.hpp
index ae478de8..cf843894 100644
--- a/sliding_window.hpp
+++ b/sliding_window.hpp
@@ -37,8 +37,7 @@ class iter::impl::WindowSlider {
  public:
   WindowSlider(WindowSlider&&) = default;
   template <typename ContainerT>
-  class Iterator
-      : public std::iterator<std::input_iterator_tag, DerefVec<ContainerT>> {
+  class Iterator {
    private:
     template <typename>
     friend class Iterator;
@@ -46,6 +45,12 @@ class iter::impl::WindowSlider {
     DerefVec<ContainerT> window_;
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = DerefVec<ContainerT>;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(IteratorWrapper<ContainerT>&& sub_iter,
         IteratorWrapper<ContainerT>&& sub_end, std::size_t window_sz)
         : sub_iter_(std::move(sub_iter)) {
diff --git a/starmap.hpp b/starmap.hpp
index 27639195..66e2956a 100644
--- a/starmap.hpp
+++ b/starmap.hpp
@@ -44,8 +44,7 @@ class iter::impl::StarMapper {
 
  public:
   template <typename ContainerT>
-  class Iterator
-      : public std::iterator<std::input_iterator_tag, StarIterDeref> {
+  class Iterator {
    private:
     template <typename>
     friend class Iterator;
@@ -53,6 +52,12 @@ class iter::impl::StarMapper {
     IteratorWrapper<ContainerT> sub_iter_;
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = StarIterDeref;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(Func& f, IteratorWrapper<ContainerT>&& sub_iter)
         : func_(&f), sub_iter_(std::move(sub_iter)) {}
 
@@ -142,8 +147,7 @@ class iter::impl::TupleStarMapper {
 
  public:
   template <typename TupTypeT>
-  class Iterator : public std::iterator<std::input_iterator_tag,
-                       typename IteratorData<TupTypeT>::TraitsValue> {
+  class Iterator {
    private:
     template <typename>
     friend class Iterator;
@@ -152,6 +156,12 @@ class iter::impl::TupleStarMapper {
     std::size_t index_;
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = typename IteratorData<TupTypeT>::TraitsValue;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(Func& f, TupTypeT& t, std::size_t i)
         : func_{&f}, tup_{&t}, index_{i} {}
 
diff --git a/takewhile.hpp b/takewhile.hpp
index ad823b0d..eb0fd801 100644
--- a/takewhile.hpp
+++ b/takewhile.hpp
@@ -34,8 +34,7 @@ class iter::impl::Taker {
   Taker(Taker&&) = default;
 
   template <typename ContainerT>
-  class Iterator : public std::iterator<std::input_iterator_tag,
-                       iterator_traits_deref<ContainerT>> {
+  class Iterator {
    private:
     template <typename>
     friend class Iterator;
@@ -59,6 +58,12 @@ class iter::impl::Taker {
     }
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = iterator_traits_deref<ContainerT>;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(IteratorWrapper<ContainerT>&& sub_iter,
         IteratorWrapper<ContainerT>&& sub_end, FilterFunc& filter_func)
         : sub_iter_{std::move(sub_iter)},
diff --git a/zip.hpp b/zip.hpp
index 3bb4ccdb..a7f2f19d 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -40,14 +40,19 @@ class iter::impl::Zipped {
   // deref they'd need to be known in the function declarations below.
   template <typename TupleTypeT, template <typename> class IteratorTuple,
       template <typename> class TupleDeref>
-  class Iterator
-      : public std::iterator<std::input_iterator_tag, TupleDeref<TupleTypeT>> {
+  class Iterator {
    private:
     template <typename, template <typename> class, template <typename> class>
     friend class Iterator;
     IteratorTuple<TupleTypeT> iters_;
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = TupleDeref<TupleTypeT>;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(IteratorTuple<TupleTypeT>&& iters) : iters_(std::move(iters)) {}
 
     Iterator& operator++() {
diff --git a/zip_longest.hpp b/zip_longest.hpp
index eb73aaac..ba6ea3c5 100644
--- a/zip_longest.hpp
+++ b/zip_longest.hpp
@@ -49,8 +49,7 @@ class iter::impl::ZippedLongest {
   ZippedLongest(ZippedLongest&&) = default;
   template <typename TupleTypeT, template <typename> class IterTuple,
       template <std::size_t, typename> class OptTempl>
-  class Iterator : public std::iterator<std::input_iterator_tag,
-                       ZipIterDeref<TupleTypeT, OptTempl>> {
+  class Iterator {
    private:
     template <typename, template <typename> class,
         template <std::size_t, typename> class>
@@ -59,6 +58,12 @@ class iter::impl::ZippedLongest {
     IterTuple<TupleTypeT> ends_;
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = ZipIterDeref<TupleTypeT, OptTempl>;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(IterTuple<TupleTypeT>&& iters, IterTuple<TupleTypeT>&& ends)
         : iters_(std::move(iters)), ends_(std::move(ends)) {}
 

From 2914ce2c8339213ddfd977a66d3b057ec3b52d63 Mon Sep 17 00:00:00 2001
From: Nikolas Vanderhoof <nikolasrvanderhoof@gmail.com>
Date: Mon, 5 Mar 2018 04:39:15 -0500
Subject: [PATCH 1684/1866] Fix Range<T>::Iterator::reference

Range<T>::Iterator::reference == Range<T>::Iterator::value_type
---
 range.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/range.hpp b/range.hpp
index c71a6854..9287e5f2 100644
--- a/range.hpp
+++ b/range.hpp
@@ -169,7 +169,7 @@ class iter::impl::Range {
     using value_type = T;
     using difference_type = std::ptrdiff_t;
     using pointer = value_type*;
-    using reference = value_type&;
+    using reference = value_type;
 
     constexpr Iterator() noexcept = default;
 

From 10b332bc2823a5d2713322f2f73b8fbf19d6c394 Mon Sep 17 00:00:00 2001
From: Nikolas Vanderhoof <nikolasrvanderhoof@gmail.com>
Date: Sun, 4 Mar 2018 22:19:35 -0500
Subject: [PATCH 1685/1866] Remove use of std::iterator

---
 accumulate.hpp                    |  8 +++++++-
 chain.hpp                         | 18 ++++++++++++++----
 chunked.hpp                       |  9 +++++++--
 combinations.hpp                  |  9 +++++++--
 combinations_with_replacement.hpp |  9 +++++++--
 compress.hpp                      |  9 +++++++--
 cycle.hpp                         |  9 +++++++--
 dropwhile.hpp                     |  9 +++++++--
 enumerate.hpp                     |  9 +++++++--
 filter.hpp                        |  9 +++++++--
 groupby.hpp                       | 18 ++++++++++++++----
 internal/iteratoriterator.hpp     | 10 ++++++----
 permutations.hpp                  |  9 +++++++--
 powerset.hpp                      |  9 +++++++--
 product.hpp                       | 17 ++++++++++++++---
 range.hpp                         |  9 +++++++--
 repeat.hpp                        | 16 ++++++++++++++--
 reversed.hpp                      |  9 +++++++--
 slice.hpp                         |  9 +++++++--
 sliding_window.hpp                |  9 +++++++--
 starmap.hpp                       | 18 ++++++++++++++----
 takewhile.hpp                     |  9 +++++++--
 zip.hpp                           |  9 +++++++--
 zip_longest.hpp                   |  9 +++++++--
 24 files changed, 202 insertions(+), 56 deletions(-)

diff --git a/accumulate.hpp b/accumulate.hpp
index 7dd27120..f2210847 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -39,7 +39,7 @@ class iter::impl::Accumulator {
   Accumulator(Accumulator&&) = default;
 
   template <typename ContainerT>
-  class Iterator : public std::iterator<std::input_iterator_tag, AccumVal> {
+  class Iterator {
    private:
     template <typename>
     friend class Iterator;
@@ -49,6 +49,12 @@ class iter::impl::Accumulator {
     std::optional<AccumVal> acc_val_;
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = AccumVal;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(IteratorWrapper<ContainerT>&& sub_iter,
         IteratorWrapper<ContainerT>&& sub_end, AccumulateFunc& accumulate_fun)
         : sub_iter_{std::move(sub_iter)},
diff --git a/chain.hpp b/chain.hpp
index 2430d219..b3c0d5e9 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -100,8 +100,7 @@ class iter::impl::Chained {
   Chained(Chained&&) = default;
 
   template <typename TupTypeT>
-  class Iterator : public std::iterator<std::input_iterator_tag,
-                       typename IteratorData<TupTypeT>::TraitsValue> {
+  class Iterator {
    private:
     using IterData = IteratorData<TupTypeT>;
     std::size_t index_;
@@ -116,6 +115,12 @@ class iter::impl::Chained {
     }
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = typename IteratorData<TupTypeT>::TraitsValue;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(std::size_t i, typename IterData::IterTupType&& iters,
         typename IterData::IterTupType&& ends)
         : index_{i}, iters_(std::move(iters)), ends_(std::move(ends)) {
@@ -224,8 +229,7 @@ class iter::impl::ChainedFromIterable {
  public:
   ChainedFromIterable(ChainedFromIterable&&) = default;
   template <typename ContainerT>
-  class Iterator : public std::iterator<std::input_iterator_tag,
-                       iterator_traits_deref<iterator_deref<ContainerT>>> {
+  class Iterator {
    private:
     template <typename>
     friend class Iterator;
@@ -238,6 +242,12 @@ class iter::impl::ChainedFromIterable {
     std::optional<SubIter> sub_end_p_;
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = iterator_traits_deref<iterator_deref<ContainerT>>;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(IteratorWrapper<ContainerT>&& top_iter,
         IteratorWrapper<ContainerT>&& top_end)
         : top_level_iter_{std::move(top_iter)},
diff --git a/chunked.hpp b/chunked.hpp
index 06f0a2aa..33d194d1 100644
--- a/chunked.hpp
+++ b/chunked.hpp
@@ -41,8 +41,7 @@ class iter::impl::Chunker {
  public:
   Chunker(Chunker&&) = default;
   template <typename ContainerT>
-  class Iterator
-      : public std::iterator<std::input_iterator_tag, DerefVec<ContainerT>> {
+  class Iterator {
    private:
     template <typename>
     friend class Iterator;
@@ -66,6 +65,12 @@ class iter::impl::Chunker {
     }
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = DerefVec<ContainerT>;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(IteratorWrapper<ContainerT>&& sub_iter,
         IteratorWrapper<ContainerT>&& sub_end, std::size_t s)
         : sub_iter_{std::move(sub_iter)},
diff --git a/combinations.hpp b/combinations.hpp
index 163fa678..afdefe4a 100644
--- a/combinations.hpp
+++ b/combinations.hpp
@@ -37,8 +37,7 @@ class iter::impl::Combinator {
  public:
   Combinator(Combinator&&) = default;
   template <typename ContainerT>
-  class Iterator : public std::iterator<std::input_iterator_tag,
-                       CombIteratorDeref<ContainerT>> {
+  class Iterator {
    private:
     template <typename>
     friend class Iterator;
@@ -48,6 +47,12 @@ class iter::impl::Combinator {
     int steps_{};
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = CombIteratorDeref<ContainerT>;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(ContainerT& container, std::size_t n)
         : container_p_{&container}, indices_{n} {
       if (n == 0) {
diff --git a/combinations_with_replacement.hpp b/combinations_with_replacement.hpp
index cc76e250..5b26f4ed 100644
--- a/combinations_with_replacement.hpp
+++ b/combinations_with_replacement.hpp
@@ -37,8 +37,7 @@ class iter::impl::CombinatorWithReplacement {
  public:
   CombinatorWithReplacement(CombinatorWithReplacement&&) = default;
   template <typename ContainerT>
-  class Iterator : public std::iterator<std::input_iterator_tag,
-                       CombIteratorDeref<ContainerT>> {
+  class Iterator {
    private:
     template <typename>
     friend class Iterator;
@@ -48,6 +47,12 @@ class iter::impl::CombinatorWithReplacement {
     int steps_;
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = CombIteratorDeref<ContainerT>;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(ContainerT& in_container, std::size_t n)
         : container_p_{&in_container},
           indices_(n, get_begin(in_container)),
diff --git a/compress.hpp b/compress.hpp
index 5ebc97ff..60a48244 100644
--- a/compress.hpp
+++ b/compress.hpp
@@ -33,8 +33,7 @@ class iter::impl::Compressed {
  public:
   Compressed(Compressed&&) = default;
   template <typename ContainerT, typename SelectorT>
-  class Iterator : public std::iterator<std::input_iterator_tag,
-                       iterator_traits_deref<ContainerT>> {
+  class Iterator {
    private:
     template <typename, typename>
     friend class Iterator;
@@ -57,6 +56,12 @@ class iter::impl::Compressed {
     }
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = iterator_traits_deref<ContainerT>;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(IteratorWrapper<ContainerT>&& cont_iter,
         IteratorWrapper<ContainerT>&& cont_end,
         IteratorWrapper<SelectorT>&& sel_iter,
diff --git a/cycle.hpp b/cycle.hpp
index c6ee4662..30cbefb0 100644
--- a/cycle.hpp
+++ b/cycle.hpp
@@ -31,8 +31,7 @@ class iter::impl::Cycler {
  public:
   Cycler(Cycler&&) = default;
   template <typename ContainerT>
-  class Iterator : public std::iterator<std::input_iterator_tag,
-                       iterator_traits_deref<ContainerT>> {
+  class Iterator {
    private:
     template <typename>
     friend class Iterator;
@@ -41,6 +40,12 @@ class iter::impl::Cycler {
     IteratorWrapper<ContainerT> sub_end_;
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = iterator_traits_deref<ContainerT>;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(IteratorWrapper<ContainerT>&& sub_iter,
         IteratorWrapper<ContainerT>&& sub_end)
         : sub_iter_{sub_iter},
diff --git a/dropwhile.hpp b/dropwhile.hpp
index 1a23c823..939f696e 100644
--- a/dropwhile.hpp
+++ b/dropwhile.hpp
@@ -33,8 +33,7 @@ class iter::impl::Dropper {
  public:
   Dropper(Dropper&&) = default;
   template <typename ContainerT>
-  class Iterator : public std::iterator<std::input_iterator_tag,
-                       iterator_traits_deref<ContainerT>> {
+  class Iterator {
    private:
     template <typename>
     friend class Iterator;
@@ -59,6 +58,12 @@ class iter::impl::Dropper {
     }
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = iterator_traits_deref<ContainerT>;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(IteratorWrapper<ContainerT>&& sub_iter,
         IteratorWrapper<ContainerT>&& sub_end, FilterFunc& filter_func)
         : sub_iter_{std::move(sub_iter)},
diff --git a/enumerate.hpp b/enumerate.hpp
index 05230525..8a7bc97e 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -68,8 +68,7 @@ class iter::impl::Enumerable {
   //  index_.  Each call to ++ increments both of these data members.
   //  Each dereference returns an IterYield.
   template <typename ContainerT>
-  class Iterator
-      : public std::iterator<std::input_iterator_tag, IterYield<ContainerT>> {
+  class Iterator {
    private:
     template <typename>
     friend class Iterator;
@@ -77,6 +76,12 @@ class iter::impl::Enumerable {
     Index index_;
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = IterYield<ContainerT>;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(IteratorWrapper<ContainerT>&& sub_iter, Index start)
         : sub_iter_{std::move(sub_iter)}, index_{start} {}
 
diff --git a/filter.hpp b/filter.hpp
index b92c2ce3..a8c04004 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -44,8 +44,7 @@ class iter::impl::Filtered {
   Filtered(Filtered&&) = default;
 
   template <typename ContainerT>
-  class Iterator : public std::iterator<std::input_iterator_tag,
-                       iterator_traits_deref<ContainerT>> {
+  class Iterator {
    protected:
     template <typename>
     friend class Iterator;
@@ -71,6 +70,12 @@ class iter::impl::Filtered {
     }
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = iterator_traits_deref<ContainerT>;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(IteratorWrapper<ContainerT>&& sub_iter,
         IteratorWrapper<ContainerT>&& sub_end, FilterFunc& filter_func)
         : sub_iter_{std::move(sub_iter)},
diff --git a/groupby.hpp b/groupby.hpp
index 8ea482f1..4f4255eb 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -59,8 +59,7 @@ class iter::impl::GroupProducer {
 
  public:
   template <typename ContainerT>
-  class Iterator : public std::iterator<std::input_iterator_tag,
-                       KeyGroupPair<ContainerT>> {
+  class Iterator {
    private:
     template <typename>
     friend class Iterator;
@@ -71,6 +70,12 @@ class iter::impl::GroupProducer {
     std::optional<KeyGroupPair<ContainerT>> current_key_group_pair_;
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = KeyGroupPair<ContainerT>;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(IteratorWrapper<ContainerT>&& sub_iter,
         IteratorWrapper<ContainerT>&& sub_end, KeyFunc& key_func)
         : sub_iter_{std::move(sub_iter)},
@@ -209,8 +214,7 @@ class iter::impl::GroupProducer {
       other.completed = true;
     }
 
-    class GroupIterator : public std::iterator<std::input_iterator_tag,
-                              iterator_traits_deref<ContainerT>> {
+    class GroupIterator {
      private:
       std::remove_reference_t<key_func_ret<ContainerT>>* key_;
       Group* group_p_;
@@ -221,6 +225,12 @@ class iter::impl::GroupProducer {
       }
 
      public:
+      using iterator_category = std::input_iterator_tag;
+      using value_type = iterator_traits_deref<ContainerT>;
+      using difference_type = std::ptrdiff_t;
+      using pointer = value_type*;
+      using reference = value_type&;
+
       // TODO template this? idk if it's relevant here
       GroupIterator(Group* group_p, key_func_ret<ContainerT>& key)
           : key_{&key}, group_p_{group_p} {}
diff --git a/internal/iteratoriterator.hpp b/internal/iteratoriterator.hpp
index cfddac5b..87ed74d1 100644
--- a/internal/iteratoriterator.hpp
+++ b/internal/iteratoriterator.hpp
@@ -23,10 +23,7 @@ namespace iter {
         : std::true_type {};
 
     template <typename TopIter>
-    class IteratorIterator
-        : public std::iterator<std::random_access_iterator_tag,
-              typename std::remove_reference<decltype(
-                  **std::declval<TopIter>())>::type> {
+    class IteratorIterator {
       template <typename> friend class IteratorIterator;
       using Diff = std::ptrdiff_t;
       static_assert(
@@ -39,6 +36,11 @@ namespace iter {
       TopIter sub_iter;
 
      public:
+      using iterator_category = std::random_access_iterator_tag;
+      using value_type = std::remove_reference_t<decltype(**std::declval<TopIter>())>;
+      using difference_type = std::ptrdiff_t;
+      using pointer = value_type*;
+      using reference = value_type&;
       IteratorIterator() = default;
       IteratorIterator(const TopIter& it) : sub_iter{it} {}
 
diff --git a/permutations.hpp b/permutations.hpp
index 39c073e5..40945040 100644
--- a/permutations.hpp
+++ b/permutations.hpp
@@ -38,8 +38,7 @@ class iter::impl::Permuter {
   Permuter(Permuter&&) = default;
 
   template <typename ContainerT>
-  class Iterator
-      : public std::iterator<std::input_iterator_tag, Permutable<ContainerT>> {
+  class Iterator {
    private:
     template <typename>
     friend class Iterator;
@@ -53,6 +52,12 @@ class iter::impl::Permuter {
     int steps_{};
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = Permutable<ContainerT>;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(IteratorWrapper<ContainerT>&& sub_iter,
         IteratorWrapper<ContainerT>&& sub_end)
         : steps_{sub_iter != sub_end ? 0 : COMPLETE} {
diff --git a/powerset.hpp b/powerset.hpp
index 8e5278f4..af270634 100644
--- a/powerset.hpp
+++ b/powerset.hpp
@@ -37,8 +37,7 @@ class iter::impl::Powersetter {
   Powersetter(Powersetter&&) = default;
 
   template <typename ContainerT>
-  class Iterator : public std::iterator<std::input_iterator_tag,
-                       CombinatorType<ContainerT>> {
+  class Iterator {
    private:
 #if 0
     template <typename> friend class Iterator;
@@ -50,6 +49,12 @@ class iter::impl::Powersetter {
     iterator_type<CombinatorType<ContainerT>> comb_end_;
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = CombinatorType<ContainerT>;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(ContainerT& container, std::size_t sz)
         : container_p_{&container},
           set_size_{sz},
diff --git a/product.hpp b/product.hpp
index 9f4d9dc7..af3deea6 100644
--- a/product.hpp
+++ b/product.hpp
@@ -50,8 +50,7 @@ class iter::impl::Productor<Container, RestContainers...> {
 
  private:
   template <typename ContainerT, typename RestIter>
-  class IteratorTempl : public std::iterator<std::input_iterator_tag,
-                            ProdIterDeref<ContainerT>> {
+  class IteratorTempl {
    private:
     template <typename, typename>
     friend class IteratorTempl;
@@ -62,6 +61,12 @@ class iter::impl::Productor<Container, RestContainers...> {
     RestIter rest_end_;
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = ProdIterDeref<ContainerT>;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     constexpr static const bool is_base_iter = false;
     IteratorTempl(IteratorWrapper<ContainerT>&& sub_iter, RestIter&& rest_iter,
         RestIter&& rest_end)
@@ -144,8 +149,14 @@ template <>
 class iter::impl::Productor<> {
  public:
   Productor(Productor&&) = default;
-  class Iterator : public std::iterator<std::input_iterator_tag, std::tuple<>> {
+  class Iterator {
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = std::tuple<>;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     constexpr static const bool is_base_iter = true;
 
     void reset() {}
diff --git a/range.hpp b/range.hpp
index 145cdfab..ee1fbba9 100644
--- a/range.hpp
+++ b/range.hpp
@@ -128,8 +128,7 @@ class iter::impl::Range {
   // of the rules, but std::vector<bool>::iterator::reference isn't
   // a reference type either, this isn't any worse
 
-  class Iterator : public std::iterator<std::forward_iterator_tag, T,
-                       std::ptrdiff_t, T*, T> {
+  class Iterator {
    private:
     iter::detail::RangeIterData<T> data;
     bool is_end;
@@ -160,6 +159,12 @@ class iter::impl::Range {
     }
 
    public:
+    using iterator_category = std::forward_iterator_tag;
+    using value_type = T;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     constexpr Iterator() noexcept = default;
 
     constexpr Iterator(T in_value, T in_step, bool in_is_end) noexcept
diff --git a/repeat.hpp b/repeat.hpp
index 1073d750..01739c6c 100644
--- a/repeat.hpp
+++ b/repeat.hpp
@@ -34,12 +34,18 @@ class iter::impl::RepeaterWithCount {
  public:
   RepeaterWithCount(RepeaterWithCount&&) = default;
 
-  class Iterator : public std::iterator<std::input_iterator_tag, const TPlain> {
+  class Iterator {
    private:
     const TPlain* elem_;
     int count_;
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = const TPlain;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     constexpr Iterator(const TPlain* e, int c) : elem_{e}, count_{c} {}
 
     Iterator& operator++() {
@@ -108,11 +114,17 @@ class iter::impl::Repeater {
  public:
   Repeater(Repeater&&) = default;
 
-  class Iterator : public std::iterator<std::input_iterator_tag, const TPlain> {
+  class Iterator {
    private:
     const TPlain* elem_;
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = const TPlain;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     constexpr Iterator(const TPlain* e) : elem_{e} {}
 
     constexpr const Iterator& operator++() const {
diff --git a/reversed.hpp b/reversed.hpp
index 08517fb7..b76ad801 100644
--- a/reversed.hpp
+++ b/reversed.hpp
@@ -71,14 +71,19 @@ class iter::impl::Reverser {
  public:
   Reverser(Reverser&&) = default;
   template <typename ContainerT>
-  class Iterator : public std::iterator<std::input_iterator_tag,
-                       reverse_iterator_traits_deref<ContainerT>> {
+  class Iterator {
    private:
     template <typename>
     friend class Iterator;
     ReverseIteratorWrapper<ContainerT> sub_iter_;
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = reverse_iterator_traits_deref<ContainerT>;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(ReverseIteratorWrapper<ContainerT>&& sub_iter)
         : sub_iter_{std::move(sub_iter)} {}
 
diff --git a/slice.hpp b/slice.hpp
index 59ea7885..53114943 100644
--- a/slice.hpp
+++ b/slice.hpp
@@ -36,8 +36,7 @@ class iter::impl::Sliced {
  public:
   Sliced(Sliced&&) = default;
   template <typename ContainerT>
-  class Iterator : public std::iterator<std::input_iterator_tag,
-                       iterator_traits_deref<ContainerT>> {
+  class Iterator {
    private:
     template <typename>
     friend class Iterator;
@@ -48,6 +47,12 @@ class iter::impl::Sliced {
     DifferenceType step_;
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = iterator_traits_deref<ContainerT>;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(IteratorWrapper<ContainerT>&& sub_iter,
         IteratorWrapper<ContainerT>&& sub_end, DifferenceType start,
         DifferenceType stop, DifferenceType step)
diff --git a/sliding_window.hpp b/sliding_window.hpp
index ae478de8..cf843894 100644
--- a/sliding_window.hpp
+++ b/sliding_window.hpp
@@ -37,8 +37,7 @@ class iter::impl::WindowSlider {
  public:
   WindowSlider(WindowSlider&&) = default;
   template <typename ContainerT>
-  class Iterator
-      : public std::iterator<std::input_iterator_tag, DerefVec<ContainerT>> {
+  class Iterator {
    private:
     template <typename>
     friend class Iterator;
@@ -46,6 +45,12 @@ class iter::impl::WindowSlider {
     DerefVec<ContainerT> window_;
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = DerefVec<ContainerT>;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(IteratorWrapper<ContainerT>&& sub_iter,
         IteratorWrapper<ContainerT>&& sub_end, std::size_t window_sz)
         : sub_iter_(std::move(sub_iter)) {
diff --git a/starmap.hpp b/starmap.hpp
index e83fbb24..371f2ffe 100644
--- a/starmap.hpp
+++ b/starmap.hpp
@@ -44,8 +44,7 @@ class iter::impl::StarMapper {
 
  public:
   template <typename ContainerT>
-  class Iterator
-      : public std::iterator<std::input_iterator_tag, StarIterDeref> {
+  class Iterator {
    private:
     template <typename>
     friend class Iterator;
@@ -53,6 +52,12 @@ class iter::impl::StarMapper {
     IteratorWrapper<ContainerT> sub_iter_;
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = StarIterDeref;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(Func& f, IteratorWrapper<ContainerT>&& sub_iter)
         : func_(&f), sub_iter_(std::move(sub_iter)) {}
 
@@ -142,8 +147,7 @@ class iter::impl::TupleStarMapper {
 
  public:
   template <typename TupTypeT>
-  class Iterator : public std::iterator<std::input_iterator_tag,
-                       typename IteratorData<TupTypeT>::TraitsValue> {
+  class Iterator {
    private:
     template <typename>
     friend class Iterator;
@@ -152,6 +156,12 @@ class iter::impl::TupleStarMapper {
     std::size_t index_;
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = typename IteratorData<TupTypeT>::TraitsValue;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(Func& f, TupTypeT& t, std::size_t i)
         : func_{&f}, tup_{&t}, index_{i} {}
 
diff --git a/takewhile.hpp b/takewhile.hpp
index ad823b0d..eb0fd801 100644
--- a/takewhile.hpp
+++ b/takewhile.hpp
@@ -34,8 +34,7 @@ class iter::impl::Taker {
   Taker(Taker&&) = default;
 
   template <typename ContainerT>
-  class Iterator : public std::iterator<std::input_iterator_tag,
-                       iterator_traits_deref<ContainerT>> {
+  class Iterator {
    private:
     template <typename>
     friend class Iterator;
@@ -59,6 +58,12 @@ class iter::impl::Taker {
     }
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = iterator_traits_deref<ContainerT>;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(IteratorWrapper<ContainerT>&& sub_iter,
         IteratorWrapper<ContainerT>&& sub_end, FilterFunc& filter_func)
         : sub_iter_{std::move(sub_iter)},
diff --git a/zip.hpp b/zip.hpp
index 3bb4ccdb..a7f2f19d 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -40,14 +40,19 @@ class iter::impl::Zipped {
   // deref they'd need to be known in the function declarations below.
   template <typename TupleTypeT, template <typename> class IteratorTuple,
       template <typename> class TupleDeref>
-  class Iterator
-      : public std::iterator<std::input_iterator_tag, TupleDeref<TupleTypeT>> {
+  class Iterator {
    private:
     template <typename, template <typename> class, template <typename> class>
     friend class Iterator;
     IteratorTuple<TupleTypeT> iters_;
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = TupleDeref<TupleTypeT>;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(IteratorTuple<TupleTypeT>&& iters) : iters_(std::move(iters)) {}
 
     Iterator& operator++() {
diff --git a/zip_longest.hpp b/zip_longest.hpp
index eb73aaac..ba6ea3c5 100644
--- a/zip_longest.hpp
+++ b/zip_longest.hpp
@@ -49,8 +49,7 @@ class iter::impl::ZippedLongest {
   ZippedLongest(ZippedLongest&&) = default;
   template <typename TupleTypeT, template <typename> class IterTuple,
       template <std::size_t, typename> class OptTempl>
-  class Iterator : public std::iterator<std::input_iterator_tag,
-                       ZipIterDeref<TupleTypeT, OptTempl>> {
+  class Iterator {
    private:
     template <typename, template <typename> class,
         template <std::size_t, typename> class>
@@ -59,6 +58,12 @@ class iter::impl::ZippedLongest {
     IterTuple<TupleTypeT> ends_;
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = ZipIterDeref<TupleTypeT, OptTempl>;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(IterTuple<TupleTypeT>&& iters, IterTuple<TupleTypeT>&& ends)
         : iters_(std::move(iters)), ends_(std::move(ends)) {}
 

From e0d1213f7ef18152ce1d633f6e1e1752563e07d7 Mon Sep 17 00:00:00 2001
From: Nikolas Vanderhoof <nikolasrvanderhoof@gmail.com>
Date: Mon, 5 Mar 2018 04:39:15 -0500
Subject: [PATCH 1686/1866] Fix Range<T>::Iterator::reference

Range<T>::Iterator::reference == Range<T>::Iterator::value_type
---
 range.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/range.hpp b/range.hpp
index ee1fbba9..8a9a4791 100644
--- a/range.hpp
+++ b/range.hpp
@@ -163,7 +163,7 @@ class iter::impl::Range {
     using value_type = T;
     using difference_type = std::ptrdiff_t;
     using pointer = value_type*;
-    using reference = value_type&;
+    using reference = value_type;
 
     constexpr Iterator() noexcept = default;
 

From c12a8bc9078447028b27c67b1a699502037f79ba Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 31 Mar 2018 14:57:00 -0400
Subject: [PATCH 1687/1866] Remove using declarations for as_const and void_t

They were in there to avoid conflict with c++14.
---
 accumulate.hpp                    |  8 ++++----
 chain.hpp                         | 16 ++++++++--------
 chunked.hpp                       |  8 ++++----
 combinations.hpp                  |  4 ++--
 combinations_with_replacement.hpp |  4 ++--
 compress.hpp                      | 16 ++++++++--------
 cycle.hpp                         |  8 ++++----
 dropwhile.hpp                     |  8 ++++----
 enumerate.hpp                     |  4 ++--
 filter.hpp                        |  8 ++++----
 groupby.hpp                       |  8 ++++----
 internal/iterbase.hpp             |  7 +------
 permutations.hpp                  |  8 ++++----
 powerset.hpp                      |  4 ++--
 product.hpp                       | 12 ++++++------
 reversed.hpp                      |  4 ++--
 slice.hpp                         | 10 +++++-----
 sliding_window.hpp                | 10 +++++-----
 sorted.hpp                        |  6 +++---
 starmap.hpp                       |  8 ++++----
 takewhile.hpp                     |  8 ++++----
 zip.hpp                           |  4 ++--
 zip_longest.hpp                   |  8 ++++----
 23 files changed, 88 insertions(+), 93 deletions(-)

diff --git a/accumulate.hpp b/accumulate.hpp
index f2210847..9d431dc4 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -106,13 +106,13 @@ class iter::impl::Accumulator {
     return {get_end(container_), get_end(container_), accumulate_func_};
   }
   Iterator<AsConst<Container>> begin() const {
-    return {get_begin(impl::as_const(container_)),
-        get_end(impl::as_const(container_)), accumulate_func_};
+    return {get_begin(std::as_const(container_)),
+        get_end(std::as_const(container_)), accumulate_func_};
   }
 
   Iterator<AsConst<Container>> end() const {
-    return {get_end(impl::as_const(container_)),
-        get_end(impl::as_const(container_)), accumulate_func_};
+    return {get_end(std::as_const(container_)),
+        get_end(std::as_const(container_)), accumulate_func_};
   }
 };
 
diff --git a/chain.hpp b/chain.hpp
index b3c0d5e9..fcdfef7f 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -175,17 +175,17 @@ class iter::impl::Chained {
 
   Iterator<AsConst<TupType>> begin() const {
     return {0, typename IteratorData<AsConst<TupType>>::IterTupType{get_begin(
-                   impl::as_const(std::get<Is>(tup_)))...},
+                   std::as_const(std::get<Is>(tup_)))...},
         typename IteratorData<AsConst<TupType>>::IterTupType{
-            get_end(impl::as_const(std::get<Is>(tup_)))...}};
+            get_end(std::as_const(std::get<Is>(tup_)))...}};
   }
 
   Iterator<AsConst<TupType>> end() const {
     return {sizeof...(Is),
         typename IteratorData<AsConst<TupType>>::IterTupType{
-            get_end(impl::as_const(std::get<Is>(tup_)))...},
+            get_end(std::as_const(std::get<Is>(tup_)))...},
         typename IteratorData<AsConst<TupType>>::IterTupType{
-            get_end(impl::as_const(std::get<Is>(tup_)))...}};
+            get_end(std::as_const(std::get<Is>(tup_)))...}};
   }
 };
 
@@ -311,13 +311,13 @@ class iter::impl::ChainedFromIterable {
   }
 
   Iterator<AsConst<Container>> begin() const {
-    return {get_begin(impl::as_const(container_)),
-        get_end(impl::as_const(container_))};
+    return {get_begin(std::as_const(container_)),
+        get_end(std::as_const(container_))};
   }
 
   Iterator<AsConst<Container>> end() const {
-    return {get_end(impl::as_const(container_)),
-        get_end(impl::as_const(container_))};
+    return {get_end(std::as_const(container_)),
+        get_end(std::as_const(container_))};
   }
 };
 
diff --git a/chunked.hpp b/chunked.hpp
index 33d194d1..87f0a0de 100644
--- a/chunked.hpp
+++ b/chunked.hpp
@@ -120,13 +120,13 @@ class iter::impl::Chunker {
   }
 
   Iterator<AsConst<Container>> begin() const {
-    return {get_begin(impl::as_const(container_)),
-        get_end(impl::as_const(container_)), chunk_size_};
+    return {get_begin(std::as_const(container_)),
+        get_end(std::as_const(container_)), chunk_size_};
   }
 
   Iterator<AsConst<Container>> end() const {
-    return {get_end(impl::as_const(container_)),
-        get_end(impl::as_const(container_)), chunk_size_};
+    return {get_end(std::as_const(container_)),
+        get_end(std::as_const(container_)), chunk_size_};
   }
 };
 
diff --git a/combinations.hpp b/combinations.hpp
index afdefe4a..bfee2c86 100644
--- a/combinations.hpp
+++ b/combinations.hpp
@@ -141,11 +141,11 @@ class iter::impl::Combinator {
   }
 
   Iterator<AsConst<Container>> begin() const {
-    return {impl::as_const(container_), length_};
+    return {std::as_const(container_), length_};
   }
 
   Iterator<AsConst<Container>> end() const {
-    return {impl::as_const(container_), 0};
+    return {std::as_const(container_), 0};
   }
 };
 
diff --git a/combinations_with_replacement.hpp b/combinations_with_replacement.hpp
index 5b26f4ed..5455a6e4 100644
--- a/combinations_with_replacement.hpp
+++ b/combinations_with_replacement.hpp
@@ -120,11 +120,11 @@ class iter::impl::CombinatorWithReplacement {
   }
 
   Iterator<AsConst<Container>> begin() const {
-    return {impl::as_const(container_), length_};
+    return {std::as_const(container_), length_};
   }
 
   Iterator<AsConst<Container>> end() const {
-    return {impl::as_const(container_), 0};
+    return {std::as_const(container_), 0};
   }
 };
 
diff --git a/compress.hpp b/compress.hpp
index 60a48244..f4606ef8 100644
--- a/compress.hpp
+++ b/compress.hpp
@@ -116,17 +116,17 @@ class iter::impl::Compressed {
   }
 
   Iterator<AsConst<Container>, AsConst<Selector>> begin() const {
-    return {get_begin(impl::as_const(container_)),
-        get_end(impl::as_const(container_)),
-        get_begin(impl::as_const(selectors_)),
-        get_end(impl::as_const(selectors_))};
+    return {get_begin(std::as_const(container_)),
+        get_end(std::as_const(container_)),
+        get_begin(std::as_const(selectors_)),
+        get_end(std::as_const(selectors_))};
   }
 
   Iterator<AsConst<Container>, AsConst<Selector>> end() const {
-    return {get_end(impl::as_const(container_)),
-        get_end(impl::as_const(container_)),
-        get_end(impl::as_const(selectors_)),
-        get_end(impl::as_const(selectors_))};
+    return {get_end(std::as_const(container_)),
+        get_end(std::as_const(container_)),
+        get_end(std::as_const(selectors_)),
+        get_end(std::as_const(selectors_))};
   }
 };
 
diff --git a/cycle.hpp b/cycle.hpp
index 30cbefb0..1d3ecaef 100644
--- a/cycle.hpp
+++ b/cycle.hpp
@@ -95,13 +95,13 @@ class iter::impl::Cycler {
   }
 
   Iterator<AsConst<Container>> begin() const {
-    return {get_begin(impl::as_const(container_)),
-        get_end(impl::as_const(container_))};
+    return {get_begin(std::as_const(container_)),
+        get_end(std::as_const(container_))};
   }
 
   Iterator<AsConst<Container>> end() const {
-    return {get_end(impl::as_const(container_)),
-        get_end(impl::as_const(container_))};
+    return {get_end(std::as_const(container_)),
+        get_end(std::as_const(container_))};
   }
 };
 
diff --git a/dropwhile.hpp b/dropwhile.hpp
index 939f696e..d4ac6594 100644
--- a/dropwhile.hpp
+++ b/dropwhile.hpp
@@ -114,13 +114,13 @@ class iter::impl::Dropper {
   }
 
   Iterator<AsConst<Container>> begin() const {
-    return {get_begin(impl::as_const(container_)),
-        get_end(impl::as_const(container_)), filter_func_};
+    return {get_begin(std::as_const(container_)),
+        get_end(std::as_const(container_)), filter_func_};
   }
 
   Iterator<AsConst<Container>> end() const {
-    return {get_end(impl::as_const(container_)),
-        get_end(impl::as_const(container_)), filter_func_};
+    return {get_end(std::as_const(container_)),
+        get_end(std::as_const(container_)), filter_func_};
   }
 };
 
diff --git a/enumerate.hpp b/enumerate.hpp
index 8a7bc97e..b36a0103 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -125,11 +125,11 @@ class iter::impl::Enumerable {
   }
 
   Iterator<AsConst<Container>> begin() const {
-    return {get_begin(impl::as_const(container_)), start_};
+    return {get_begin(std::as_const(container_)), start_};
   }
 
   Iterator<AsConst<Container>> end() const {
-    return {get_end(impl::as_const(container_)), start_};
+    return {get_end(std::as_const(container_)), start_};
   }
 };
 #endif
diff --git a/filter.hpp b/filter.hpp
index a8c04004..2187b46c 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -127,13 +127,13 @@ class iter::impl::Filtered {
   }
 
   Iterator<AsConst<Container>> begin() const {
-    return {get_begin(impl::as_const(container_)),
-        get_end(impl::as_const(container_)), filter_func_};
+    return {get_begin(std::as_const(container_)),
+        get_end(std::as_const(container_)), filter_func_};
   }
 
   Iterator<AsConst<Container>> end() const {
-    return {get_end(impl::as_const(container_)),
-        get_end(impl::as_const(container_)), filter_func_};
+    return {get_end(std::as_const(container_)),
+        get_end(std::as_const(container_)), filter_func_};
   }
 };
 
diff --git a/groupby.hpp b/groupby.hpp
index 4f4255eb..7cf00b4e 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -285,13 +285,13 @@ class iter::impl::GroupProducer {
   }
 
   Iterator<AsConst<Container>> begin() const {
-    return {get_begin(impl::as_const(container_)),
-        get_end(impl::as_const(container_)), key_func_};
+    return {get_begin(std::as_const(container_)),
+        get_end(std::as_const(container_)), key_func_};
   }
 
   Iterator<AsConst<Container>> end() const {
-    return {get_end(impl::as_const(container_)),
-        get_end(impl::as_const(container_)), key_func_};
+    return {get_end(std::as_const(container_)),
+        get_end(std::as_const(container_)), key_func_};
   }
 };
 
diff --git a/internal/iterbase.hpp b/internal/iterbase.hpp
index 7ddc1c2a..60e31517 100644
--- a/internal/iterbase.hpp
+++ b/internal/iterbase.hpp
@@ -47,13 +47,8 @@ namespace iter {
       using type = T;
     };
 
-    // TODO get rid of these and explicitly use std:: everywhere once master is
-    // on C++17
-    using std::as_const;
-    using std::void_t;
-
     template <typename T>
-    using AsConst = decltype(impl::as_const(std::declval<T&>()));
+    using AsConst = decltype(std::as_const(std::declval<T&>()));
 
     // iterator_type<C> is the type of C's iterator
     template <typename Container>
diff --git a/permutations.hpp b/permutations.hpp
index 40945040..e10872d4 100644
--- a/permutations.hpp
+++ b/permutations.hpp
@@ -115,13 +115,13 @@ class iter::impl::Permuter {
   }
 
   Iterator<AsConst<Container>> begin() const {
-    return {get_begin(impl::as_const(container_)),
-        get_end(impl::as_const(container_))};
+    return {get_begin(std::as_const(container_)),
+        get_end(std::as_const(container_))};
   }
 
   Iterator<AsConst<Container>> end() const {
-    return {get_end(impl::as_const(container_)),
-        get_end(impl::as_const(container_))};
+    return {get_end(std::as_const(container_)),
+        get_end(std::as_const(container_))};
   }
 };
 
diff --git a/powerset.hpp b/powerset.hpp
index af270634..3439069d 100644
--- a/powerset.hpp
+++ b/powerset.hpp
@@ -119,12 +119,12 @@ class iter::impl::Powersetter {
   }
 
   Iterator<AsConst<Container>> begin() const {
-    return {impl::as_const(container_), 0};
+    return {std::as_const(container_), 0};
   }
 
   Iterator<AsConst<Container>> end() const {
     return {
-        impl::as_const(container_), dumb_size(impl::as_const(container_)) + 1};
+        std::as_const(container_), dumb_size(std::as_const(container_)) + 1};
   }
 };
 
diff --git a/product.hpp b/product.hpp
index af3deea6..74671462 100644
--- a/product.hpp
+++ b/product.hpp
@@ -133,15 +133,15 @@ class iter::impl::Productor<Container, RestContainers...> {
   }
 
   ConstIterator begin() const {
-    return {get_begin(impl::as_const(container_)),
-        get_begin(impl::as_const(rest_products_)),
-        get_end(impl::as_const(rest_products_))};
+    return {get_begin(std::as_const(container_)),
+        get_begin(std::as_const(rest_products_)),
+        get_end(std::as_const(rest_products_))};
   }
 
   ConstIterator end() const {
-    return {get_end(impl::as_const(container_)),
-        get_end(impl::as_const(rest_products_)),
-        get_end(impl::as_const(rest_products_))};
+    return {get_end(std::as_const(container_)),
+        get_end(std::as_const(rest_products_)),
+        get_end(std::as_const(rest_products_))};
   }
 };
 
diff --git a/reversed.hpp b/reversed.hpp
index b76ad801..fcf04d27 100644
--- a/reversed.hpp
+++ b/reversed.hpp
@@ -126,11 +126,11 @@ class iter::impl::Reverser {
   }
 
   Iterator<AsConst<Container>> begin() const {
-    return {std::rbegin(impl::as_const(container_))};
+    return {std::rbegin(std::as_const(container_))};
   }
 
   Iterator<AsConst<Container>> end() const {
-    return {std::rend(impl::as_const(container_))};
+    return {std::rend(std::as_const(container_))};
   }
 };
 
diff --git a/slice.hpp b/slice.hpp
index 53114943..22855645 100644
--- a/slice.hpp
+++ b/slice.hpp
@@ -107,15 +107,15 @@ class iter::impl::Sliced {
   }
 
   Iterator<AsConst<Container>> begin() const {
-    auto it = get_begin(impl::as_const(container_));
-    dumb_advance(it, get_end(impl::as_const(container_)), start_);
-    return {std::move(it), get_end(impl::as_const(container_)), start_, stop_,
+    auto it = get_begin(std::as_const(container_));
+    dumb_advance(it, get_end(std::as_const(container_)), start_);
+    return {std::move(it), get_end(std::as_const(container_)), start_, stop_,
         step_};
   }
 
   Iterator<AsConst<Container>> end() const {
-    return {get_end(impl::as_const(container_)),
-        get_end(impl::as_const(container_)), stop_, stop_, step_};
+    return {get_end(std::as_const(container_)),
+        get_end(std::as_const(container_)), stop_, stop_, step_};
   }
 };
 
diff --git a/sliding_window.hpp b/sliding_window.hpp
index cf843894..fcb41e00 100644
--- a/sliding_window.hpp
+++ b/sliding_window.hpp
@@ -109,15 +109,15 @@ class iter::impl::WindowSlider {
 
   Iterator<AsConst<Container>> begin() const {
     return {(window_size_ != 0 ? IteratorWrapper<AsConst<Container>>{get_begin(
-                                     impl::as_const(container_))}
+                                     std::as_const(container_))}
                                : IteratorWrapper<AsConst<Container>>{get_end(
-                                     impl::as_const(container_))}),
-        get_end(impl::as_const(container_)), window_size_};
+                                     std::as_const(container_))}),
+        get_end(std::as_const(container_)), window_size_};
   }
 
   Iterator<AsConst<Container>> end() const {
-    return {get_end(impl::as_const(container_)),
-        get_end(impl::as_const(container_)), window_size_};
+    return {get_end(std::as_const(container_)),
+        get_end(std::as_const(container_)), window_size_};
   }
 };
 
diff --git a/sorted.hpp b/sorted.hpp
index 24701488..a45cc75c 100644
--- a/sorted.hpp
+++ b/sorted.hpp
@@ -61,7 +61,7 @@ class iter::impl::SortedView {
 
   template <typename ContainerT>
   class SortedItersHolder<ContainerT,
-      void_t<decltype(std::begin(std::declval<AsConst<ContainerT>&>()))>> {
+      std::void_t<decltype(std::begin(std::declval<AsConst<ContainerT>&>()))>> {
    public:
     using IterIterWrap =
         IterIterWrapper<std::vector<iterator_type<ContainerT>>>;
@@ -101,8 +101,8 @@ class iter::impl::SortedView {
       if (!const_sorted_iters_.empty()) {
         return;
       }
-      for (auto iter = get_begin(impl::as_const(container_));
-           iter != get_end(impl::as_const(container_)); ++iter) {
+      for (auto iter = get_begin(std::as_const(container_));
+           iter != get_end(std::as_const(container_)); ++iter) {
         const_sorted_iters_.get().push_back(iter);
       }
 
diff --git a/starmap.hpp b/starmap.hpp
index 371f2ffe..384bf8f3 100644
--- a/starmap.hpp
+++ b/starmap.hpp
@@ -100,11 +100,11 @@ class iter::impl::StarMapper {
   }
 
   Iterator<AsConst<Container>> begin() const {
-    return {func_, get_begin(impl::as_const(container_))};
+    return {func_, get_begin(std::as_const(container_))};
   }
 
   Iterator<AsConst<Container>> end() const {
-    return {func_, get_end(impl::as_const(container_))};
+    return {func_, get_end(std::as_const(container_))};
   }
 };
 
@@ -204,11 +204,11 @@ class iter::impl::TupleStarMapper {
   }
 
   Iterator<AsConst<TupType>> begin() const {
-    return {func_, impl::as_const(tup_), 0};
+    return {func_, std::as_const(tup_), 0};
   }
 
   Iterator<AsConst<TupType>> end() const {
-    return {func_, impl::as_const(tup_), sizeof...(Is)};
+    return {func_, std::as_const(tup_), sizeof...(Is)};
   }
 };
 
diff --git a/takewhile.hpp b/takewhile.hpp
index eb0fd801..e4b3f001 100644
--- a/takewhile.hpp
+++ b/takewhile.hpp
@@ -115,13 +115,13 @@ class iter::impl::Taker {
   }
 
   Iterator<AsConst<Container>> begin() const {
-    return {get_begin(impl::as_const(container_)),
-        get_end(impl::as_const(container_)), filter_func_};
+    return {get_begin(std::as_const(container_)),
+        get_end(std::as_const(container_)), filter_func_};
   }
 
   Iterator<AsConst<Container>> end() const {
-    return {get_end(impl::as_const(container_)),
-        get_end(impl::as_const(container_)), filter_func_};
+    return {get_end(std::as_const(container_)),
+        get_end(std::as_const(container_)), filter_func_};
   }
 };
 
diff --git a/zip.hpp b/zip.hpp
index a7f2f19d..6cd26351 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -106,14 +106,14 @@ class iter::impl::Zipped {
       const_iterator_deref_tuple>
   begin() const {
     return {const_iterator_tuple_type<AsConst<TupleType>>{
-        get_begin(impl::as_const(std::get<Is>(containers_)))...}};
+        get_begin(std::as_const(std::get<Is>(containers_)))...}};
   }
 
   Iterator<AsConst<TupleType>, const_iterator_tuple_type,
       const_iterator_deref_tuple>
   end() const {
     return {const_iterator_tuple_type<AsConst<TupleType>>{
-        get_end(impl::as_const(std::get<Is>(containers_)))...}};
+        get_end(std::as_const(std::get<Is>(containers_)))...}};
   }
 };
 
diff --git a/zip_longest.hpp b/zip_longest.hpp
index ba6ea3c5..c73383c6 100644
--- a/zip_longest.hpp
+++ b/zip_longest.hpp
@@ -126,17 +126,17 @@ class iter::impl::ZippedLongest {
   Iterator<AsConst<TupleType>, const_iterator_tuple_type, ConstOptType> begin()
       const {
     return {const_iterator_tuple_type<AsConst<TupleType>>{
-                get_begin(impl::as_const(std::get<Is>(containers_)))...},
+                get_begin(std::as_const(std::get<Is>(containers_)))...},
         const_iterator_tuple_type<AsConst<TupleType>>{
-            get_end(impl::as_const(std::get<Is>(containers_)))...}};
+            get_end(std::as_const(std::get<Is>(containers_)))...}};
   }
 
   Iterator<AsConst<TupleType>, const_iterator_tuple_type, ConstOptType> end()
       const {
     return {const_iterator_tuple_type<AsConst<TupleType>>{
-                get_end(impl::as_const(std::get<Is>(containers_)))...},
+                get_end(std::as_const(std::get<Is>(containers_)))...},
         const_iterator_tuple_type<AsConst<TupleType>>{
-            get_end(impl::as_const(std::get<Is>(containers_)))...}};
+            get_end(std::as_const(std::get<Is>(containers_)))...}};
   }
 };
 

From 16d996e8677ff14daf776b507bf3306836cb4f45 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 31 Mar 2018 15:38:27 -0400
Subject: [PATCH 1688/1866] Tests imap with pointer-to-member

---
 test/test_imap.cpp | 33 ++++++++++++++++++++++++++++++++-
 1 file changed, 32 insertions(+), 1 deletion(-)

diff --git a/test/test_imap.cpp b/test/test_imap.cpp
index db37d3f5..b2be404d 100644
--- a/test/test_imap.cpp
+++ b/test/test_imap.cpp
@@ -61,6 +61,38 @@ TEST_CASE("imap: works with lambda, callable, and function", "[imap]") {
   REQUIRE(v == vc);
 }
 
+TEST_CASE("imap: works with pointer to member", "[imap]") {
+  using itertest::Point;
+  std::vector<Point> ps = {{3, 6}, {20, 25}};
+  std::vector<int> v;
+  SECTION("with pointer to member function") {
+    auto im = imap(&Point::get_y, ps);
+    v.assign(std::begin(im), std::end(im));
+  }
+
+  SECTION("with pointer to data member") {
+    auto im = imap(&Point::y, ps);
+    v.assign(std::begin(im), std::end(im));
+  }
+
+  Vec vc = {6, 25};
+  REQUIRE(v == vc);
+}
+
+TEST_CASE("imap: works with pointer to member function taking argument") {
+  using itertest::Point;
+  std::vector<Point> ps = {{10, 20}, {6, 8}, {3, 15}};
+  std::vector<std::string> strs = {"a", "point", "pos"};
+
+  auto im = imap(&Point::prefix, ps, strs);
+
+  std::vector<std::string> v(std::begin(im), std::end(im));
+  const std::vector<std::string> vc = {
+      "a(10, 20)", "point(6, 8)", "pos(3, 15)"};
+
+  REQUIRE(v == vc);
+}
+
 // TODO enable once zip supports const
 #if 0
 TEST_CASE("imap: supports const iteration", "[imap][const]") {
@@ -77,7 +109,6 @@ TEST_CASE("imap: const iterators can be compared to non-const iterators", "[imap
   (void)(std::begin(m) == std::end(cm));
 }
 #endif
-  
 
 TEST_CASE("imap: Works with different begin and end types", "[imap]") {
   CharRange cr{'d'};

From 2337c507e28efc2710e138bdcd536634025e292a Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 31 Mar 2018 15:39:14 -0400
Subject: [PATCH 1689/1866] Tests starmap with pointer-to-member

---
 test/test_starmap.cpp | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/test/test_starmap.cpp b/test/test_starmap.cpp
index 210694f5..bb98a349 100644
--- a/test/test_starmap.cpp
+++ b/test/test_starmap.cpp
@@ -61,6 +61,17 @@ TEST_CASE("starmap: works with function pointer and lambda", "[starmap]") {
   REQUIRE(v == vc);
 }
 
+TEST_CASE("starmap: works with pointer to member function", "[starmap]") {
+  using itertest::Point;
+  std::vector<std::pair<Point, std::string>> tup = {
+      {{10, 20}, "a"}, {{6, 8}, "point"}, {{3, 15}, "pos"}};
+  auto sm = starmap(&Point::prefix, tup);
+  std::vector<std::string> v(std::begin(sm), std::end(sm));
+  const std::vector<std::string> vc = {
+      "a(10, 20)", "point(6, 8)", "pos(3, 15)"};
+  REQUIRE(v == vc);
+}
+
 TEST_CASE("starmap: vector of pairs const iteration", "[starmap][const]") {
   using Vec = const std::vector<int>;
   const std::vector<std::pair<double, int>> v1 = {{1l, 2}, {3l, 11}, {6l, 7}};

From a68bc082e7e44454aed6f0f77f191e66ae6dbcd9 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 31 Mar 2018 15:43:17 -0400
Subject: [PATCH 1690/1866] Adds Point for testing

---
 test/helpers.hpp | 21 +++++++++++++++++++--
 1 file changed, 19 insertions(+), 2 deletions(-)

diff --git a/test/helpers.hpp b/test/helpers.hpp
index 1a65f9e3..584c540e 100644
--- a/test/helpers.hpp
+++ b/test/helpers.hpp
@@ -3,6 +3,7 @@
 
 #include <internal/iterbase.hpp>
 
+#include <sstream>
 #include <stdexcept>
 #include <type_traits>
 #include <utility>
@@ -111,8 +112,7 @@ namespace itertest {
         : data{new T[other.size]}, size{other.size} {
       other.was_copied_from_ = true;
       auto o_it = begin(other);
-      for (auto it = begin(*this); o_it != end(other);
-           ++it, ++o_it) {
+      for (auto it = begin(*this); o_it != end(other); ++it, ++o_it) {
         *it = *o_it;
       }
     }
@@ -211,6 +211,23 @@ namespace itertest {
                 && !std::is_copy_assignable<T>::value
                 && !std::is_move_assignable<T>::value
                 && std::is_move_constructible<T>::value> {};
+
+  struct Point {
+    int x;
+    int y;
+    int get_x() const {
+      return x;
+    }
+    int get_y() const {
+      return y;
+    }
+
+    std::string prefix(const std::string& str) {
+      std::ostringstream ss;
+      ss << str << "(" << x << ", " << y << ")";
+      return ss.str();
+    }
+  };
 }
 template <typename T, typename Inc>
 class DiffEndRange {

From 17ad9774852ed19e813a04db078d3e8d57973f84 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 31 Mar 2018 15:45:34 -0400
Subject: [PATCH 1691/1866] Uses std::invoke is call_with_tuple

This lets imap and starmap support pointer to member function and
pointer to data member arguments.
---
 internal/iter_tuples.hpp | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/internal/iter_tuples.hpp b/internal/iter_tuples.hpp
index 99fdfffe..5b3a5cda 100644
--- a/internal/iter_tuples.hpp
+++ b/internal/iter_tuples.hpp
@@ -4,6 +4,8 @@
 #include "iterator_wrapper.hpp"
 #include "iterbase.hpp"
 
+#include <functional>
+
 namespace iter {
   namespace impl {
     namespace detail {
@@ -54,8 +56,9 @@ namespace iter {
       template <typename Func, typename TupleType, std::size_t... Is>
       decltype(auto) call_with_tuple_impl(
           Func&& mf, TupleType&& tup, std::index_sequence<Is...>) {
-        return mf(std::forward<std::tuple_element_t<Is,
-                std::remove_reference_t<TupleType>>>(std::get<Is>(tup))...);
+        return std::invoke(
+            mf, std::forward<std::tuple_element_t<Is,
+                    std::remove_reference_t<TupleType>>>(std::get<Is>(tup))...);
       }
     }
 

From 38dc638b9deabe7482fa9673eb7e6e21a81197b3 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 31 Mar 2018 18:28:08 -0400
Subject: [PATCH 1692/1866] Tests filter with pointer to member

---
 test/test_filter.cpp | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/test/test_filter.cpp b/test/test_filter.cpp
index 62b5f9a1..73f684ee 100644
--- a/test/test_filter.cpp
+++ b/test/test_filter.cpp
@@ -53,6 +53,24 @@ TEST_CASE("filter: handles different callable types", "[filter]") {
   }
 }
 
+TEST_CASE("filter: handles pointer to member", "[filter]") {
+  using itertest::Point;
+  const std::vector<Point> ps = {{0, 3}, {4, 0}, {0, 1}, {-1, -1}};
+  std::vector<Point> v;
+  SECTION("with pointer to data member") {
+    auto f = filter(&Point::x, ps);
+    v.assign(std::begin(f), std::end(f));
+  }
+
+  SECTION("with pointer to member function") {
+    auto f = filter(&Point::get_x, ps);
+    v.assign(std::begin(f), std::end(f));
+  }
+
+  const std::vector<Point> vc = {{4, 0}, {-1, -1}};
+  REQUIRE(v == vc);
+}
+
 TEST_CASE("filter: const iteration", "[filter][const]") {
   Vec ns = {1, 2, 5, 6, 3, 1, 7, -1, 5};
   const auto f = filter(LessThanValue{5}, ns);

From 0ce5d03131ce04cf27a45ef21dfcf299a72b1bee Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 31 Mar 2018 18:28:39 -0400
Subject: [PATCH 1693/1866] Adds == and != operators to Point

---
 test/helpers.hpp | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/test/helpers.hpp b/test/helpers.hpp
index 584c540e..65d856d8 100644
--- a/test/helpers.hpp
+++ b/test/helpers.hpp
@@ -227,6 +227,14 @@ namespace itertest {
       ss << str << "(" << x << ", " << y << ")";
       return ss.str();
     }
+
+    bool operator==(Point other) const {
+      return x == other.x && y == other.y;
+    }
+
+    bool operator!=(Point other) const {
+      return !(*this == other);
+    }
   };
 }
 template <typename T, typename Inc>

From 374cfbc2d86758dc7dadf9821870ac734b82e99b Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 31 Mar 2018 18:33:23 -0400
Subject: [PATCH 1694/1866] Uses std::invoke in filter

To support pointer-to-member
---
 filter.hpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/filter.hpp b/filter.hpp
index 2187b46c..0676917b 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -4,6 +4,7 @@
 #include "internal/iterator_wrapper.hpp"
 #include "internal/iterbase.hpp"
 
+#include <functional>
 #include <initializer_list>
 #include <iterator>
 #include <utility>
@@ -64,7 +65,8 @@ class iter::impl::Filtered {
     // increment until the iterator points to is true on the
     // predicate.  Called by constructor and operator++
     void skip_failures() {
-      while (sub_iter_ != sub_end_ && !(*filter_func_)(item_.get())) {
+      while (
+          sub_iter_ != sub_end_ && !std::invoke(*filter_func_, item_.get())) {
         inc_sub_iter();
       }
     }

From 001eaaf19ba746a99646b58e4bafce57c2af7ba9 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 31 Mar 2018 18:41:23 -0400
Subject: [PATCH 1695/1866] Makes Point printable by catch

---
 test/helpers.hpp | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/test/helpers.hpp b/test/helpers.hpp
index 65d856d8..ec0180cf 100644
--- a/test/helpers.hpp
+++ b/test/helpers.hpp
@@ -3,6 +3,7 @@
 
 #include <internal/iterbase.hpp>
 
+#include <iostream>
 #include <sstream>
 #include <stdexcept>
 #include <type_traits>
@@ -222,7 +223,7 @@ namespace itertest {
       return y;
     }
 
-    std::string prefix(const std::string& str) {
+    std::string prefix(const std::string& str) const {
       std::ostringstream ss;
       ss << str << "(" << x << ", " << y << ")";
       return ss.str();
@@ -235,6 +236,10 @@ namespace itertest {
     bool operator!=(Point other) const {
       return !(*this == other);
     }
+
+    friend std::ostream& operator<<(std::ostream& out, const Point& p) {
+      return out << p.prefix("");
+    }
   };
 }
 template <typename T, typename Inc>

From e70b220026c303cf981fa2bd7b4562560a1061f1 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 31 Mar 2018 18:42:19 -0400
Subject: [PATCH 1696/1866] Tests filterfalse with pointer to member

---
 test/test_filterfalse.cpp | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/test/test_filterfalse.cpp b/test/test_filterfalse.cpp
index 9e230ee1..7a74a0df 100644
--- a/test/test_filterfalse.cpp
+++ b/test/test_filterfalse.cpp
@@ -60,6 +60,24 @@ TEST_CASE("filterfalse: handles different callable types", "[filterfalse]") {
   }
 }
 
+TEST_CASE("filterfalse: handles pointer to member", "[filterfalse]") {
+  using itertest::Point;
+  const std::vector<Point> ps = {{0, 3}, {4, 0}, {0, 1}, {-1, -1}};
+  std::vector<Point> v;
+  SECTION("with pointer to data member") {
+    auto f = filterfalse(&Point::x, ps);
+    v.assign(std::begin(f), std::end(f));
+  }
+
+  SECTION("with pointer to member function") {
+    auto f = filterfalse(&Point::get_x, ps);
+    v.assign(std::begin(f), std::end(f));
+  }
+
+  const std::vector<Point> vc = {{0, 3}, {0, 1}};
+  REQUIRE(v == vc);
+}
+
 TEST_CASE("filterfalse: const iteration", "[filterfalse][const]") {
   Vec ns = {1, 2, 5, 6, 3, 1, 7, -1, 5};
   const auto f = filterfalse(LessThanValue{5}, ns);

From 2eb21d34a5451bb87bd4ea8ff967eb8b57b5a39e Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 31 Mar 2018 18:42:46 -0400
Subject: [PATCH 1697/1866] Uses std::invoke in filterfalse

To support pointer to member
---
 filterfalse.hpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/filterfalse.hpp b/filterfalse.hpp
index 9de7a3df..f0f22628 100644
--- a/filterfalse.hpp
+++ b/filterfalse.hpp
@@ -4,6 +4,7 @@
 #include "filter.hpp"
 #include "internal/iterbase.hpp"
 
+#include <functional>
 #include <utility>
 
 namespace iter {
@@ -22,13 +23,13 @@ namespace iter {
       // Calls the filter_func_
       template <typename T>
       bool operator()(const T& item) const {
-        return !bool(filter_func_(item));
+        return !bool(std::invoke(filter_func_, item));
       }
 
       // with non-const incase FilterFunc::operator() is non-const
       template <typename T>
       bool operator()(const T& item) {
-        return !bool(filter_func_(item));
+        return !bool(std::invoke(filter_func_, item));
       }
     };
 

From 11f476fd39692ba3a55636c5b6dbe84961c1765f Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 31 Mar 2018 18:46:53 -0400
Subject: [PATCH 1698/1866] filterfalse example to print non-empty strings

---
 examples/filterfalse_examples.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/examples/filterfalse_examples.cpp b/examples/filterfalse_examples.cpp
index 772005a8..f03debfa 100644
--- a/examples/filterfalse_examples.cpp
+++ b/examples/filterfalse_examples.cpp
@@ -26,4 +26,10 @@ int main() {
     for (auto&& i : iter::filterfalse(ns)) {
         std::cout << i << '\n';
     }
+
+    // only print non-empty strings
+    std::vector<std::string> words {"hello", "", "", "world", "", "goodbye", ""};
+    for (auto&& s : iter::filterfalse(&std::string::empty, words)) {
+      std::cout << s << '\n';
+    }
 }

From 5dd671957fc738a6e55291764702a628d034653b Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 31 Mar 2018 18:57:49 -0400
Subject: [PATCH 1699/1866] Tests dropwhile with pointer to member

---
 test/test_dropwhile.cpp | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/test/test_dropwhile.cpp b/test/test_dropwhile.cpp
index 1b4edcb5..38e686aa 100644
--- a/test/test_dropwhile.cpp
+++ b/test/test_dropwhile.cpp
@@ -41,6 +41,33 @@ TEST_CASE("dropwhile: skips initial elements", "[dropwhile]") {
   REQUIRE(v == vc);
 }
 
+TEST_CASE("dropwhile: handles pointer to member", "[dropwhile]") {
+  using itertest::Point;
+  const std::vector<Point> ps = {
+      {5, 0}, {3, 5}, {2, 1}, {0, 1}, {2, 2}, {6, 0}};
+  std::vector<Point> v;
+  SECTION("with pointer to data member") {
+    auto dw = dropwhile(&Point::x, ps);
+    v.assign(std::begin(dw), std::end(dw));
+  }
+
+  SECTION("with pointer to member function") {
+    auto dw = dropwhile(&Point::get_x, ps);
+    v.assign(std::begin(dw), std::end(dw));
+  }
+
+  const std::vector<Point> vc = {{0, 1}, {2, 2}, {6, 0}};
+  REQUIRE(v == vc);
+}
+
+TEST_CASE("dropwhile: drop empty strings at front", "[dropwhile]") {
+  const std::vector<std::string> words = {"", "", "check", "", "test"};
+  auto dw = dropwhile(&std::string::empty, words);
+  const std::vector<std::string> v(std::begin(dw), std::end(dw));
+  const std::vector<std::string> vc = {"check", "", "test"};
+  REQUIRE(v == vc);
+}
+
 TEST_CASE("dropwhile: const iteration", "[dropwhile][const]") {
   Vec ns{1, 2, 3, 4, 5, 6, 7, 8};
   const auto d = dropwhile(LessThanValue{5}, ns);

From 93d9bd4f5e735934e95f901d1206997f5a85f668 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 31 Mar 2018 18:59:19 -0400
Subject: [PATCH 1700/1866] Uses std::invoke in dropwhile

To support pointer to member
---
 dropwhile.hpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/dropwhile.hpp b/dropwhile.hpp
index d4ac6594..ca190471 100644
--- a/dropwhile.hpp
+++ b/dropwhile.hpp
@@ -5,6 +5,7 @@
 #include "internal/iterator_wrapper.hpp"
 #include "internal/iterbase.hpp"
 
+#include <functional>
 #include <iterator>
 #include <utility>
 
@@ -52,7 +53,7 @@ class iter::impl::Dropper {
 
     // skip all values for which the predicate is true
     void skip_passes() {
-      while (sub_iter_ != sub_end_ && (*filter_func_)(item_.get())) {
+      while (sub_iter_ != sub_end_ && std::invoke(*filter_func_, item_.get())) {
         inc_sub_iter();
       }
     }

From dd50796169d18470fc1778fb9ce5ea2a56e00722 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 31 Mar 2018 19:02:48 -0400
Subject: [PATCH 1701/1866] Tests takewhile with pointer to member

---
 test/test_takewhile.cpp | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/test/test_takewhile.cpp b/test/test_takewhile.cpp
index bea9e6e2..23ad8462 100644
--- a/test/test_takewhile.cpp
+++ b/test/test_takewhile.cpp
@@ -57,6 +57,25 @@ TEST_CASE("takewhile: works with lambda, callable, and function pointer",
   }
 }
 
+TEST_CASE("takewhile: handles pointer to member", "[takewhile]") {
+  using itertest::Point;
+  const std::vector<Point> ps = {
+      {5, 0}, {3, 5}, {2, 1}, {0, 1}, {2, 2}, {6, 0}};
+  std::vector<Point> v;
+  SECTION("with pointer to data member") {
+    auto tw = takewhile(&Point::x, ps);
+    v.assign(std::begin(tw), std::end(tw));
+  }
+
+  SECTION("with pointer to member function") {
+    auto tw = takewhile(&Point::get_x, ps);
+    v.assign(std::begin(tw), std::end(tw));
+  }
+
+  const std::vector<Point> vc = {{5, 0}, {3, 5}, {2, 1}};
+  REQUIRE(v == vc);
+}
+
 TEST_CASE("takewhile: supports const iteration", "[takewhile][const]") {
   Vec ns = {1, 3, 5, 20, 2, 4, 6, 8};
   const auto tw = takewhile(UnderTen{}, ns);

From 56525bc4007e212f58e64d30aecad4e779149ee0 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 31 Mar 2018 19:07:51 -0400
Subject: [PATCH 1702/1866] Uses std::invoke in takewhile

To support pointer to member
---
 takewhile.hpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/takewhile.hpp b/takewhile.hpp
index e4b3f001..8e28fcf2 100644
--- a/takewhile.hpp
+++ b/takewhile.hpp
@@ -5,6 +5,7 @@
 #include "internal/iterator_wrapper.hpp"
 #include "internal/iterbase.hpp"
 
+#include <functional>
 #include <iterator>
 #include <utility>
 
@@ -52,7 +53,7 @@ class iter::impl::Taker {
     }
 
     void check_current() {
-      if (sub_iter_ != sub_end_ && !(*filter_func_)(item_.get())) {
+      if (sub_iter_ != sub_end_ && !std::invoke(*filter_func_, item_.get())) {
         sub_iter_ = sub_end_;
       }
     }

From 5d6497e69208075f8a4e43817c74c3ef526fc4f9 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 31 Mar 2018 19:54:23 -0400
Subject: [PATCH 1703/1866] Tests groupby with pointer to member

---
 test/test_groupby.cpp | 40 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)

diff --git a/test/test_groupby.cpp b/test/test_groupby.cpp
index d6d508fa..1f86a40e 100644
--- a/test/test_groupby.cpp
+++ b/test/test_groupby.cpp
@@ -59,6 +59,13 @@ TEST_CASE("groupby: works with lambda, callable, and function pointer") {
     }
   }
 
+  SECTION("pointer to member") {
+    for (auto&& gb : groupby(vec, &std::string::size)) {
+      keys.push_back(gb.first);
+      groups.emplace_back(std::begin(gb.second), std::end(gb.second));
+    }
+  }
+
   const std::vector<int> kc = {2, 3, 5};
   REQUIRE(keys == kc);
 
@@ -69,6 +76,39 @@ TEST_CASE("groupby: works with lambda, callable, and function pointer") {
   REQUIRE(groups == gc);
 }
 
+TEST_CASE("groupby: handles pointer to member", "[groupby]") {
+  using itertest::Point;
+  const std::vector<Point> ps = {
+      {0, 2}, {0, 4}, {1, 3}, {1, 7}, {1, 10}, {1, 12}, {3, 5}};
+
+  std::vector<std::vector<Point>> groups;
+  std::vector<int> keys;
+
+  SECTION("with pointer to data member") {
+    auto g = groupby(ps, &Point::x);
+    for (auto&& gb : g) {
+      keys.push_back(gb.first);
+      groups.emplace_back(std::begin(gb.second), std::end(gb.second));
+    }
+  }
+
+  SECTION("with pointer member function") {
+    auto g = groupby(ps, &Point::get_x);
+    for (auto&& gb : g) {
+      keys.push_back(gb.first);
+      groups.emplace_back(std::begin(gb.second), std::end(gb.second));
+    }
+  }
+
+  const std::vector<int> kc = {0, 1, 3};
+  REQUIRE(keys == kc);
+
+  const std::vector<std::vector<Point>> gc = {
+      {{0, 2}, {0, 4}}, {{1, 3}, {1, 7}, {1, 10}, {1, 12}}, {{3, 5}}};
+
+  REQUIRE(groups == gc);
+}
+
 TEST_CASE("groupby: const iteration", "[groupby][const]") {
   std::vector<int> keys;
   std::vector<std::vector<std::string>> groups;

From 0febc1dd3c5d130ca0673e939dee62ec5f1d497d Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 31 Mar 2018 19:54:38 -0400
Subject: [PATCH 1704/1866] Uses std::invoke in groupby

To support pointer to member
---
 groupby.hpp | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/groupby.hpp b/groupby.hpp
index 7cf00b4e..a496ba67 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -6,6 +6,7 @@
 #include "internal/iterator_wrapper.hpp"
 #include "internal/iterbase.hpp"
 
+#include <functional>
 #include <iterator>
 #include <memory>
 #include <optional>
@@ -165,13 +166,13 @@ class iter::impl::GroupProducer {
     }
 
     key_func_ret<ContainerT> next_key() {
-      return (*key_func_)(item_.get());
+      return std::invoke(*key_func_, item_.get());
     }
 
     void set_key_group_pair() {
       if (!current_key_group_pair_) {
-        current_key_group_pair_.emplace(
-            (*key_func_)(item_.get()), Group<ContainerT>{*this, next_key()});
+        current_key_group_pair_.emplace(std::invoke(*key_func_, item_.get()),
+            Group<ContainerT>{*this, next_key()});
       }
     }
   };
@@ -208,9 +209,8 @@ class iter::impl::GroupProducer {
     }
 
     // move-constructible, non-copy-constructible, non-assignable
-    Group(Group&& other) noexcept : owner_(other.owner_),
-                                    key_{other.key_},
-                                    completed{other.completed} {
+    Group(Group&& other) noexcept
+        : owner_(other.owner_), key_{other.key_}, completed{other.completed} {
       other.completed = true;
     }
 

From 5d041a451957352d6128084e37ab0e8787b94556 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 31 Mar 2018 20:25:04 -0400
Subject: [PATCH 1705/1866] Adds left_of comparison function to Point

---
 test/helpers.hpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/test/helpers.hpp b/test/helpers.hpp
index ec0180cf..01063643 100644
--- a/test/helpers.hpp
+++ b/test/helpers.hpp
@@ -240,6 +240,10 @@ namespace itertest {
     friend std::ostream& operator<<(std::ostream& out, const Point& p) {
       return out << p.prefix("");
     }
+
+    bool left_of(Point other) const {
+      return x < other.x;
+    }
   };
 }
 template <typename T, typename Inc>

From 1757cfccce1f9984fa62927a1416b8d925a1d9c1 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 31 Mar 2018 20:26:14 -0400
Subject: [PATCH 1706/1866] Tests sorted with pointer to member function

---
 test/test_sorted.cpp | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/test/test_sorted.cpp b/test/test_sorted.cpp
index 930ca4f8..1c584bd0 100644
--- a/test/test_sorted.cpp
+++ b/test/test_sorted.cpp
@@ -29,6 +29,15 @@ TEST_CASE("sorted: iterates through a vector in sorted order", "[sorted]") {
   REQUIRE(v == vc);
 }
 
+TEST_CASE("sorted: handles pointer to member function", "[sorted]") {
+  using itertest::Point;
+  const std::vector<Point> ps = {{5, 0}, {3, 0}, {10, 0}, {6, 0}};
+  auto s = sorted(ps, &Point::left_of);
+  const std::vector<Point> v(std::begin(s), std::end(s));
+  const std::vector<Point> vc = {{3, 0}, {5, 0}, {6, 0}, {10, 0}};
+  REQUIRE(v == vc);
+}
+
 TEST_CASE("sorted: const iteration", "[sorted][const]") {
   Vec ns = {4, 0, 5, 1, 6, 7, 9, 3, 2, 8};
   const auto s = sorted(ns);
@@ -208,7 +217,7 @@ TEST_CASE("sorted: moves rvalues and binds to lvalues", "[sorted]") {
 TEST_CASE("sorted: doesn't move or copy elements of iterable", "[sorted]") {
   using itertest::SolidInt;
   constexpr SolidInt arr[] = {{6}, {7}, {8}};
-  for (auto &&i : sorted(arr, [](const SolidInt &lhs, const SolidInt &rhs) {
+  for (auto &&i : sorted(arr, [](const SolidInt&lhs, const SolidInt&rhs) {
          return lhs.getint() < rhs.getint();
        })) {
     (void)i;

From b1cfc428bec8f81da200f3e7043a71662ed5016b Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 31 Mar 2018 20:26:44 -0400
Subject: [PATCH 1707/1866] Uses std::invoke in sorted

To support pointer to member
---
 sorted.hpp | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/sorted.hpp b/sorted.hpp
index a45cc75c..4e963228 100644
--- a/sorted.hpp
+++ b/sorted.hpp
@@ -5,6 +5,7 @@
 #include "internal/iterbase.hpp"
 
 #include <algorithm>
+#include <functional>
 #include <iterator>
 #include <vector>
 
@@ -44,9 +45,9 @@ class iter::impl::SortedView {
 
       // sort by comparing the elements that the iterators point to
       std::sort(get_begin(sorted_iters_.get()), get_end(sorted_iters_.get()),
-          [compare_func](iterator_type<Container> it1,
-                    iterator_type<Container> it2) {
-            return compare_func(*it1, *it2);
+          [compare_func](
+              iterator_type<Container> it1, iterator_type<Container> it2) {
+            return std::invoke(compare_func, *it1, *it2);
           });
     }
 
@@ -92,7 +93,7 @@ class iter::impl::SortedView {
       // sort by comparing the elements that the iterators point to
       std::sort(get_begin(sorted_iters_.get()), get_end(sorted_iters_.get()),
           [this](iterator_type<ContainerT> it1, iterator_type<ContainerT> it2) {
-            return compare_func_(*it1, *it2);
+            return std::invoke(compare_func_, *it1, *it2);
           });
     }
 
@@ -110,7 +111,7 @@ class iter::impl::SortedView {
       std::sort(get_begin(const_sorted_iters_.get()),
           get_end(const_sorted_iters_.get()),
           [this](iterator_type<AsConst<ContainerT>> it1,
-                    iterator_type<AsConst<ContainerT>> it2) {
+              iterator_type<AsConst<ContainerT>> it2) {
             return compare_func_(*it1, *it2);
           });
     }

From 3e48a5d9a4def3817f54d8afdd5a546f8828a166 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 31 Mar 2018 20:45:16 -0400
Subject: [PATCH 1708/1866] Adds add() function to Point

This function is stupid, only using it for testing purproses. Give me a
break, math kids.
---
 test/helpers.hpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/test/helpers.hpp b/test/helpers.hpp
index 01063643..7c466145 100644
--- a/test/helpers.hpp
+++ b/test/helpers.hpp
@@ -244,6 +244,10 @@ namespace itertest {
     bool left_of(Point other) const {
       return x < other.x;
     }
+
+    Point add(Point other) const {
+      return {x + other.x, y + other.y};
+    }
   };
 }
 template <typename T, typename Inc>

From 7b6714fbbc41758f826345f18c0227003ea18c89 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 31 Mar 2018 20:45:58 -0400
Subject: [PATCH 1709/1866] Tests accumulate with pointer to member function

---
 test/test_accumulate.cpp | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/test/test_accumulate.cpp b/test/test_accumulate.cpp
index 53b3a7e4..3b4ba572 100644
--- a/test/test_accumulate.cpp
+++ b/test/test_accumulate.cpp
@@ -45,6 +45,15 @@ TEST_CASE("accumulate: With subtraction lambda", "[accumulate]") {
   REQUIRE(v == vc);
 }
 
+TEST_CASE("accumulate: handles pointer to member function", "[accumulate]") {
+  using itertest::Point;
+  std::vector<Point> ps = {{1, 2}, {10, 50}, {300, 600}};
+  auto a = accumulate(ps, &Point::add);
+  const std::vector<Point> v(std::begin(a), std::end(a));
+  const std::vector<Point> vc = {{1, 2}, {11, 52}, {311, 652}};
+  REQUIRE(v == vc);
+}
+
 TEST_CASE("accumulate: const iterators", "[accumulate][const]") {
   std::vector<int> v;
   SECTION("lvalue") {
@@ -65,7 +74,8 @@ TEST_CASE("accumulate: const iterators", "[accumulate][const]") {
   REQUIRE(v == vc);
 }
 
-TEST_CASE("accumulate: const iterators can be compared", "[accumulate][const]") {
+TEST_CASE(
+    "accumulate: const iterators can be compared", "[accumulate][const]") {
   auto e = accumulate(std::string("hello"));
   const auto& ce = e;
   (void)(std::begin(e) == std::end(ce));

From bf133cf888af72950a09f7d2852cff8bfa2cded4 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 31 Mar 2018 20:46:51 -0400
Subject: [PATCH 1710/1866] Uses std::invoke in accumulate

To support pointer to member functions
---
 accumulate.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/accumulate.hpp b/accumulate.hpp
index 9d431dc4..5d1e6d68 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -76,7 +76,7 @@ class iter::impl::Accumulator {
     Iterator& operator++() {
       ++sub_iter_;
       if (sub_iter_ != sub_end_) {
-        *acc_val_ = (*accumulate_func_)(*acc_val_, *sub_iter_);
+        *acc_val_ = std::invoke(*accumulate_func_, *acc_val_, *sub_iter_);
       }
       return *this;
     }

From 835559ab67b3ba1efd49c523b77c7a0801e8bdf8 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 1 Apr 2018 22:38:58 -0400
Subject: [PATCH 1711/1866] Removes call_with_tuple, uses std::apply

---
 internal/iter_tuples.hpp | 18 ------------------
 starmap.hpp              | 18 ++++++++++--------
 2 files changed, 10 insertions(+), 26 deletions(-)

diff --git a/internal/iter_tuples.hpp b/internal/iter_tuples.hpp
index 5b3a5cda..c71f8dee 100644
--- a/internal/iter_tuples.hpp
+++ b/internal/iter_tuples.hpp
@@ -51,24 +51,6 @@ namespace iter {
     // results anywhere
     template <typename... Ts>
     void absorb(Ts&&...) {}
-
-    namespace detail {
-      template <typename Func, typename TupleType, std::size_t... Is>
-      decltype(auto) call_with_tuple_impl(
-          Func&& mf, TupleType&& tup, std::index_sequence<Is...>) {
-        return std::invoke(
-            mf, std::forward<std::tuple_element_t<Is,
-                    std::remove_reference_t<TupleType>>>(std::get<Is>(tup))...);
-      }
-    }
-
-    // expand a TupleType into individual arguments when calling a Func
-    template <typename Func, typename TupleType>
-    decltype(auto) call_with_tuple(Func&& mf, TupleType&& tup) {
-      constexpr auto TUP_SIZE = std::tuple_size<std::decay_t<TupleType>>::value;
-      return detail::call_with_tuple_impl(std::forward<Func>(mf),
-          std::forward<TupleType>(tup), std::make_index_sequence<TUP_SIZE>{});
-    }
   }
 }
 
diff --git a/starmap.hpp b/starmap.hpp
index 384bf8f3..681e9926 100644
--- a/starmap.hpp
+++ b/starmap.hpp
@@ -35,7 +35,7 @@ class iter::impl::StarMapper {
   Container container_;
 
   using StarIterDeref = std::remove_reference_t<decltype(
-      call_with_tuple(func_, std::declval<iterator_deref<Container>>()))>;
+      std::apply(func_, std::declval<iterator_deref<Container>>()))>;
 
   StarMapper(Func f, Container&& c)
       : func_(std::move(f)), container_(std::forward<Container>(c)) {}
@@ -83,7 +83,7 @@ class iter::impl::StarMapper {
     }
 
     decltype(auto) operator*() {
-      return call_with_tuple(*func_, *sub_iter_);
+      return std::apply(*func_, *sub_iter_);
     }
 
     auto operator-> () -> ArrowProxy<decltype(**this)> {
@@ -131,7 +131,7 @@ class iter::impl::TupleStarMapper {
    public:
     template <std::size_t Idx>
     static decltype(auto) get_and_call_with_tuple(Func& f, TupTypeT& t) {
-      return call_with_tuple(f, std::get<Idx>(t));
+      return std::apply(f, std::get<Idx>(t));
     }
 
     using ResultType = decltype(get_and_call_with_tuple<0>(func_, tup_));
@@ -238,11 +238,13 @@ struct iter::impl::StarMapFn : PipeableAndBindFirst<StarMapFn> {
  public:
   template <typename Func, typename Seq>
   auto operator()(Func func, Seq&& sequence) const {
-    if constexpr (is_tuple_like<Seq>{}) {
-      return helper_with_tuples(std::move(func), std::forward<Seq>(sequence),
-          std::make_index_sequence<std::tuple_size<std::decay_t<Seq>>::
-                  value>{});
-    } else {
+    if
+      constexpr(is_tuple_like<Seq>{}) {
+        return helper_with_tuples(std::move(func), std::forward<Seq>(sequence),
+            std::make_index_sequence<std::tuple_size<std::decay_t<Seq>>::
+                    value>{});
+      }
+    else {
       return StarMapper<Func, Seq>{
           std::move(func), std::forward<Seq>(sequence)};
     }

From 5941b43ab4430a7afb314a25f345d2de33109449 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 1 Apr 2018 22:54:41 -0400
Subject: [PATCH 1712/1866] Removes definitions for constexpr data members

static constexpr data members are implicitly inline in c++17.
---
 chain.hpp   | 33 ++-------------------------------
 starmap.hpp |  7 -------
 2 files changed, 2 insertions(+), 38 deletions(-)

diff --git a/chain.hpp b/chain.hpp
index fcdfef7f..d7e52f28 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -189,35 +189,6 @@ class iter::impl::Chained {
   }
 };
 
-// jesus christ. what have I done.
-template <typename TupType, std::size_t... Is>
-template <typename TupTypeT>
-constexpr std::array<typename iter::impl::Chained<TupType,
-                         Is...>::template IteratorData<TupTypeT>::DerefFunc,
-    sizeof...(Is)>
-    iter::impl::Chained<TupType, Is...>::IteratorData<TupTypeT>::derefers;
-
-template <typename TupType, std::size_t... Is>
-template <typename TupTypeT>
-constexpr std::array<typename iter::impl::Chained<TupType,
-                         Is...>::template IteratorData<TupTypeT>::ArrowFunc,
-    sizeof...(Is)>
-    iter::impl::Chained<TupType, Is...>::IteratorData<TupTypeT>::arrowers;
-
-template <typename TupType, std::size_t... Is>
-template <typename TupTypeT>
-constexpr std::array<typename iter::impl::Chained<TupType,
-                         Is...>::template IteratorData<TupTypeT>::IncFunc,
-    sizeof...(Is)>
-    iter::impl::Chained<TupType, Is...>::IteratorData<TupTypeT>::incrementers;
-
-template <typename TupType, std::size_t... Is>
-template <typename TupTypeT>
-constexpr std::array<typename iter::impl::Chained<TupType,
-                         Is...>::template IteratorData<TupTypeT>::NeqFunc,
-    sizeof...(Is)>
-    iter::impl::Chained<TupType, Is...>::IteratorData<TupTypeT>::neq_comparers;
-
 template <typename Container>
 class iter::impl::ChainedFromIterable {
  private:
@@ -316,8 +287,8 @@ class iter::impl::ChainedFromIterable {
   }
 
   Iterator<AsConst<Container>> end() const {
-    return {get_end(std::as_const(container_)),
-        get_end(std::as_const(container_))};
+    return {
+        get_end(std::as_const(container_)), get_end(std::as_const(container_))};
   }
 };
 
diff --git a/starmap.hpp b/starmap.hpp
index 681e9926..0952bd1d 100644
--- a/starmap.hpp
+++ b/starmap.hpp
@@ -212,13 +212,6 @@ class iter::impl::TupleStarMapper {
   }
 };
 
-template <typename Func, typename TupType, std::size_t... Is>
-template <typename T>
-constexpr std::array<typename iter::impl::TupleStarMapper<Func, TupType,
-                         Is...>::template IteratorData<T>::CallerFunc,
-    sizeof...(Is)>
-    iter::impl::TupleStarMapper<Func, TupType, Is...>::IteratorData<T>::callers;
-
 struct iter::impl::StarMapFn : PipeableAndBindFirst<StarMapFn> {
  private:
   template <typename Func, typename TupType, std::size_t... Is>

From 693e73f8a34b67fd55008f20aa69bb5050d3dbb0 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 1 Apr 2018 23:04:43 -0400
Subject: [PATCH 1713/1866] formatting for if constexpr

Needed to update my clang-format to 6.0
---
 starmap.hpp | 12 +++++-------
 1 file changed, 5 insertions(+), 7 deletions(-)

diff --git a/starmap.hpp b/starmap.hpp
index 0952bd1d..614e6b75 100644
--- a/starmap.hpp
+++ b/starmap.hpp
@@ -231,13 +231,11 @@ struct iter::impl::StarMapFn : PipeableAndBindFirst<StarMapFn> {
  public:
   template <typename Func, typename Seq>
   auto operator()(Func func, Seq&& sequence) const {
-    if
-      constexpr(is_tuple_like<Seq>{}) {
-        return helper_with_tuples(std::move(func), std::forward<Seq>(sequence),
-            std::make_index_sequence<std::tuple_size<std::decay_t<Seq>>::
-                    value>{});
-      }
-    else {
+    if constexpr (is_tuple_like<Seq>{}) {
+      return helper_with_tuples(std::move(func), std::forward<Seq>(sequence),
+          std::make_index_sequence<
+              std::tuple_size<std::decay_t<Seq>>::value>{});
+    } else {
       return StarMapper<Func, Seq>{
           std::move(func), std::forward<Seq>(sequence)};
     }

From 22c83df10e5f1e2a489c1ac24a3939ad307f1ca2 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 1 Apr 2018 23:09:46 -0400
Subject: [PATCH 1714/1866] No closing namespace comments

Since I keep namespaces as short as possible, mostly just for
declarations, I don't think the closing comments are helpful.
---
 .clang-format | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.clang-format b/.clang-format
index b5f272f2..650739d3 100644
--- a/.clang-format
+++ b/.clang-format
@@ -7,5 +7,6 @@ AllowShortLoopsOnASingleLine: false
 BreakBeforeBinaryOperators: NonAssignment
 DerivePointerAlignment: false
 NamespaceIndentation: All
+FixNamespaceComments: false
 ...
 

From 9beb6867dc19dce16ed6b817d237cefccaf931fb Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 3 Apr 2018 14:11:09 -0400
Subject: [PATCH 1715/1866] Removes explicit tuple types

c++17 explicit tuple constructor rules are relaxed
---
 chain.hpp | 25 ++++++++-----------------
 1 file changed, 8 insertions(+), 17 deletions(-)

diff --git a/chain.hpp b/chain.hpp
index d7e52f28..2b08ae9d 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -160,32 +160,23 @@ class iter::impl::Chained {
   };
 
   Iterator<TupType> begin() {
-    return {0, typename IteratorData<TupType>::IterTupType{get_begin(
-                   std::get<Is>(tup_))...},
-        typename IteratorData<TupType>::IterTupType{
-            get_end(std::get<Is>(tup_))...}};
+    return {0, {get_begin(std::get<Is>(tup_))...},
+        {get_end(std::get<Is>(tup_))...}};
   }
 
   Iterator<TupType> end() {
-    return {sizeof...(Is), typename IteratorData<TupType>::IterTupType{get_end(
-                               std::get<Is>(tup_))...},
-        typename IteratorData<TupType>::IterTupType{
-            get_end(std::get<Is>(tup_))...}};
+    return {sizeof...(Is), {get_end(std::get<Is>(tup_))...},
+        {get_end(std::get<Is>(tup_))...}};
   }
 
   Iterator<AsConst<TupType>> begin() const {
-    return {0, typename IteratorData<AsConst<TupType>>::IterTupType{get_begin(
-                   std::as_const(std::get<Is>(tup_)))...},
-        typename IteratorData<AsConst<TupType>>::IterTupType{
-            get_end(std::as_const(std::get<Is>(tup_)))...}};
+    return {0, {get_begin(std::as_const(std::get<Is>(tup_)))...},
+        {get_end(std::as_const(std::get<Is>(tup_)))...}};
   }
 
   Iterator<AsConst<TupType>> end() const {
-    return {sizeof...(Is),
-        typename IteratorData<AsConst<TupType>>::IterTupType{
-            get_end(std::as_const(std::get<Is>(tup_)))...},
-        typename IteratorData<AsConst<TupType>>::IterTupType{
-            get_end(std::as_const(std::get<Is>(tup_)))...}};
+    return {sizeof...(Is), {get_end(std::as_const(std::get<Is>(tup_)))...},
+        {get_end(std::as_const(std::get<Is>(tup_)))...}};
   }
 };
 

From 90ed62469419cdc9671f9f2b92f945061c409986 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 3 Apr 2018 15:06:21 -0400
Subject: [PATCH 1716/1866] Removes explicit tuple types from zip returns

---
 zip.hpp | 14 +++++---------
 1 file changed, 5 insertions(+), 9 deletions(-)

diff --git a/zip.hpp b/zip.hpp
index 6cd26351..2c041513 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -84,7 +84,7 @@ class iter::impl::Zipped {
     }
 
     TupleDeref<TupleTypeT> operator*() {
-      return TupleDeref<TupleTypeT>{(*std::get<Is>(iters_))...};
+      return {(*std::get<Is>(iters_))...};
     }
 
     auto operator-> () -> ArrowProxy<decltype(**this)> {
@@ -93,27 +93,23 @@ class iter::impl::Zipped {
   };
 
   Iterator<TupleType, iterator_tuple_type, iterator_deref_tuple> begin() {
-    return {iterator_tuple_type<TupleType>{
-        get_begin(std::get<Is>(containers_))...}};
+    return {{get_begin(std::get<Is>(containers_))...}};
   }
 
   Iterator<TupleType, iterator_tuple_type, iterator_deref_tuple> end() {
-    return {
-        iterator_tuple_type<TupleType>{get_end(std::get<Is>(containers_))...}};
+    return {{get_end(std::get<Is>(containers_))...}};
   }
 
   Iterator<AsConst<TupleType>, const_iterator_tuple_type,
       const_iterator_deref_tuple>
   begin() const {
-    return {const_iterator_tuple_type<AsConst<TupleType>>{
-        get_begin(std::as_const(std::get<Is>(containers_)))...}};
+    return {{get_begin(std::as_const(std::get<Is>(containers_)))...}};
   }
 
   Iterator<AsConst<TupleType>, const_iterator_tuple_type,
       const_iterator_deref_tuple>
   end() const {
-    return {const_iterator_tuple_type<AsConst<TupleType>>{
-        get_end(std::as_const(std::get<Is>(containers_)))...}};
+    return {{get_end(std::as_const(std::get<Is>(containers_)))...}};
   }
 };
 

From 786f67099e814b9dcb8fed16a390b0c0282695df Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Wed, 11 Apr 2018 11:46:40 -0400
Subject: [PATCH 1717/1866] Removes explicit tuple types in zip_longest return

---
 zip_longest.hpp | 38 +++++++++++++++-----------------------
 1 file changed, 15 insertions(+), 23 deletions(-)

diff --git a/zip_longest.hpp b/zip_longest.hpp
index c73383c6..3762119e 100644
--- a/zip_longest.hpp
+++ b/zip_longest.hpp
@@ -31,13 +31,12 @@ class iter::impl::ZippedLongest {
       TupleType&&, std::index_sequence<Is...>);
 
   template <std::size_t I, typename TupleTypeT>
-  using OptType = boost::optional<iterator_deref<std::tuple_element_t<I,
-      std::remove_reference_t<TupleTypeT>>>>;
+  using OptType = boost::optional<iterator_deref<
+      std::tuple_element_t<I, std::remove_reference_t<TupleTypeT>>>>;
 
   template <std::size_t I, typename TupleTypeT>
-  using ConstOptType =
-      boost::optional<const_iterator_type_deref<std::tuple_element_t<I,
-          std::remove_reference_t<TupleTypeT>>>>;
+  using ConstOptType = boost::optional<const_iterator_type_deref<
+      std::tuple_element_t<I, std::remove_reference_t<TupleTypeT>>>>;
 
   template <typename TupleTypeT,
       template <std::size_t, typename> class OptTempl>
@@ -100,10 +99,9 @@ class iter::impl::ZippedLongest {
     }
 
     ZipIterDeref<TupleTypeT, OptTempl> operator*() {
-      return ZipIterDeref<TupleTypeT, OptTempl>{
-          ((std::get<Is>(iters_) != std::get<Is>(ends_))
-                  ? OptTempl<Is, TupleTypeT>{*std::get<Is>(iters_)}
-                  : OptTempl<Is, TupleTypeT>{})...};
+      return {((std::get<Is>(iters_) != std::get<Is>(ends_))
+                   ? OptTempl<Is, TupleTypeT>{*std::get<Is>(iters_)}
+                   : OptTempl<Is, TupleTypeT>{})...};
     }
 
     auto operator-> () -> ArrowProxy<decltype(**this)> {
@@ -112,31 +110,25 @@ class iter::impl::ZippedLongest {
   };
 
   Iterator<TupleType, iterator_tuple_type, OptType> begin() {
-    return {
-        iterator_tuple_type<TupleType>{get_begin(std::get<Is>(containers_))...},
-        iterator_tuple_type<TupleType>{get_end(std::get<Is>(containers_))...}};
+    return {{get_begin(std::get<Is>(containers_))...},
+        {get_end(std::get<Is>(containers_))...}};
   }
 
   Iterator<TupleType, iterator_tuple_type, OptType> end() {
-    return {
-        iterator_tuple_type<TupleType>{get_end(std::get<Is>(containers_))...},
-        iterator_tuple_type<TupleType>{get_end(std::get<Is>(containers_))...}};
+    return {{get_end(std::get<Is>(containers_))...},
+        {get_end(std::get<Is>(containers_))...}};
   }
 
   Iterator<AsConst<TupleType>, const_iterator_tuple_type, ConstOptType> begin()
       const {
-    return {const_iterator_tuple_type<AsConst<TupleType>>{
-                get_begin(std::as_const(std::get<Is>(containers_)))...},
-        const_iterator_tuple_type<AsConst<TupleType>>{
-            get_end(std::as_const(std::get<Is>(containers_)))...}};
+    return {{get_begin(std::as_const(std::get<Is>(containers_)))...},
+        {get_end(std::as_const(std::get<Is>(containers_)))...}};
   }
 
   Iterator<AsConst<TupleType>, const_iterator_tuple_type, ConstOptType> end()
       const {
-    return {const_iterator_tuple_type<AsConst<TupleType>>{
-                get_end(std::as_const(std::get<Is>(containers_)))...},
-        const_iterator_tuple_type<AsConst<TupleType>>{
-            get_end(std::as_const(std::get<Is>(containers_)))...}};
+    return {{get_end(std::as_const(std::get<Is>(containers_)))...},
+        {get_end(std::as_const(std::get<Is>(containers_)))...}};
   }
 };
 

From b53c4d66b101b8d26d163cc513d9287ee0b041b3 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Wed, 11 Apr 2018 11:55:30 -0400
Subject: [PATCH 1718/1866] Adds instructions for running tests

---
 README.md | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/README.md b/README.md
index bef2be14..46ee3750 100644
--- a/README.md
+++ b/README.md
@@ -50,6 +50,31 @@ tools except for `zip_longest` which must be included separately.  You may
 also include individual pieces with the relevant header
 (`#include <cppitertools/enumerate.hpp>` for example).
 
+
+### Running tests
+You may use either `scons` or `bazel` to build the tests. `scons` seems
+to work better with viewing the test output, but the same `bazel` command
+can be run from any directory.
+
+To run tests with scons you must be within the `test` directory
+
+```sh
+test$ # build and run all tests
+test$ scons
+test$ ./test_all
+test$ # build and run a specific test
+test$ scons test_enumerate
+test$ ./test_enumerate
+test$ valgrind ./test_enumerate
+```
+
+`bazel` absolute commands can be run from any directory inside the project
+
+```sh
+$ bazel test //test:all # runs all tests
+$ bazel test //test:test_enumerate # runs a specific test
+```
+
 #### Requirements of passed objects
 Most itertools will work with iterables using InputIterators and not copy
 or move any underlying elements.  The itertools that need ForwardIterators or

From e0fdcfacde04ae582b26e79f18bc00ea1ccb7178 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Wed, 11 Apr 2018 12:46:18 -0400
Subject: [PATCH 1719/1866] Tests that enumerate provides references

---
 test/test_enumerate.cpp | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/test/test_enumerate.cpp b/test/test_enumerate.cpp
index 3f061cc1..d5fb4238 100644
--- a/test/test_enumerate.cpp
+++ b/test/test_enumerate.cpp
@@ -56,6 +56,14 @@ TEST_CASE("const enumerate", "[enumerate][const]") {
   REQUIRE(v == vc);
 }
 
+TEST_CASE("enumerate: can modify underlying sequence", "[enumerate]") {
+  std::string s = "abc";
+  for (auto&& [i, c] : enumerate(s)) {
+    c = '-';
+  }
+  REQUIRE(s == "---");
+}
+
 TEST_CASE("enumerate: const iterators can be compared", "[enumerate][const]") {
   auto e = enumerate(std::string("hello"));
   const auto& ce = e;

From e8dff8e8facce3b50dd8a60a261293543e5996d4 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Wed, 11 Apr 2018 12:46:36 -0400
Subject: [PATCH 1720/1866] Removes & from .element in enumerate iter yield

If the underlying sequence provides references, this will still be a
reference type, if it doesn't then this shouldn't have been a reference
type in the first place. Just lucky this didn't cause a problem for
anyone before (that I heard about at least).
---
 enumerate.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index b36a0103..6580b783 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -25,7 +25,7 @@ namespace iter {
 
      public:
       typename BasePair::first_type index = BasePair::first;
-      typename BasePair::second_type& element = BasePair::second;
+      typename BasePair::second_type element = BasePair::second;
     };
 
     template <typename Container, typename Index>

From ea1035ffa7379a1bedea065451e4b7d800dc6d1f Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Tue, 8 May 2018 15:35:54 -0700
Subject: [PATCH 1721/1866] Tests product with 50 of the same container.

---
 test/test_product.cpp | 42 +++++++++++++++++++++++++++++++++---------
 1 file changed, 33 insertions(+), 9 deletions(-)

diff --git a/test/test_product.cpp b/test/test_product.cpp
index d7c113d9..aa7ed1bb 100644
--- a/test/test_product.cpp
+++ b/test/test_product.cpp
@@ -93,15 +93,33 @@ TEST_CASE("product: with repeat", "[product]") {
   ResType v(std::begin(p), std::end(p));
 
   ResType vc = {
-      TP{'h', 'h', 'h'}, TP{'h', 'h', 'o'}, TP{'h', 'h', 'p'},
-      TP{'h', 'o', 'h'}, TP{'h', 'o', 'o'}, TP{'h', 'o', 'p'},
-      TP{'h', 'p', 'h'}, TP{'h', 'p', 'o'}, TP{'h', 'p', 'p'},
-      TP{'o', 'h', 'h'}, TP{'o', 'h', 'o'}, TP{'o', 'h', 'p'},
-      TP{'o', 'o', 'h'}, TP{'o', 'o', 'o'}, TP{'o', 'o', 'p'},
-      TP{'o', 'p', 'h'}, TP{'o', 'p', 'o'}, TP{'o', 'p', 'p'},
-      TP{'p', 'h', 'h'}, TP{'p', 'h', 'o'}, TP{'p', 'h', 'p'},
-      TP{'p', 'o', 'h'}, TP{'p', 'o', 'o'}, TP{'p', 'o', 'p'},
-      TP{'p', 'p', 'h'}, TP{'p', 'p', 'o'}, TP{'p', 'p', 'p'},
+      TP{'h', 'h', 'h'},
+      TP{'h', 'h', 'o'},
+      TP{'h', 'h', 'p'},
+      TP{'h', 'o', 'h'},
+      TP{'h', 'o', 'o'},
+      TP{'h', 'o', 'p'},
+      TP{'h', 'p', 'h'},
+      TP{'h', 'p', 'o'},
+      TP{'h', 'p', 'p'},
+      TP{'o', 'h', 'h'},
+      TP{'o', 'h', 'o'},
+      TP{'o', 'h', 'p'},
+      TP{'o', 'o', 'h'},
+      TP{'o', 'o', 'o'},
+      TP{'o', 'o', 'p'},
+      TP{'o', 'p', 'h'},
+      TP{'o', 'p', 'o'},
+      TP{'o', 'p', 'p'},
+      TP{'p', 'h', 'h'},
+      TP{'p', 'h', 'o'},
+      TP{'p', 'h', 'p'},
+      TP{'p', 'o', 'h'},
+      TP{'p', 'o', 'o'},
+      TP{'p', 'o', 'p'},
+      TP{'p', 'p', 'h'},
+      TP{'p', 'p', 'o'},
+      TP{'p', 'p', 'p'},
   };
   REQUIRE(v == vc);
 }
@@ -186,6 +204,12 @@ TEST_CASE("product: binds to lvalues and moves rvalues", "[product]") {
   }
 }
 
+TEST_CASE("product: handles a lot of containers values", "[product]") {
+  constexpr char str[] = "";
+  auto p = product<50>(str);
+  p.begin();
+}
+
 TEST_CASE("product: doesn't move or copy elements of iterable", "[product]") {
   constexpr itertest::SolidInt arr[] = {{1}, {0}, {2}};
   for (auto&& t : product(arr)) {

From d32698ec3b0b00550219440475e4b12461ab76a6 Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Tue, 8 May 2018 15:36:09 -0700
Subject: [PATCH 1722/1866] Flattens product implementation

This is a combination of the zip() and chain() implementations. Prior to
this, product() with around 18 or more containers was seeing very slow
compile times, and then seg faults at runtime.
---
 product.hpp | 290 +++++++++++++++++++++++++---------------------------
 1 file changed, 140 insertions(+), 150 deletions(-)

diff --git a/product.hpp b/product.hpp
index 74671462..cf7be30e 100644
--- a/product.hpp
+++ b/product.hpp
@@ -1,6 +1,7 @@
 #ifndef ITER_PRODUCT_HPP_
 #define ITER_PRODUCT_HPP_
 
+#include "internal/iter_tuples.hpp"
 #include "internal/iterator_wrapper.hpp"
 #include "internal/iterbase.hpp"
 
@@ -11,79 +12,110 @@
 
 namespace iter {
   namespace impl {
-    template <typename... Containers>
+    template <typename TupleType, std::size_t... Is>
     class Productor;
 
-    template <typename Container, typename... RestContainers>
-    class Productor<Container, RestContainers...>;
-
-    template <>
-    class Productor<>;
+    template <typename TupleType, std::size_t... Is>
+    Productor<TupleType, Is...> product_impl(
+        TupleType&& containers, std::index_sequence<Is...>);
   }
-
-  template <typename... Containers>
-  impl::Productor<Containers...> product(Containers&&...);
 }
 
-// specialization for at least 1 template argument
-template <typename Container, typename... RestContainers>
-class iter::impl::Productor<Container, RestContainers...> {
-  friend Productor iter::product<Container, RestContainers...>(
-      Container&&, RestContainers&&...);
-
-  template <typename... RC>
-  friend class Productor;
-
-  template <typename T>
-  using ProdIterDeref =
-      std::tuple<iterator_deref<T>, iterator_deref<RestContainers>...>;
+template <typename TupleType, std::size_t... Is>
+class iter::impl::Productor {
+  friend Productor iter::impl::product_impl<TupleType, Is...>(
+      TupleType&&, std::index_sequence<Is...>);
 
  private:
-  Container container_;
-  Productor<RestContainers...> rest_products_;
-  Productor(Container&& container, RestContainers&&... rest)
-      : container_(std::forward<Container>(container)),
-        rest_products_{std::forward<RestContainers>(rest)...} {}
+  TupleType containers_;
+
+  Productor(TupleType&& containers) : containers_(std::move(containers)) {}
 
  public:
   Productor(Productor&&) = default;
 
  private:
-  template <typename ContainerT, typename RestIter>
+  template <typename TupTypeT>
+  class IteratorData {
+    IteratorData() = delete;
+    static_assert(
+        std::tuple_size<std::decay_t<TupTypeT>>::value == sizeof...(Is),
+        "tuple size != sizeof Is");
+
+   public:
+    using IterTupType = iterator_tuple_type<TupTypeT>;
+
+    template <std::size_t Idx>
+    static bool equal(const IterTupType& lhs, const IterTupType& rhs) {
+      return !(std::get<Idx>(lhs) != std::get<Idx>(rhs));
+    }
+
+    // returns true if incremented, false if wrapped around
+    template <std::size_t Idx>
+    static bool get_and_increment_with_wraparound(IterTupType& iters,
+        const IterTupType& begin_iters, const IterTupType& end_iters) {
+      // if already at the end, we're looking at an empty container
+      if (equal<Idx>(iters, end_iters)) {
+        return false;
+      }
+
+      ++std::get<Idx>(iters);
+
+      if (equal<Idx>(iters, end_iters)) {
+        std::get<Idx>(iters) = std::get<Idx>(begin_iters);
+        return false;
+      }
+
+      return true;
+    }
+    using IncFunc = bool (*)(
+        IterTupType&, const IterTupType&, const IterTupType&);
+
+    constexpr static std::array<IncFunc, sizeof...(Is)> incrementers{
+        {get_and_increment_with_wraparound<Is>...}};
+  };
+
+  // template templates here because I need to defer evaluation in the const
+  // iteration case for types that don't have non-const begin() and end(). If I
+  // passed in the actual types of the tuples of iterators and the type for
+  // deref they'd need to be known in the function declarations below.
+  template <typename TupleTypeT, template <typename> class IteratorTuple,
+      template <typename> class TupleDeref>
   class IteratorTempl {
    private:
-    template <typename, typename>
+    template <typename, template <typename> class, template <typename> class>
     friend class IteratorTempl;
-    IteratorWrapper<ContainerT> sub_iter_;
-    IteratorWrapper<ContainerT> sub_begin_;
-
-    RestIter rest_iter_;
-    RestIter rest_end_;
+    IteratorTuple<TupleTypeT> iters_;
+    IteratorTuple<TupleTypeT> begin_iters_;
+    IteratorTuple<TupleTypeT> end_iters_;
 
    public:
     using iterator_category = std::input_iterator_tag;
-    using value_type = ProdIterDeref<ContainerT>;
+    using value_type = TupleDeref<TupleTypeT>;
     using difference_type = std::ptrdiff_t;
     using pointer = value_type*;
     using reference = value_type&;
 
-    constexpr static const bool is_base_iter = false;
-    IteratorTempl(IteratorWrapper<ContainerT>&& sub_iter, RestIter&& rest_iter,
-        RestIter&& rest_end)
-        : sub_iter_{sub_iter},
-          sub_begin_{sub_iter},
-          rest_iter_{rest_iter},
-          rest_end_{rest_end} {}
-
-    void reset() {
-      sub_iter_ = sub_begin_;
-    }
+    IteratorTempl(IteratorTuple<TupleTypeT>&& iters,
+        IteratorTuple<TupleTypeT>&& end_iters)
+        : iters_(std::move(iters)),
+          begin_iters_(iters_),
+          end_iters_(std::move(end_iters)) {}
 
     IteratorTempl& operator++() {
-      ++rest_iter_;
-      if (!(rest_iter_ != rest_end_)) {
-        rest_iter_.reset();
-        ++sub_iter_;
+      static constexpr int NUM_ELEMENTS = sizeof...(Is);
+      int i = NUM_ELEMENTS - 1;
+      bool done = false;
+      while (i >= 0) {
+        if (IteratorData<TupleTypeT>::incrementers[i](
+                iters_, begin_iters_, end_iters_)) {
+          done = true;
+          break;
+        }
+        --i;
+      }
+      if (i < 0 && !done) {
+        iters_ = end_iters_;
       }
       return *this;
     }
@@ -94,150 +126,108 @@ class iter::impl::Productor<Container, RestContainers...> {
       return ret;
     }
 
-    template <typename T, typename U>
-    bool operator!=(const IteratorTempl<T, U>& other) const {
-      return sub_iter_ != other.sub_iter_
-             && (RestIter::is_base_iter || rest_iter_ != other.rest_iter_);
+    template <typename T, template <typename> class IT,
+        template <typename> class TD>
+    bool operator!=(const IteratorTempl<T, IT, TD>& other) const {
+      if (sizeof...(Is) == 0) return false;
+
+      bool results[] = {
+          true, (std::get<Is>(iters_) != std::get<Is>(other.iters_))...};
+      return std::all_of(
+          get_begin(results), get_end(results), [](bool b) { return b; });
     }
 
-    template <typename T, typename U>
-    bool operator==(const IteratorTempl<T, U>& other) const {
+    template <typename T, template <typename> class IT,
+        template <typename> class TD>
+    bool operator==(const IteratorTempl<T, IT, TD>& other) const {
       return !(*this != other);
     }
 
-    ProdIterDeref<ContainerT> operator*() {
-      return std::tuple_cat(
-          std::tuple<iterator_deref<ContainerT>>{*sub_iter_}, *rest_iter_);
+    TupleDeref<TupleTypeT> operator*() {
+      return {(*std::get<Is>(iters_))...};
     }
 
-    ArrowProxy<ProdIterDeref<ContainerT>> operator->() {
+    auto operator-> () -> ArrowProxy<decltype(**this)> {
       return {**this};
     }
   };
 
-  using RestIter = typename Productor<RestContainers...>::Iterator;
-  using RestConstIter = typename Productor<RestContainers...>::ConstIterator;
+  using Iterator =
+      IteratorTempl<TupleType, iterator_tuple_type, iterator_deref_tuple>;
+  using ConstIterator = IteratorTempl<AsConst<TupleType>,
+      const_iterator_tuple_type, const_iterator_deref_tuple>;
 
  public:
-  using Iterator = IteratorTempl<Container, RestIter>;
-  using ConstIterator = IteratorTempl<AsConst<Container>, RestConstIter>;
-
   Iterator begin() {
-    return {get_begin(container_), get_begin(rest_products_),
-        get_end(rest_products_)};
+    return {{get_begin(std::get<Is>(containers_))...},
+        {get_end(std::get<Is>(containers_))...}};
   }
 
   Iterator end() {
-    return {
-        get_end(container_), get_end(rest_products_), get_end(rest_products_)};
+    return {{get_end(std::get<Is>(containers_))...},
+        {get_end(std::get<Is>(containers_))...}};
   }
 
   ConstIterator begin() const {
-    return {get_begin(std::as_const(container_)),
-        get_begin(std::as_const(rest_products_)),
-        get_end(std::as_const(rest_products_))};
+    return {{get_begin(std::as_const(std::get<Is>(containers_)))...},
+        {get_end(std::as_const(std::get<Is>(containers_)))...}};
   }
 
   ConstIterator end() const {
-    return {get_end(std::as_const(container_)),
-        get_end(std::as_const(rest_products_)),
-        get_end(std::as_const(rest_products_))};
+    return {{get_end(std::as_const(std::get<Is>(containers_)))...},
+        {get_end(std::as_const(std::get<Is>(containers_)))...}};
   }
 };
 
-template <>
-class iter::impl::Productor<> {
- public:
-  Productor(Productor&&) = default;
-  class Iterator {
-   public:
-    using iterator_category = std::input_iterator_tag;
-    using value_type = std::tuple<>;
-    using difference_type = std::ptrdiff_t;
-    using pointer = value_type*;
-    using reference = value_type&;
-
-    constexpr static const bool is_base_iter = true;
-
-    void reset() {}
-
-    Iterator& operator++() {
-      return *this;
-    }
-
-    Iterator operator++(int) {
-      auto ret = *this;
-      ++*this;
-      return ret;
-    }
-
-    // see note in zip about base case operator!=
-    bool operator!=(const Iterator&) const {
-      return false;
-    }
-
-    bool operator==(const Iterator& other) const {
-      return !(*this != other);
-    }
-
-    std::tuple<> operator*() const {
-      return {};
-    }
-  };
-  using ConstIterator = Iterator;
+namespace iter::impl {
+  template <typename TupleType, std::size_t... Is>
+  Productor<TupleType, Is...> product_impl(
+      TupleType&& containers, std::index_sequence<Is...>) {
+    return {std::move(containers)};
+  }
+}
 
-  Iterator begin() {
-    return {};
+namespace iter {
+  template <typename... Containers>
+  decltype(auto) product(Containers&&... containers) {
+    return impl::product_impl(
+        std::tuple<Containers...>(std::forward<Containers>(containers)...),
+        std::index_sequence_for<Containers...>{});
   }
 
-  Iterator end() {
-    return {};
+  constexpr std::array<std::tuple<>, 1> product() {
+    return {{}};
   }
 
-  ConstIterator begin() const {
-    return {};
+}
+
+namespace iter::impl {
+  // rvalue must be copied, lvalue and const lvalue references can be bound
+  template <std::size_t... Is, typename Container>
+  decltype(auto) product_repeat(
+      std::index_sequence<Is...>, Container&& container) {
+    return product(((void)Is, Container(container))...);
   }
 
-  ConstIterator end() const {
-    return {};
+  template <std::size_t... Is, typename Container>
+  decltype(auto) product_repeat(
+      std::index_sequence<Is...>, Container& container) {
+    return product(((void)Is, container)...);
   }
-};
 
-template <typename... Containers>
-iter::impl::Productor<Containers...> iter::product(Containers&&... containers) {
-  return {std::forward<Containers>(containers)...};
+  template <std::size_t... Is, typename Container>
+  decltype(auto) product_repeat(
+      std::index_sequence<Is...>, const Container& container) {
+    return product(((void)Is, container)...);
+  }
 }
 
 namespace iter {
-  namespace impl {
-    // rvalue must be copied, lvalue and const lvalue references can be bound
-    template <std::size_t... Is, typename Container>
-    decltype(auto) product_repeat(
-        std::index_sequence<Is...>, Container&& container) {
-      return product(((void)Is, Container(container))...);
-    }
-
-    template <std::size_t... Is, typename Container>
-    decltype(auto) product_repeat(
-        std::index_sequence<Is...>, Container& container) {
-      return product(((void)Is, container)...);
-    }
-
-    template <std::size_t... Is, typename Container>
-    decltype(auto) product_repeat(
-        std::index_sequence<Is...>, const Container& container) {
-      return product(((void)Is, container)...);
-    }
-  }
   template <std::size_t N, typename Container>
   decltype(auto) product(Container&& container) {
     return impl::product_repeat(
         std::make_index_sequence<N>{}, std::forward<Container>(container));
   }
-
-  constexpr std::array<std::tuple<>, 1> product() {
-    return {{}};
-  }
 }
 
 #endif

From c8ae589972d97564d4ff84080c7860cdc5ee44bb Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Tue, 8 May 2018 17:58:22 -0700
Subject: [PATCH 1723/1866] Passes IterTupType to product's IteratorData

---
 product.hpp | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

diff --git a/product.hpp b/product.hpp
index cf7be30e..5e0bae30 100644
--- a/product.hpp
+++ b/product.hpp
@@ -35,16 +35,14 @@ class iter::impl::Productor {
   Productor(Productor&&) = default;
 
  private:
-  template <typename TupTypeT>
+  template <typename IterTupType>
   class IteratorData {
     IteratorData() = delete;
     static_assert(
-        std::tuple_size<std::decay_t<TupTypeT>>::value == sizeof...(Is),
+        std::tuple_size<std::decay_t<IterTupType>>::value == sizeof...(Is),
         "tuple size != sizeof Is");
 
    public:
-    using IterTupType = iterator_tuple_type<TupTypeT>;
-
     template <std::size_t Idx>
     static bool equal(const IterTupType& lhs, const IterTupType& rhs) {
       return !(std::get<Idx>(lhs) != std::get<Idx>(rhs));
@@ -85,9 +83,10 @@ class iter::impl::Productor {
    private:
     template <typename, template <typename> class, template <typename> class>
     friend class IteratorTempl;
-    IteratorTuple<TupleTypeT> iters_;
-    IteratorTuple<TupleTypeT> begin_iters_;
-    IteratorTuple<TupleTypeT> end_iters_;
+    using IterTupType = IteratorTuple<TupleTypeT>;
+    IterTupType iters_;
+    IterTupType begin_iters_;
+    IterTupType end_iters_;
 
    public:
     using iterator_category = std::input_iterator_tag;
@@ -107,7 +106,7 @@ class iter::impl::Productor {
       int i = NUM_ELEMENTS - 1;
       bool done = false;
       while (i >= 0) {
-        if (IteratorData<TupleTypeT>::incrementers[i](
+        if (IteratorData<IterTupType>::incrementers[i](
                 iters_, begin_iters_, end_iters_)) {
           done = true;
           break;

From 5ee4304cb88a4c31ff273dcaf98bdb370f5dce87 Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Tue, 8 May 2018 18:03:59 -0700
Subject: [PATCH 1724/1866] Cleans up product increment

---
 product.hpp | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/product.hpp b/product.hpp
index 5e0bae30..7fc6acc8 100644
--- a/product.hpp
+++ b/product.hpp
@@ -103,17 +103,15 @@ class iter::impl::Productor {
 
     IteratorTempl& operator++() {
       static constexpr int NUM_ELEMENTS = sizeof...(Is);
-      int i = NUM_ELEMENTS - 1;
-      bool done = false;
-      while (i >= 0) {
+      bool performed_increment = false;
+      for (int i = NUM_ELEMENTS - 1; i >= 0; --i) {
         if (IteratorData<IterTupType>::incrementers[i](
                 iters_, begin_iters_, end_iters_)) {
-          done = true;
+          performed_increment = true;
           break;
         }
-        --i;
       }
-      if (i < 0 && !done) {
+      if (!performed_increment) {
         iters_ = end_iters_;
       }
       return *this;

From 1f4560a4c0afdb24cc9ebee8af65a95ee4a76158 Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Fri, 11 May 2018 17:31:31 -0700
Subject: [PATCH 1725/1866] Attempting to build on windows

---
 test/SConstruct | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/test/SConstruct b/test/SConstruct
index 5c4bc272..171bf49d 100644
--- a/test/SConstruct
+++ b/test/SConstruct
@@ -1,15 +1,15 @@
 import os
+import platform
+
+cc_flags = ["-I.",  "-std=c++17", "-Wall",]
+
+if platform != "Windows":
+    cc_flags += ["-Wextra", "-pedantic", "-g", '-I/usr/local/include']
 
 env = Environment(
     ENV = os.environ,
-    CXXFLAGS= ['-g', '-Wall', '-Wextra',
-               '-pedantic', '-std=c++17',
-               '-I/usr/local/include', '-I.'],
-    CPPPATH='..',
-    LINKFLAGS=['-L/usr/local/lib'])
-
-# allows highighting to print to terminal from compiler output
-env['ENV']['TERM'] = os.environ['TERM']
+    CXXFLAGS= cc_flags,
+    CPPPATH='..')
 
 progs = Split(
     '''

From ba3b5de472c23b679a4cf1abfa463a8f6c51fe19 Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Fri, 11 May 2018 17:37:50 -0700
Subject: [PATCH 1726/1866] Don't check for catch on windows

---
 test/SConstruct | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/SConstruct b/test/SConstruct
index 171bf49d..53a2649b 100644
--- a/test/SConstruct
+++ b/test/SConstruct
@@ -53,7 +53,7 @@ progs = Split(
 conf = Configure(env)
 
 # if catch isn't available, exit
-if not conf.CheckCXXHeader('catch.hpp'):
+if platform != 'Windows' and not conf.CheckCXXHeader('catch.hpp'):
     print("WARNING: catch.hpp not found, run ./download_catch.sh first")
     print("note: you may receive this warning if the c++ compiler specified "
           "by CXX  at the top of the SConstruct file is invalid.")

From 76d4048b1b54b225dcab0db25f8aea8c90904b59 Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Fri, 11 May 2018 17:40:22 -0700
Subject: [PATCH 1727/1866] Fixes platform check

---
 test/SConstruct | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/test/SConstruct b/test/SConstruct
index 53a2649b..9d1e64c4 100644
--- a/test/SConstruct
+++ b/test/SConstruct
@@ -1,9 +1,11 @@
 import os
 import platform
 
+print('platform:', platform.system())
+
 cc_flags = ["-I.",  "-std=c++17", "-Wall",]
 
-if platform != "Windows":
+if platform.system() != "Windows":
     cc_flags += ["-Wextra", "-pedantic", "-g", '-I/usr/local/include']
 
 env = Environment(
@@ -53,7 +55,7 @@ progs = Split(
 conf = Configure(env)
 
 # if catch isn't available, exit
-if platform != 'Windows' and not conf.CheckCXXHeader('catch.hpp'):
+if platform.system() != 'Windows' and not conf.CheckCXXHeader('catch.hpp'):
     print("WARNING: catch.hpp not found, run ./download_catch.sh first")
     print("note: you may receive this warning if the c++ compiler specified "
           "by CXX  at the top of the SConstruct file is invalid.")

From 2ade01e733749562855a64a16e0fb890c5677783 Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Fri, 11 May 2018 17:45:23 -0700
Subject: [PATCH 1728/1866] Fixes windows std flag

---
 test/SConstruct | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/test/SConstruct b/test/SConstruct
index 9d1e64c4..5966a145 100644
--- a/test/SConstruct
+++ b/test/SConstruct
@@ -1,12 +1,14 @@
 import os
 import platform
 
-print('platform:', platform.system())
+print("platform:", platform.system())
 
-cc_flags = ["-I.",  "-std=c++17", "-Wall",]
+cc_flags = ["-I.", "-Wall",]
 
-if platform.system() != "Windows":
-    cc_flags += ["-Wextra", "-pedantic", "-g", '-I/usr/local/include']
+if platform.system() == "Windows":
+    cc_flags += ["-std:c++17"]
+else:
+    cc_flags += ["-Wextra", "-std=c++17", "-pedantic", "-g", '-I/usr/local/include']
 
 env = Environment(
     ENV = os.environ,

From a3b4e0b033ac01017ec4e3b7716b2a034249e980 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 13 May 2018 22:27:52 -0400
Subject: [PATCH 1729/1866] Replaces std::result_of with std::invoke_result

std::result_of is deprecated
---
 accumulate.hpp | 4 ++--
 groupby.hpp    | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/accumulate.hpp b/accumulate.hpp
index 5d1e6d68..0d43a20e 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -28,8 +28,8 @@ class iter::impl::Accumulator {
 
   friend AccumulateFn;
 
-  using AccumVal = std::remove_reference_t<std::result_of_t<AccumulateFunc(
-      iterator_deref<Container>, iterator_deref<Container>)>>;
+  using AccumVal = std::remove_reference_t<std::invoke_result_t<AccumulateFunc,
+      iterator_deref<Container>, iterator_deref<Container>>>;
 
   Accumulator(Container&& container, AccumulateFunc accumulate_func)
       : container_(std::forward<Container>(container)),
diff --git a/groupby.hpp b/groupby.hpp
index a496ba67..4f2fffb5 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -39,7 +39,7 @@ class iter::impl::GroupProducer {
   friend GroupByFn;
 
   template <typename T>
-  using key_func_ret = std::result_of_t<KeyFunc(iterator_deref<T>)>;
+  using key_func_ret = std::invoke_result_t<KeyFunc, iterator_deref<T>>;
 
   GroupProducer(Container&& container, KeyFunc key_func)
       : container_(std::forward<Container>(container)), key_func_(key_func) {}

From 9e72b897e0a7777d684768aa784d89cb44721ab8 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Wed, 16 May 2018 01:56:14 -0400
Subject: [PATCH 1730/1866] Revert "Fixes windows std flag"

This reverts commit 2ade01e733749562855a64a16e0fb890c5677783.
---
 test/SConstruct | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/test/SConstruct b/test/SConstruct
index 5966a145..9d1e64c4 100644
--- a/test/SConstruct
+++ b/test/SConstruct
@@ -1,14 +1,12 @@
 import os
 import platform
 
-print("platform:", platform.system())
+print('platform:', platform.system())
 
-cc_flags = ["-I.", "-Wall",]
+cc_flags = ["-I.",  "-std=c++17", "-Wall",]
 
-if platform.system() == "Windows":
-    cc_flags += ["-std:c++17"]
-else:
-    cc_flags += ["-Wextra", "-std=c++17", "-pedantic", "-g", '-I/usr/local/include']
+if platform.system() != "Windows":
+    cc_flags += ["-Wextra", "-pedantic", "-g", '-I/usr/local/include']
 
 env = Environment(
     ENV = os.environ,

From d2cbc3d4f04a385a422c7a98a24fc60f268b393c Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Wed, 16 May 2018 01:56:23 -0400
Subject: [PATCH 1731/1866] Revert "Fixes platform check"

This reverts commit 76d4048b1b54b225dcab0db25f8aea8c90904b59.
---
 test/SConstruct | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/test/SConstruct b/test/SConstruct
index 9d1e64c4..53a2649b 100644
--- a/test/SConstruct
+++ b/test/SConstruct
@@ -1,11 +1,9 @@
 import os
 import platform
 
-print('platform:', platform.system())
-
 cc_flags = ["-I.",  "-std=c++17", "-Wall",]
 
-if platform.system() != "Windows":
+if platform != "Windows":
     cc_flags += ["-Wextra", "-pedantic", "-g", '-I/usr/local/include']
 
 env = Environment(
@@ -55,7 +53,7 @@ progs = Split(
 conf = Configure(env)
 
 # if catch isn't available, exit
-if platform.system() != 'Windows' and not conf.CheckCXXHeader('catch.hpp'):
+if platform != 'Windows' and not conf.CheckCXXHeader('catch.hpp'):
     print("WARNING: catch.hpp not found, run ./download_catch.sh first")
     print("note: you may receive this warning if the c++ compiler specified "
           "by CXX  at the top of the SConstruct file is invalid.")

From 1c93b1599ef154a262581e2bc7551507e61e3fd3 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Wed, 16 May 2018 01:56:31 -0400
Subject: [PATCH 1732/1866] Revert "Don't check for catch on windows"

This reverts commit ba3b5de472c23b679a4cf1abfa463a8f6c51fe19.
---
 test/SConstruct | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/SConstruct b/test/SConstruct
index 53a2649b..171bf49d 100644
--- a/test/SConstruct
+++ b/test/SConstruct
@@ -53,7 +53,7 @@ progs = Split(
 conf = Configure(env)
 
 # if catch isn't available, exit
-if platform != 'Windows' and not conf.CheckCXXHeader('catch.hpp'):
+if not conf.CheckCXXHeader('catch.hpp'):
     print("WARNING: catch.hpp not found, run ./download_catch.sh first")
     print("note: you may receive this warning if the c++ compiler specified "
           "by CXX  at the top of the SConstruct file is invalid.")

From 1ed3ff88bac354e4ebb3dfc89af962acf2f613cf Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Wed, 16 May 2018 01:56:40 -0400
Subject: [PATCH 1733/1866] Revert "Attempting to build on windows"

This reverts commit 1f4560a4c0afdb24cc9ebee8af65a95ee4a76158.
---
 test/SConstruct | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/test/SConstruct b/test/SConstruct
index 171bf49d..5c4bc272 100644
--- a/test/SConstruct
+++ b/test/SConstruct
@@ -1,15 +1,15 @@
 import os
-import platform
-
-cc_flags = ["-I.",  "-std=c++17", "-Wall",]
-
-if platform != "Windows":
-    cc_flags += ["-Wextra", "-pedantic", "-g", '-I/usr/local/include']
 
 env = Environment(
     ENV = os.environ,
-    CXXFLAGS= cc_flags,
-    CPPPATH='..')
+    CXXFLAGS= ['-g', '-Wall', '-Wextra',
+               '-pedantic', '-std=c++17',
+               '-I/usr/local/include', '-I.'],
+    CPPPATH='..',
+    LINKFLAGS=['-L/usr/local/lib'])
+
+# allows highighting to print to terminal from compiler output
+env['ENV']['TERM'] = os.environ['TERM']
 
 progs = Split(
     '''

From 739780b331f0395d492b722080db30e49bb32df8 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Wed, 16 May 2018 10:23:30 -0400
Subject: [PATCH 1734/1866] Adds default initializer for range::iter::is_end

---
 range.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/range.hpp b/range.hpp
index 8a9a4791..d4727b4b 100644
--- a/range.hpp
+++ b/range.hpp
@@ -131,7 +131,7 @@ class iter::impl::Range {
   class Iterator {
    private:
     iter::detail::RangeIterData<T> data;
-    bool is_end;
+    bool is_end{};
 
     // first argument must be regular iterator
     // second argument must be end iterator

From e3a4c1fb79fefc21ae153209f965a62717699b6e Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Wed, 20 Jun 2018 16:40:33 -0700
Subject: [PATCH 1735/1866] Uses DerefHolder in chain.from_iterable

Previously chain.from_iterable couldn't accept an iterable that yielded
rvalues.
---
 chain.hpp | 33 +++++++++++++++++----------------
 1 file changed, 17 insertions(+), 16 deletions(-)

diff --git a/chain.hpp b/chain.hpp
index 2b08ae9d..8a0522e3 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -200,9 +200,22 @@ class iter::impl::ChainedFromIterable {
 
     IteratorWrapper<ContainerT> top_level_iter_;
     IteratorWrapper<ContainerT> top_level_end_;
+    DerefHolder<SubContainer> sub_iterable_;
     std::optional<SubIter> sub_iter_p_;
     std::optional<SubIter> sub_end_p_;
 
+    void next_sub_iterable() {
+      if (top_level_iter_ != top_level_end_) {
+        sub_iterable_.reset(*top_level_iter_);
+        sub_iter_p_ =
+            std::make_optional<SubIter>(get_begin(sub_iterable_.get()));
+        sub_end_p_ = std::make_optional<SubIter>(get_end(sub_iterable_.get()));
+      } else {
+        sub_iter_p_.reset();
+        sub_end_p_.reset();
+      }
+    }
+
    public:
     using iterator_category = std::input_iterator_tag;
     using value_type = iterator_traits_deref<iterator_deref<ContainerT>>;
@@ -213,27 +226,15 @@ class iter::impl::ChainedFromIterable {
     Iterator(IteratorWrapper<ContainerT>&& top_iter,
         IteratorWrapper<ContainerT>&& top_end)
         : top_level_iter_{std::move(top_iter)},
-          top_level_end_{std::move(top_end)},
-          sub_iter_p_{!(top_iter != top_end)
-                          ?  // iter == end ?
-                          std::nullopt
-                          : std::make_optional<SubIter>(get_begin(*top_iter))},
-          sub_end_p_{!(top_iter != top_end)
-                         ?  // iter == end ?
-                         std::nullopt
-                         : std::make_optional<SubIter>(get_end(*top_iter))} {}
+          top_level_end_{std::move(top_end)} {
+      next_sub_iterable();
+    }
 
     Iterator& operator++() {
       ++*sub_iter_p_;
       if (!(*sub_iter_p_ != *sub_end_p_)) {
         ++top_level_iter_;
-        if (top_level_iter_ != top_level_end_) {
-          sub_iter_p_ = get_begin(*top_level_iter_);
-          sub_end_p_ = get_end(*top_level_iter_);
-        } else {
-          sub_iter_p_.reset();
-          sub_end_p_.reset();
-        }
+        next_sub_iterable();
       }
       return *this;
     }

From c09fcf03e9fdf7334649c3794f8af8aaa9e25fcf Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Wed, 20 Jun 2018 16:58:30 -0700
Subject: [PATCH 1736/1866] chain.from_iterable(imap([](auto v){return v},x))

The key point is that the imap callable returns values, not references.
---
 test/test_mixed.cpp | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/test/test_mixed.cpp b/test/test_mixed.cpp
index ecf65091..c4da12b2 100644
--- a/test/test_mixed.cpp
+++ b/test/test_mixed.cpp
@@ -143,3 +143,16 @@ TEST_CASE("filter into enumerate with pipe", "[filter][enumerate]") {
   const Vec vc = {{0, 42}, {1, 44}};
   REQUIRE(v == vc);
 }
+
+TEST_CASE("chain.from_iterable: accept imap result that yields rvalues",
+          "[chain.from_iterable][imap]") {
+  using iter::chain;
+  using iter::imap;
+  const std::vector<std::vector<char>> ns = {{'a'}, {'q'}, {'x', 'z'}};
+  auto ch = iter::chain.from_iterable(iter::imap([](auto v) { return v; }, ns));
+  const std::vector<char> v(std::begin(ch), std::end(ch));
+
+  const std::vector<char> vc = {'a', 'q', 'x', 'z'};
+
+  REQUIRE(v == vc);
+}

From 08a40b593d3e4d0541003183995c0d11a9d8ef08 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fran=C3=A7ois-R=20Boyer?= <Francois-R.Boyer@PolyMtl.ca>
Date: Sat, 8 Sep 2018 22:37:10 -0400
Subject: [PATCH 1737/1866] Added CMake files for better cross-platform build
 support. - Currently on MSVC cl 19.15.26726, only 5/34 test files compile and
 pass tests

---
 examples/CMakeLists.txt | 22 ++++++++++++++++++++++
 test/CMakeLists.txt     | 32 ++++++++++++++++++++++++++++++++
 2 files changed, 54 insertions(+)
 create mode 100644 examples/CMakeLists.txt
 create mode 100644 test/CMakeLists.txt

diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
new file mode 100644
index 00000000..23cf493a
--- /dev/null
+++ b/examples/CMakeLists.txt
@@ -0,0 +1,22 @@
+# Note that some examples currently use boost.optional which we do no not search for in this file.
+# You might have to use the "keep going" option to continue building on errors if boost.optional is not in the include path.
+# For example, building with MSVC (from an examples/buildMsvc directory):
+#   set CXX=cl.exe
+#   cmake .. -G Ninja
+#   cmake --build . -- -k99
+
+cmake_minimum_required(VERSION 3.8)
+project(cppitertools_examples CXX)
+set (CMAKE_CXX_STANDARD 17)
+
+include_directories(
+	..
+)
+
+file(GLOB _examples_files "*_examples.cpp")
+
+foreach(_file_cpp ${_examples_files})
+	get_filename_component(_name_cpp "${_file_cpp}" NAME)
+	get_filename_component(_name_without_extension "${_name_cpp}" NAME_WE)
+	add_executable(${_name_without_extension} ${_file_cpp})
+endforeach()
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
new file mode 100644
index 00000000..315e4b04
--- /dev/null
+++ b/test/CMakeLists.txt
@@ -0,0 +1,32 @@
+# Note that some examples currently use boost.optional which we do no not search for in this file.
+# You might have to use the "keep going" option to continue building on errors if boost.optional is not in the include path.
+# For example, building with MSVC (from a test/buildMsvc directory):
+#   set CXX=cl.exe
+#   cmake .. -G Ninja
+#   cmake --build . -- -k99
+
+cmake_minimum_required(VERSION 3.8)
+project(cppitertools_tests CXX)
+set (CMAKE_CXX_STANDARD 17)
+
+include_directories(
+	..
+)
+
+include(CheckIncludeFileCXX)
+set(CMAKE_REQUIRED_INCLUDES ${PROJECT_SOURCE_DIR})
+CHECK_INCLUDE_FILE_CXX(catch.hpp _has_catch)
+if(NOT "${_has_catch}")
+	message("WARNING: catch.hpp not found, run ./download_catch.sh from test/ directory first")
+endif()
+
+file(GLOB test_sources RELATIVE ${PROJECT_SOURCE_DIR} "test_*.cpp")
+list(REMOVE_ITEM test_sources test_main.cpp)
+add_library(test_main OBJECT test_main.cpp)
+
+foreach(_source_cpp ${test_sources})
+	get_filename_component(_name_without_extension "${_source_cpp}" NAME_WE)
+	add_executable(${_name_without_extension} ${_source_cpp} $<TARGET_OBJECTS:test_main>)
+endforeach()
+
+add_executable(test_all ${test_sources} $<TARGET_OBJECTS:test_main>)

From 39158fb150056ad2d0ae611d947b6aa5b63027eb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fran=C3=A7ois-R=20Boyer?= <Francois-R.Boyer@PolyMtl.ca>
Date: Sun, 9 Sep 2018 00:04:28 -0400
Subject: [PATCH 1738/1866] - Use of C++17 is_same_v instead of instatiating
 is_same or using ::value (but kept tests using old syntax). - Fixed bug that
 operators * and -> should be const in IteratorIterator as they do not modify
 the iterator. - Changed name of template parameter from Container to T in
 iterator_type, because of a bug in MSVC. - Used an explicit decltype, instead
 of decltype(auto), in TupleStarMapper::IteratorData::get_and_call_with_tuple
 because MSVC was not able to deduce it. - Fixed bug in filterfalse_examples
 where <string> was not included. Result with MSVC: - All tests pass and
 examples are running, in release build. - 4/34 test files fail in debug,
 because of STL assertion failure.

---
 examples/filterfalse_examples.cpp | 1 +
 internal/iterator_wrapper.hpp     | 6 +++---
 internal/iteratoriterator.hpp     | 4 ++--
 internal/iterbase.hpp             | 4 ++--
 reversed.hpp                      | 4 ++--
 starmap.hpp                       | 2 +-
 6 files changed, 11 insertions(+), 10 deletions(-)

diff --git a/examples/filterfalse_examples.cpp b/examples/filterfalse_examples.cpp
index f03debfa..dd937cee 100644
--- a/examples/filterfalse_examples.cpp
+++ b/examples/filterfalse_examples.cpp
@@ -1,6 +1,7 @@
 #include <filterfalse.hpp>
 
 #include <vector>
+#include <string>
 #include <iostream>
 
 bool greater_than_four(int i) {
diff --git a/internal/iterator_wrapper.hpp b/internal/iterator_wrapper.hpp
index a9c3f5d9..2d91fc02 100644
--- a/internal/iterator_wrapper.hpp
+++ b/internal/iterator_wrapper.hpp
@@ -32,15 +32,15 @@ namespace iter {
 
     template <typename Container>
     using IteratorWrapper = typename IteratorWrapperImplType<Container,
-        std::is_same<impl::iterator_type<Container>,
-            impl::iterator_end_type<Container>>{}>::type;
+        std::is_same_v<impl::iterator_type<Container>,
+            impl::iterator_end_type<Container>>>::type;
   }
 }
 
 template <typename SubIter, typename SubEnd>
 class iter::impl::IteratorWrapperImpl {
  private:
-  static_assert(!std::is_same<SubIter, SubEnd>{});
+  static_assert(!std::is_same_v<SubIter, SubEnd>);
   SubIter& sub_iter() {
     auto* sub = std::get_if<SubIter>(&sub_iter_or_end_);
     assert(sub);
diff --git a/internal/iteratoriterator.hpp b/internal/iteratoriterator.hpp
index 87ed74d1..a01c0d27 100644
--- a/internal/iteratoriterator.hpp
+++ b/internal/iteratoriterator.hpp
@@ -80,11 +80,11 @@ namespace iter {
         return ret;
       }
 
-      auto operator*() -> decltype(**sub_iter) {
+      auto operator*() const -> decltype(**sub_iter) {
         return **this->sub_iter;
       }
 
-      auto operator-> () -> decltype(*sub_iter) {
+      auto operator-> () const -> decltype(*sub_iter) {
         return *this->sub_iter;
       }
 
diff --git a/internal/iterbase.hpp b/internal/iterbase.hpp
index 60e31517..6232c300 100644
--- a/internal/iterbase.hpp
+++ b/internal/iterbase.hpp
@@ -51,8 +51,8 @@ namespace iter {
     using AsConst = decltype(std::as_const(std::declval<T&>()));
 
     // iterator_type<C> is the type of C's iterator
-    template <typename Container>
-    using iterator_type = decltype(get_begin(std::declval<Container&>()));
+    template <typename T> //TODO: See bug https://developercommunity.visualstudio.com/content/problem/252157/sfinae-error-depends-on-name-of-template-parameter.html  for why we use T instead of Container.  Should be changed back to Container when that bug is fixed in MSVC.
+    using iterator_type = decltype(get_begin(std::declval<T&>()));
 
     // iterator_type<C> is the type of C's iterator
     template <typename Container>
diff --git a/reversed.hpp b/reversed.hpp
index fcf04d27..3b914bb1 100644
--- a/reversed.hpp
+++ b/reversed.hpp
@@ -35,9 +35,9 @@ namespace iter {
     template <typename Container>
     using ReverseIteratorWrapper =
         typename ReverseIteratorWrapperImplType<Container,
-            std::is_same<impl::reverse_iterator_type<Container>,
+            std::is_same_v<impl::reverse_iterator_type<Container>,
                                                     impl::
-                                                        reverse_iterator_end_type<Container>>{}>::
+                                                        reverse_iterator_end_type<Container>>>::
             type;
 
     template <typename Container>
diff --git a/starmap.hpp b/starmap.hpp
index 614e6b75..d3fb678b 100644
--- a/starmap.hpp
+++ b/starmap.hpp
@@ -130,7 +130,7 @@ class iter::impl::TupleStarMapper {
   class IteratorData {
    public:
     template <std::size_t Idx>
-    static decltype(auto) get_and_call_with_tuple(Func& f, TupTypeT& t) {
+    static auto get_and_call_with_tuple(Func& f, TupTypeT& t) -> decltype(std::apply(f, std::get<Idx>(t))) { //TODO: Remove duplicated expression in decltype, using decltype(auto) as return type, when all compilers correctly deduce type (i.e. MSVC cl 19.15 does not do it).
       return std::apply(f, std::get<Idx>(t));
     }
 

From 9d6bf0e918f3bfb711733a70c20afed3592fb953 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fran=C3=A7ois-R=20Boyer?= <Francois-R.Boyer@PolyMtl.ca>
Date: Sun, 9 Sep 2018 00:50:07 -0400
Subject: [PATCH 1739/1866] =?UTF-8?q?-=20Fixed=20bug=20in=20combinations?=
 =?UTF-8?q?=20and=20combinations=5Fwith=5Freplacement,=20where=20rbegin()-?=
 =?UTF-8?q?1=20was=20used=20but=20is=20undefined=20behavior=20(see=20C++17?=
 =?UTF-8?q?=20[bidirectional.iterators]=20and=20[random.access.iterators])?=
 =?UTF-8?q?.=20-=20Fixed=20incorrect=20test=20in=20test=5Fsorted=20that=20?=
 =?UTF-8?q?was=20not=20checking=20the=20result=20of=20the=20comparision,?=
 =?UTF-8?q?=20but=20is=20disabled=20for=20now=20as=20it=20compares=20itera?=
 =?UTF-8?q?tors=20on=20different=20containers,=20which=20is=20undefined=20?=
 =?UTF-8?q?behavior=20(see=20C++17=20[forward.iterators]=C2=B62).=20-=20No?=
 =?UTF-8?q?w=20all=20tests=20are=20passing=20with=20MSVC.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 combinations.hpp                  | 5 +++--
 combinations_with_replacement.hpp | 5 +++--
 test/test_sorted.cpp              | 7 ++++---
 3 files changed, 10 insertions(+), 7 deletions(-)

diff --git a/combinations.hpp b/combinations.hpp
index bfee2c86..7572142c 100644
--- a/combinations.hpp
+++ b/combinations.hpp
@@ -94,10 +94,11 @@ class iter::impl::Combinator {
         if (!(dumb_next(*iter, dist) != get_end(*container_p_))) {
           if ((iter + 1) != indices_.get().rend()) {
             size_t inc = 1;
-            for (auto down = iter; down != indices_.get().rbegin() - 1;
-                 --down) {
+            for (auto down = iter; ; --down) {
               (*down) = dumb_next(*(iter + 1), 1 + inc);
               ++inc;
+              if (down == indices_.get().rbegin())
+                break;
             }
           } else {
             steps_ = COMPLETE;
diff --git a/combinations_with_replacement.hpp b/combinations_with_replacement.hpp
index 5455a6e4..b7e20d7d 100644
--- a/combinations_with_replacement.hpp
+++ b/combinations_with_replacement.hpp
@@ -74,9 +74,10 @@ class iter::impl::CombinatorWithReplacement {
         ++(*iter);
         if (!(*iter != get_end(*container_p_))) {
           if ((iter + 1) != indices_.get().rend()) {
-            for (auto down = iter; down != indices_.get().rbegin() - 1;
-                 --down) {
+            for (auto down = iter; ; --down) {
               (*down) = dumb_next(*(iter + 1));
+              if (down == indices_.get().rbegin())
+                break;
             }
           } else {
             steps_ = COMPLETE;
diff --git a/test/test_sorted.cpp b/test/test_sorted.cpp
index 1c584bd0..7c31a638 100644
--- a/test/test_sorted.cpp
+++ b/test/test_sorted.cpp
@@ -46,11 +46,12 @@ TEST_CASE("sorted: const iteration", "[sorted][const]") {
   REQUIRE(v == vc);
 }
 
+//FIXME: This test currently fails (STL assertion fails on MSVC with debug library, simple test failure on gcc).  The problem is 'sorted' will sort twice, once for non-const and once for const container; the resulting iterators are thus not on the same container (violating domain of == as specified in C++17 [forward.iterators]¶2).  Remove [!hide] tag when fixed.
 TEST_CASE("sorted: const iterators can be compared to non-const iterators",
-    "[sorted][const]") {
-  auto s = sorted(Vec{});
+    "[sorted][const][!hide]") {
+  auto s = sorted(Vec{1});
   const auto& cs = s;
-  (void)(std::begin(s) == std::end(cs));
+  REQUIRE(std::begin(s) == std::begin(cs));
 }
 
 TEST_CASE("sorted: can modify elements through sorted", "[sorted]") {

From 32f4dc22dbd04cc5c9c4b71ebedcffd2eb93b9da Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fran=C3=A7ois-R=20Boyer?= <Francois-R.Boyer@PolyMtl.ca>
Date: Sun, 9 Sep 2018 12:12:28 -0400
Subject: [PATCH 1740/1866] - Corrected all warnings at /W4 with MSVC (except
 in test_starmap, where it would slightly change tests) - Replaced std::all_of
 and any_of by fold expressions

---
 product.hpp                   | 9 +++------
 test/test_accumulate.cpp      | 2 +-
 test/test_mixed.cpp           | 4 ++--
 test/test_sorted.cpp          | 6 +++---
 test/test_unique_everseen.cpp | 6 +++---
 test/test_unique_justseen.cpp | 6 +++---
 test/test_zip_longest.cpp     | 4 ++--
 zip.hpp                       | 9 +++------
 zip_longest.hpp               | 7 +------
 9 files changed, 21 insertions(+), 32 deletions(-)

diff --git a/product.hpp b/product.hpp
index 7fc6acc8..38836fba 100644
--- a/product.hpp
+++ b/product.hpp
@@ -126,12 +126,9 @@ class iter::impl::Productor {
     template <typename T, template <typename> class IT,
         template <typename> class TD>
     bool operator!=(const IteratorTempl<T, IT, TD>& other) const {
-      if (sizeof...(Is) == 0) return false;
-
-      bool results[] = {
-          true, (std::get<Is>(iters_) != std::get<Is>(other.iters_))...};
-      return std::all_of(
-          get_begin(results), get_end(results), [](bool b) { return b; });
+      if constexpr (sizeof...(Is) == 0) return false;
+      else
+        return (... && (std::get<Is>(iters_) != std::get<Is>(other.iters_)));
     }
 
     template <typename T, template <typename> class IT,
diff --git a/test/test_accumulate.cpp b/test/test_accumulate.cpp
index 3b4ba572..02467fb2 100644
--- a/test/test_accumulate.cpp
+++ b/test/test_accumulate.cpp
@@ -93,7 +93,7 @@ TEST_CASE("accumulate: intermidate type need not be default constructible",
     "[accumulate]") {
   std::vector<Integer> v = {{2}, {3}, {10}};
   auto a = accumulate(v, std::plus<Integer>{});
-  std::begin(a);
+  (void)std::begin(a);
 }
 
 TEST_CASE("accumulate: binds reference when it should", "[accumulate]") {
diff --git a/test/test_mixed.cpp b/test/test_mixed.cpp
index c4da12b2..46d47f03 100644
--- a/test/test_mixed.cpp
+++ b/test/test_mixed.cpp
@@ -21,8 +21,8 @@ class MyUnMovable {
   constexpr int get_val() const {
     return val;
   }
-  void set_val(int val) {
-    this->val = val;
+  void set_val(int new_val) {
+    this->val = new_val;
   }
 
   bool operator==(const MyUnMovable& other) const {
diff --git a/test/test_sorted.cpp b/test/test_sorted.cpp
index 7c31a638..ff151576 100644
--- a/test/test_sorted.cpp
+++ b/test/test_sorted.cpp
@@ -68,12 +68,12 @@ char inc_vowels(char c) {
 }
 
 TEST_CASE("sorted: Works with different begin and end types", "[sorted]") {
-  using Vec = std::vector<char>;
+  using VecC = std::vector<char>;
   CharRange cr{'g'};
   auto s =
       sorted(cr, [](char x, char y) { return inc_vowels(x) < inc_vowels(y); });
-  Vec v(s.begin(), s.end());
-  Vec vc{'b', 'c', 'd', 'f', 'a', 'e'};
+  VecC v(s.begin(), s.end());
+  VecC vc{'b', 'c', 'd', 'f', 'a', 'e'};
   REQUIRE(v == vc);
 }
 
diff --git a/test/test_unique_everseen.cpp b/test/test_unique_everseen.cpp
index c34bb74d..d70de075 100644
--- a/test/test_unique_everseen.cpp
+++ b/test/test_unique_everseen.cpp
@@ -65,10 +65,10 @@ TEST_CASE(
 TEST_CASE("unique everseen: Works with different begin and end types",
     "[unique_everseen]") {
   CharRange cr{'d'};
-  using Vec = std::vector<char>;
+  using VecC = std::vector<char>;
   auto ue = unique_everseen(cr);
-  Vec v(ue.begin(), ue.end());
-  Vec vc{'a', 'b', 'c'};
+  VecC v(ue.begin(), ue.end());
+  VecC vc{'a', 'b', 'c'};
   REQUIRE(v == vc);
 }
 
diff --git a/test/test_unique_justseen.cpp b/test/test_unique_justseen.cpp
index 2614aa89..c6671e5f 100644
--- a/test/test_unique_justseen.cpp
+++ b/test/test_unique_justseen.cpp
@@ -54,10 +54,10 @@ TEST_CASE("unique justseen: some repeating values", "[unique_justseen]") {
 TEST_CASE("unique justseen: Works with different begin and end types",
     "[unique_justseen]") {
   CharRange cr{'d'};
-  using Vec = std::vector<char>;
+  using VecC = std::vector<char>;
   auto uj = unique_justseen(cr);
-  Vec v(uj.begin(), uj.end());
-  Vec vc{'a', 'b', 'c'};
+  VecC v(uj.begin(), uj.end());
+  VecC vc{'a', 'b', 'c'};
   REQUIRE(v == vc);
 }
 
diff --git a/test/test_zip_longest.cpp b/test/test_zip_longest.cpp
index a737b6b7..4759a412 100644
--- a/test/test_zip_longest.cpp
+++ b/test/test_zip_longest.cpp
@@ -118,8 +118,8 @@ TEST_CASE("zip_longest: const iterators can be compared to non-const iterators",
     "[zip_longest][const]") {
   auto zl = zip_longest(std::vector<int>{});
   const auto& czl = zl;
-  std::begin(zl);
-  std::begin(czl);
+  (void)std::begin(zl);
+  (void)std::begin(czl);
   (void)(std::begin(zl) == std::end(czl));
 }
 
diff --git a/zip.hpp b/zip.hpp
index 2c041513..ee973b9e 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -69,12 +69,9 @@ class iter::impl::Zipped {
     template <typename T, template <typename> class IT,
         template <typename> class TD>
     bool operator!=(const Iterator<T, IT, TD>& other) const {
-      if (sizeof...(Is) == 0) return false;
-
-      bool results[] = {
-          true, (std::get<Is>(iters_) != std::get<Is>(other.iters_))...};
-      return std::all_of(
-          get_begin(results), get_end(results), [](bool b) { return b; });
+      if constexpr (sizeof...(Is) == 0) return false;
+      else
+        return (... && (std::get<Is>(iters_) != std::get<Is>(other.iters_)));
     }
 
     template <typename T, template <typename> class IT,
diff --git a/zip_longest.hpp b/zip_longest.hpp
index 3762119e..89e637e3 100644
--- a/zip_longest.hpp
+++ b/zip_longest.hpp
@@ -84,12 +84,7 @@ class iter::impl::ZippedLongest {
     template <typename T, template <typename> class TT,
         template <std::size_t, typename> class TU>
     bool operator!=(const Iterator<T, TT, TU>& other) const {
-      if (sizeof...(Is) == 0) return false;
-
-      bool results[] = {
-          false, (std::get<Is>(iters_) != std::get<Is>(other.iters_))...};
-      return std::any_of(
-          get_begin(results), get_end(results), [](bool b) { return b; });
+      return (... || (std::get<Is>(iters_) != std::get<Is>(other.iters_)));
     }
 
     template <typename T, template <typename> class TT,

From 419a22acb403eaeda1361e3a60236d5aa788e38f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fran=C3=A7ois-R=20Boyer?= <Francois-R.Boyer@PolyMtl.ca>
Date: Sun, 9 Sep 2018 12:14:06 -0400
Subject: [PATCH 1741/1866] - Corrected warnings at /W4 with MSVC in
 test_starmap (slightly changes the types used in the tests)

---
 test/test_starmap.cpp | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/test/test_starmap.cpp b/test/test_starmap.cpp
index bb98a349..4c12b7c1 100644
--- a/test/test_starmap.cpp
+++ b/test/test_starmap.cpp
@@ -27,8 +27,8 @@ namespace {
       return a + b + c;
     }
 
-    int operator()(int a, int b) {
-      return a + b;
+    int operator()(double a, int b) {
+      return int(a + b);
     }
 
     int operator()(int a) {
@@ -39,7 +39,7 @@ namespace {
 
 TEST_CASE("starmap: works with function pointer and lambda", "[starmap]") {
   using Vec = const std::vector<int>;
-  const std::vector<std::pair<double, int>> v1 = {{1l, 2}, {3l, 11}, {6l, 7}};
+  const std::vector<std::pair<long, int>> v1 = {{1l, 2}, {3l, 11}, {6l, 7}};
   Vec vc = {2l, 33l, 42l};
 
   std::vector<int> v;
@@ -74,7 +74,7 @@ TEST_CASE("starmap: works with pointer to member function", "[starmap]") {
 
 TEST_CASE("starmap: vector of pairs const iteration", "[starmap][const]") {
   using Vec = const std::vector<int>;
-  const std::vector<std::pair<double, int>> v1 = {{1l, 2}, {3l, 11}, {6l, 7}};
+  const std::vector<std::pair<double, int>> v1 = {{1.0, 2}, {3.0, 11}, {6.0, 7}};
 
   const auto sm = starmap(Callable{}, v1);
   std::vector<int> v(std::begin(sm), std::end(sm));
@@ -121,7 +121,7 @@ TEST_CASE(
 
 TEST_CASE("starmap: list of tuples", "[starmap]") {
   using Vec = const std::vector<std::string>;
-  using T = std::tuple<std::string, int, double>;
+  using T = std::tuple<std::string, int, char>;
   std::list<T> li = {T{"hey", 42, 'a'}, T{"there", 3, 'b'}, T{"yall", 5, 'c'}};
 
   auto sm = starmap(g, li);
@@ -172,7 +172,7 @@ TEST_CASE("starmap: moves rvalues, binds to lvalues", "[starmap]") {
 TEST_CASE("starmap: iterator meets requirements", "[starmap]") {
   std::string s{};
   const std::vector<std::pair<double, int>> v1;
-  auto sm = starmap([](long a, int b) { return a * b; }, v1);
+  auto sm = starmap([](double a, int b) { return a * b; }, v1);
   REQUIRE(itertest::IsIterator<decltype(std::begin(sm))>::value);
 }
 

From 54d6d5a6dfce9c5851ce78843b3f96be18246280 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fran=C3=A7ois-R=20Boyer?= <Francois-R.Boyer@PolyMtl.ca>
Date: Sun, 30 Sep 2018 20:18:54 -0400
Subject: [PATCH 1742/1866] - IteratorIterator operator[] is now const, as
 required by RandomAccessIterator - Removed incorrect operaror - where (2 -
 it) would give (it - 2) - Added tests to cover all methods in
 iteratoriterator.hpp

---
 internal/iteratoriterator.hpp  |   7 +--
 test/test_iteratoriterator.cpp | 106 +++++++++++++++++++++++++++++++++
 2 files changed, 107 insertions(+), 6 deletions(-)

diff --git a/internal/iteratoriterator.hpp b/internal/iteratoriterator.hpp
index a01c0d27..3993a4d0 100644
--- a/internal/iteratoriterator.hpp
+++ b/internal/iteratoriterator.hpp
@@ -115,16 +115,11 @@ namespace iter {
         return it;
       }
 
-      friend IteratorIterator operator-(Diff n, IteratorIterator it) {
-        it -= n;
-        return it;
-      }
-
       Diff operator-(const IteratorIterator& rhs) const {
         return this->sub_iter - rhs.sub_iter;
       }
 
-      auto operator[](Diff idx) -> decltype(*sub_iter[idx]) {
+      auto operator[](Diff idx) const -> decltype(*sub_iter[idx]) {
         return *sub_iter[idx];
       }
 
diff --git a/test/test_iteratoriterator.cpp b/test/test_iteratoriterator.cpp
index c4442f7a..dd2c4987 100644
--- a/test/test_iteratoriterator.cpp
+++ b/test/test_iteratoriterator.cpp
@@ -2,6 +2,7 @@
 
 #include <string>
 #include <vector>
+#include <utility>
 
 #include "catch.hpp"
 
@@ -61,3 +62,108 @@ TEST_CASE("Iterate over a vector of string iterators", "[iteratoriterator]") {
                     std::iterator_traits<decltype(it)>::reference>::value,
       "iterator is mis marked");
 }
+
+TEST_CASE("IteratorIterator supports mutable RandomAccessIterator operators",
+    "[iteratoriterator]") {
+  using std::vector;
+  struct S {
+    int value;
+  };
+  vector<S> v = {{2}, {4}, {6}, {8}};
+
+  IterIterWrapper<vector<vector<S>::iterator>> itr;
+  itr.get().push_back(std::begin(v) + 1);
+  itr.get().push_back(std::end(v) - 1);
+  itr.get().push_back(std::begin(v));
+
+  // RandomAccessIterator (and ForwardIterator):
+  auto a = itr.begin();
+  auto r = a;
+  auto r2 = r;
+  ((r += 2) -= 2) += 2;
+  REQUIRE(&(++r2) == &r2);  // Required by OutputIterator.
+  REQUIRE(&(*r2++) == &a[1]);
+  REQUIRE(r == r2);
+  auto test_const_or_not = [&itr](auto& a, auto& b) {
+    REQUIRE(!(b == a));
+    REQUIRE(b == a + 2);
+    REQUIRE(b == 2 + a);
+    REQUIRE(b - 2 == a);
+    REQUIRE(&a[2] == &b[0]);
+    REQUIRE(b - a == 2);
+    REQUIRE(a < b);
+    REQUIRE(!(a < a));
+    REQUIRE(b > a);
+    REQUIRE(!(a > a));
+    REQUIRE(a <= b);
+    REQUIRE(!(b <= a));
+    REQUIRE(a <= a);
+    REQUIRE(b >= a);
+    REQUIRE(!(a >= b));
+    REQUIRE(a >= a);
+
+    // InputIterator:
+    REQUIRE(b != a);
+    REQUIRE(!(a != a));
+    REQUIRE(&(*a) != &(*b));
+    REQUIRE(&(a->value) == &(*a).value);
+
+    // Added methods, not from ...Iterator:
+    REQUIRE(a.get() == std::begin(itr.get()));
+  };
+  test_const_or_not(a, r);
+  test_const_or_not(std::as_const(a), r);
+  test_const_or_not(a, std::as_const(r));
+  test_const_or_not(std::as_const(a), std::as_const(r));
+
+  // BidirectionalIterator (and RandomAccessIterator):
+  REQUIRE((--r)-- == a + 1);
+  REQUIRE(r == a);
+  REQUIRE(&(*r2--) == &a[2]);
+
+  // OutputIterator (and RandomAccessIterator):
+  *r++ = {10};
+  REQUIRE(r == a + 1);
+  REQUIRE(v[1].value == 10);
+  *++r = {12};
+  REQUIRE(r == a + 2);
+  REQUIRE(v[0].value == 12);
+  *r = {14};
+  REQUIRE(r == a + 2);
+  REQUIRE(v[0].value == 14);
+  a[1] = {16};
+  REQUIRE(a == itr.begin());
+  REQUIRE(v[3].value == 16);
+}
+
+TEST_CASE("IterIterWrapper supports several SequenceContainer methodes",
+    "[iteratoriterator]") {
+  using std::vector;
+  vector<int> v = {2, 4, 6, 8};
+
+  IterIterWrapper<vector<vector<int>::iterator>> itr;
+  itr.get().push_back(std::begin(v) + 1);
+  itr.get().push_back(std::end(v) - 1);
+
+  auto test_const_or_not = [&v](auto& c) {
+    REQUIRE(c.at(0) == 4);
+    REQUIRE(c.at(1) == 8);
+    REQUIRE(c[0] == 4);
+    REQUIRE(c[1] == 8);
+    REQUIRE(!c.empty());
+    REQUIRE(c.size() == 2);
+    REQUIRE(*c.begin() == 4);
+    REQUIRE(*(c.end() - 1) == 8);
+    REQUIRE(*c.cbegin() == 4);
+    REQUIRE(*(c.cend() - 1) == 8);
+    REQUIRE(*c.rbegin() == 8);
+    REQUIRE(*(c.rend() - 1) == 4);
+    REQUIRE(*c.crbegin() == 8);
+    REQUIRE(*(c.crend() - 1) == 4);
+
+    // Added methods, not from SequenceContainer:
+    REQUIRE(c.get()[0] == std::begin(v) + 1);
+  };
+  test_const_or_not(itr);
+  test_const_or_not(std::as_const(itr));
+}

From 06e592338617519fe8279a1e79d042b8c2aaaf48 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 19 Oct 2018 11:09:35 -0400
Subject: [PATCH 1743/1866] s/protected/private in Filter Iterator

It should have been private afaict, but this matters because of gcc bug
87652
https://gcc.gnu.org/bugzilla/show_bug.cgi?id=87652#
---
 filter.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/filter.hpp b/filter.hpp
index 0676917b..10a793c6 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -46,7 +46,7 @@ class iter::impl::Filtered {
 
   template <typename ContainerT>
   class Iterator {
-   protected:
+   private:
     template <typename>
     friend class Iterator;
     using Holder = DerefHolder<iterator_deref<ContainerT>>;

From 829254264e9259a1e99fd364a5e3dcba3a86daac Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 20 Oct 2018 20:13:40 -0400
Subject: [PATCH 1744/1866] Messing with travis

---
 .travis.yml | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 .travis.yml

diff --git a/.travis.yml b/.travis.yml
new file mode 100644
index 00000000..bbe56ec9
--- /dev/null
+++ b/.travis.yml
@@ -0,0 +1,20 @@
+language: cpp
+
+script: scons
+
+before_script: cd test
+
+matrix:
+    # works on Precise and Trusty
+    - os: linux
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+            - g++-7
+      env:
+        - MATRIX_EVAL="CC=gcc-7 && CXX=g++-7"
+
+before_install:
+    - eval "${MATRIX_EVAL}"

From 58d4776b924569f8d472d749e3e18dafc652ab8f Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 21 Oct 2018 02:25:33 -0400
Subject: [PATCH 1745/1866] Uses CXX from enviroment to build tests if provided

---
 test/SConstruct | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/test/SConstruct b/test/SConstruct
index 5c4bc272..8c884bf6 100644
--- a/test/SConstruct
+++ b/test/SConstruct
@@ -11,6 +11,11 @@ env = Environment(
 # allows highighting to print to terminal from compiler output
 env['ENV']['TERM'] = os.environ['TERM']
 
+try:
+    env.Replace(CXX=os.environ['CXX'])
+except KeyError:
+    pass
+
 progs = Split(
     '''
     accumulate

From dd0e49943b950f5e48a27ef23f2b9ea0d675539d Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 21 Oct 2018 11:55:03 -0400
Subject: [PATCH 1746/1866] If clang, use libc++

---
 test/SConstruct | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/test/SConstruct b/test/SConstruct
index 8c884bf6..e338b923 100644
--- a/test/SConstruct
+++ b/test/SConstruct
@@ -16,6 +16,10 @@ try:
 except KeyError:
     pass
 
+if env['CXX'].startswith('clang++'):
+    env['CXXFLAGS'].append('-stdlib=libc++')
+    env['LINKFLAGS'].append('-stdlib=libc++')
+
 progs = Split(
     '''
     accumulate

From f61f46a0a6f037ae8fe3e3a5b243899851e03883 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 22 Oct 2018 13:48:50 -0400
Subject: [PATCH 1747/1866] specifies linker libs for clang

---
 test/SConstruct | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/SConstruct b/test/SConstruct
index e338b923..5122d8d4 100644
--- a/test/SConstruct
+++ b/test/SConstruct
@@ -18,7 +18,7 @@ except KeyError:
 
 if env['CXX'].startswith('clang++'):
     env['CXXFLAGS'].append('-stdlib=libc++')
-    env['LINKFLAGS'].append('-stdlib=libc++')
+    env['LINKFLAGS'].extend(['-lc++', '-lc++abi'])
 
 progs = Split(
     '''

From 008493b21627f36cda42ef95b9c9c324d37f198b Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 22 Oct 2018 14:07:59 -0400
Subject: [PATCH 1748/1866] Revert "specifies linker libs for clang"

This reverts commit f61f46a0a6f037ae8fe3e3a5b243899851e03883.
---
 test/SConstruct | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/SConstruct b/test/SConstruct
index 5122d8d4..e338b923 100644
--- a/test/SConstruct
+++ b/test/SConstruct
@@ -18,7 +18,7 @@ except KeyError:
 
 if env['CXX'].startswith('clang++'):
     env['CXXFLAGS'].append('-stdlib=libc++')
-    env['LINKFLAGS'].extend(['-lc++', '-lc++abi'])
+    env['LINKFLAGS'].append('-stdlib=libc++')
 
 progs = Split(
     '''

From d2663addceb9a27e04f67acc72c58eb479c14278 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 27 Oct 2018 16:41:41 -0400
Subject: [PATCH 1749/1866] Uses custom test class for pointer to mem function

Looking at the discussion on a clang bug, although the error I'm seeing
isn't related, the code I had wasn't guaranteed to be portable anyway.

https://bugs.llvm.org/show_bug.cgi?id=39463
---
 test/helpers.hpp        | 21 ++++++++++++++++++
 test/test_dropwhile.cpp | 11 +++++-----
 test/test_groupby.cpp   | 48 ++++++++++++++++++++++++++++++-----------
 3 files changed, 62 insertions(+), 18 deletions(-)

diff --git a/test/helpers.hpp b/test/helpers.hpp
index 7c466145..aa80cd3c 100644
--- a/test/helpers.hpp
+++ b/test/helpers.hpp
@@ -31,6 +31,27 @@ namespace itertest {
     SolidInt(SolidInt&&) = delete;
   };
 
+  class Integer {
+   private:
+    int i_{};
+
+   public:
+    constexpr Integer(int i) : i_{i} {}
+    constexpr bool is_zero() const {
+      return i_ == 0;
+    }
+    constexpr bool operator==(const Integer& other) const {
+      return i_ == other.i_;
+    }
+    constexpr bool operator!=(const Integer& other) const {
+      return i_ != other.i_;
+    }
+
+    constexpr bool is_positive() const {
+      return i_ > 0;
+    }
+  };
+
   namespace {
     struct DoubleDereferenceError : std::exception {
       const char* what() const noexcept override {
diff --git a/test/test_dropwhile.cpp b/test/test_dropwhile.cpp
index 38e686aa..55370092 100644
--- a/test/test_dropwhile.cpp
+++ b/test/test_dropwhile.cpp
@@ -60,11 +60,12 @@ TEST_CASE("dropwhile: handles pointer to member", "[dropwhile]") {
   REQUIRE(v == vc);
 }
 
-TEST_CASE("dropwhile: drop empty strings at front", "[dropwhile]") {
-  const std::vector<std::string> words = {"", "", "check", "", "test"};
-  auto dw = dropwhile(&std::string::empty, words);
-  const std::vector<std::string> v(std::begin(dw), std::end(dw));
-  const std::vector<std::string> vc = {"check", "", "test"};
+TEST_CASE("dropwhile: drop zeros from front", "[dropwhile]") {
+  using itertest::Integer;
+  const std::vector<Integer> nums = {0, 0, 3, 4, 0, 5, 0};
+  auto dw = dropwhile(&Integer::is_zero, nums);
+  const std::vector<Integer> v(std::begin(dw), std::end(dw));
+  const std::vector<Integer> vc = {3, 4, 0, 5, 0};
   REQUIRE(v == vc);
 }
 
diff --git a/test/test_groupby.cpp b/test/test_groupby.cpp
index 1f86a40e..0069da14 100644
--- a/test/test_groupby.cpp
+++ b/test/test_groupby.cpp
@@ -59,24 +59,36 @@ TEST_CASE("groupby: works with lambda, callable, and function pointer") {
     }
   }
 
-  SECTION("pointer to member") {
-    for (auto&& gb : groupby(vec, &std::string::size)) {
-      keys.push_back(gb.first);
-      groups.emplace_back(std::begin(gb.second), std::end(gb.second));
-    }
-  }
-
   const std::vector<int> kc = {2, 3, 5};
   REQUIRE(keys == kc);
 
   const std::vector<std::vector<std::string>> gc = {
-      {"hi", "ab", "ho"}, {"abc", "def"}, {"abcde", "efghi"},
+      {"hi", "ab", "ho"},
+      {"abc", "def"},
+      {"abcde", "efghi"},
   };
 
   REQUIRE(groups == gc);
 }
 
-TEST_CASE("groupby: handles pointer to member", "[groupby]") {
+TEST_CASE("groupby: handles pointer to member function", "[groupby]") {
+  std::vector<itertest::Integer> nums = {
+      10, 20, 30, -5, 40, -6, -7, 50, 60, -8, -9, -10, -11, 70};
+
+  std::vector<std::vector<itertest::Integer>> groups;
+  std::vector<bool> keys;
+  for (auto&& gb : groupby(nums, &itertest::Integer::is_positive)) {
+    keys.push_back(gb.first);
+    groups.emplace_back(std::begin(gb.second), std::end(gb.second));
+  }
+  const std::vector<bool> kc = {true, false, true, false, true, false, true};
+  const std::vector<std::vector<itertest::Integer>> gc = {
+      {10, 20, 30}, {-5}, {40}, {-6, -7}, {50, 60}, {-8, -9, -10, -11}, {70}};
+  REQUIRE(keys == kc);
+  REQUIRE(groups == gc);
+}
+
+TEST_CASE("groupby: handles pointer to data member", "[groupby]") {
   using itertest::Point;
   const std::vector<Point> ps = {
       {0, 2}, {0, 4}, {1, 3}, {1, 7}, {1, 10}, {1, 12}, {3, 5}};
@@ -151,7 +163,9 @@ TEST_CASE("groupby: const iteration", "[groupby][const]") {
   REQUIRE(keys == kc);
 
   const std::vector<std::vector<std::string>> gc = {
-      {"hi", "ab", "ho"}, {"abc", "def"}, {"abcde", "efghi"},
+      {"hi", "ab", "ho"},
+      {"abc", "def"},
+      {"abcde", "efghi"},
   };
 
   REQUIRE(groups == gc);
@@ -203,7 +217,8 @@ TEST_CASE("groupby: groups can be skipped completely", "[groupby]") {
   REQUIRE(keys == kc);
 
   const std::vector<std::vector<std::string>> gc = {
-      {"hi", "ab", "ho"}, {"abcde", "efghi"},
+      {"hi", "ab", "ho"},
+      {"abcde", "efghi"},
   };
 
   REQUIRE(groups == gc);
@@ -226,7 +241,9 @@ TEST_CASE("groupby: groups can be skipped partially", "[groupby]") {
   REQUIRE(keys == kc);
 
   const std::vector<std::vector<std::string>> gc = {
-      {"hi", "ab", "ho"}, {"abc"}, {"abcde", "efghi"},
+      {"hi", "ab", "ho"},
+      {"abc"},
+      {"abcde", "efghi"},
   };
 
   REQUIRE(groups == gc);
@@ -253,7 +270,12 @@ TEST_CASE("groupby: single argument uses elements as keys", "[groupby]") {
   REQUIRE(keys == kc);
 
   std::vector<std::vector<int>> gc = {
-      {5, 5}, {6, 6}, {19, 19, 19, 19}, {69}, {0}, {10, 10},
+      {5, 5},
+      {6, 6},
+      {19, 19, 19, 19},
+      {69},
+      {0},
+      {10, 10},
   };
 
   REQUIRE(groups == gc);

From 8e55c430740031ec09d3344055f64f671717cfca Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 27 Oct 2018 16:56:48 -0400
Subject: [PATCH 1750/1866] Adds script to install new enough libc++ on travis

---
 .install-libcxx-travis.sh | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 .install-libcxx-travis.sh

diff --git a/.install-libcxx-travis.sh b/.install-libcxx-travis.sh
new file mode 100644
index 00000000..158cebef
--- /dev/null
+++ b/.install-libcxx-travis.sh
@@ -0,0 +1,17 @@
+#!/usr/bin/env bash
+
+if [[  "${COMPILER}" = clang++* ]]; then
+  echo "using clang, install libc++"
+  sudo apt-get install -y dpkg
+  wget -c http://launchpadlibrarian.net/360656578/libc++-helpers_6.0-2_all.deb
+  sudo dpkg -i libc++-helpers_6.0-2_all.deb
+  wget -c http://launchpadlibrarian.net/360656583/libc++abi1_6.0-2_amd64.deb
+  sudo dpkg -i libc++abi1_6.0-2_amd64.deb
+  wget -c http://launchpadlibrarian.net/360656580/libc++1_6.0-2_amd64.deb
+  sudo dpkg -i libc++1_6.0-2_amd64.deb
+  wget -c http://launchpadlibrarian.net/360656576/libc++-dev_6.0-2_amd64.deb
+  sudo dpkg -i libc++-dev_6.0-2_amd64.deb
+  wget -c http://launchpadlibrarian.net/360656581/libc++abi-dev_6.0-2_amd64.deb
+  sudo dpkg -i libc++abi-dev_6.0-2_amd64.deb
+  sudo apt-get install -f
+fi

From a19b44774fb7637de6dd8812d54c9ccb38841ecb Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 27 Oct 2018 16:58:10 -0400
Subject: [PATCH 1751/1866] Removes conditions from libcxx install script

---
 .install-libcxx-travis.sh | 27 ++++++++++++---------------
 1 file changed, 12 insertions(+), 15 deletions(-)

diff --git a/.install-libcxx-travis.sh b/.install-libcxx-travis.sh
index 158cebef..e108ea9e 100644
--- a/.install-libcxx-travis.sh
+++ b/.install-libcxx-travis.sh
@@ -1,17 +1,14 @@
 #!/usr/bin/env bash
 
-if [[  "${COMPILER}" = clang++* ]]; then
-  echo "using clang, install libc++"
-  sudo apt-get install -y dpkg
-  wget -c http://launchpadlibrarian.net/360656578/libc++-helpers_6.0-2_all.deb
-  sudo dpkg -i libc++-helpers_6.0-2_all.deb
-  wget -c http://launchpadlibrarian.net/360656583/libc++abi1_6.0-2_amd64.deb
-  sudo dpkg -i libc++abi1_6.0-2_amd64.deb
-  wget -c http://launchpadlibrarian.net/360656580/libc++1_6.0-2_amd64.deb
-  sudo dpkg -i libc++1_6.0-2_amd64.deb
-  wget -c http://launchpadlibrarian.net/360656576/libc++-dev_6.0-2_amd64.deb
-  sudo dpkg -i libc++-dev_6.0-2_amd64.deb
-  wget -c http://launchpadlibrarian.net/360656581/libc++abi-dev_6.0-2_amd64.deb
-  sudo dpkg -i libc++abi-dev_6.0-2_amd64.deb
-  sudo apt-get install -f
-fi
+sudo apt-get install -y dpkg
+wget -c http://launchpadlibrarian.net/360656578/libc++-helpers_6.0-2_all.deb
+sudo dpkg -i libc++-helpers_6.0-2_all.deb
+wget -c http://launchpadlibrarian.net/360656583/libc++abi1_6.0-2_amd64.deb
+sudo dpkg -i libc++abi1_6.0-2_amd64.deb
+wget -c http://launchpadlibrarian.net/360656580/libc++1_6.0-2_amd64.deb
+sudo dpkg -i libc++1_6.0-2_amd64.deb
+wget -c http://launchpadlibrarian.net/360656576/libc++-dev_6.0-2_amd64.deb
+sudo dpkg -i libc++-dev_6.0-2_amd64.deb
+wget -c http://launchpadlibrarian.net/360656581/libc++abi-dev_6.0-2_amd64.deb
+sudo dpkg -i libc++abi-dev_6.0-2_amd64.deb
+sudo apt-get install -f

From 9f37bf7049dc6987cbc785fc5ca642a4924e0ff1 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 27 Oct 2018 17:37:16 -0400
Subject: [PATCH 1752/1866] Removes shebang from libcxx install

---
 .install-libcxx-travis.sh | 2 --
 1 file changed, 2 deletions(-)

diff --git a/.install-libcxx-travis.sh b/.install-libcxx-travis.sh
index e108ea9e..98b18fb0 100644
--- a/.install-libcxx-travis.sh
+++ b/.install-libcxx-travis.sh
@@ -1,5 +1,3 @@
-#!/usr/bin/env bash
-
 sudo apt-get install -y dpkg
 wget -c http://launchpadlibrarian.net/360656578/libc++-helpers_6.0-2_all.deb
 sudo dpkg -i libc++-helpers_6.0-2_all.deb

From 4c14dd96a58d74ad38ce98deff96d874777c0a48 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 27 Oct 2018 17:44:48 -0400
Subject: [PATCH 1753/1866] Travis build for gcc-[7,8] and clang-[5.0, 6.0]

Using libc++ with clang.
---
 .travis.yml | 70 +++++++++++++++++++++++++++++++++++++++++++++++------
 1 file changed, 62 insertions(+), 8 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index bbe56ec9..d4d97a0d 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,11 +1,43 @@
 language: cpp
-
-script: scons
-
-before_script: cd test
+dist: trusty
+sudo: require
 
 matrix:
-    # works on Precise and Trusty
+  include:
+    - os: linux
+      compiler: clang
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-5.0
+          packages:
+            - clang-5.0
+            - clang++-5.0
+            - valgrind
+            - gcc-8-base
+            - libc6
+            - libgcc1
+      env:
+        - COMPILER=clang++-5.0
+        - USE_LIBCXX=1
+    - os: linux
+      compiler: clang
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-6.0
+          packages:
+            - clang-6.0
+            - clang++-6.0
+            - valgrind
+            - gcc-8-base
+            - libc6
+            - libgcc1
+      env:
+        - COMPILER=clang++-6.0
+        - USE_LIBCXX=1
     - os: linux
       addons:
         apt:
@@ -13,8 +45,30 @@ matrix:
             - ubuntu-toolchain-r-test
           packages:
             - g++-7
+            - valgrind
+      env:
+        - COMPILER=g++-7
+    - os: linux
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+            - g++-8
+            - valgrind
       env:
-        - MATRIX_EVAL="CC=gcc-7 && CXX=g++-7"
+        - COMPILER=g++-8
+
+script:
+  - ${COMPILER} --version
+  - CXX="${COMPILER}" scons
+  - ./test_all
+  - valgrind ./test_all
+
 
-before_install:
-    - eval "${MATRIX_EVAL}"
+before_script:
+  - if [ -n "${USE_LIBCXX}" ]; then
+    bash .install-libcxx-travis.sh;
+    fi
+  - cd test
+  - ./download_catch.sh

From 2e80258e03014af64021d0a222eb6d68500a522e Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 27 Oct 2018 18:13:49 -0400
Subject: [PATCH 1754/1866] Conditional public data members for gcc bug

gcc bug preventing these friend declarations from working
https://gcc.gnu.org/bugzilla/show_bug.cgi?id=87651

I'd rather not have these be public on every branch, in case someone is
crazy enough to try to access `iters_` they'll hopefully at least get an
error using one of their compilers.

Fixes #48
---
 internal/iterbase.hpp | 23 ++++++++++++++++++-----
 product.hpp           |  9 +++++++--
 zip.hpp               |  8 +++++++-
 zip_longest.hpp       |  4 ++++
 4 files changed, 36 insertions(+), 8 deletions(-)

diff --git a/internal/iterbase.hpp b/internal/iterbase.hpp
index 6232c300..c857af52 100644
--- a/internal/iterbase.hpp
+++ b/internal/iterbase.hpp
@@ -15,6 +15,14 @@
 #include <type_traits>
 #include <utility>
 
+// see gcc bug 87651
+// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=87651
+#ifdef __GNUC__
+#define NO_GCC_FRIEND_ERROR __GNUC__ < 8
+#else
+#define NO_GCC_FRIEND_ERROR 1
+#endif
+
 namespace iter {
   namespace impl {
     namespace get_iters {
@@ -51,8 +59,13 @@ namespace iter {
     using AsConst = decltype(std::as_const(std::declval<T&>()));
 
     // iterator_type<C> is the type of C's iterator
-    template <typename T> //TODO: See bug https://developercommunity.visualstudio.com/content/problem/252157/sfinae-error-depends-on-name-of-template-parameter.html  for why we use T instead of Container.  Should be changed back to Container when that bug is fixed in MSVC.
-    using iterator_type = decltype(get_begin(std::declval<T&>()));
+    template <typename T>  // TODO: See bug
+                           // https://developercommunity.visualstudio.com/content/problem/252157/sfinae-error-depends-on-name-of-template-parameter.html
+                           // for why we use T instead of Container.  Should be
+                           // changed back to Container when that bug is fixed in
+                           // MSVC.
+                           using iterator_type =
+                               decltype(get_begin(std::declval<T&>()));
 
     // iterator_type<C> is the type of C's iterator
     template <typename Container>
@@ -152,9 +165,9 @@ namespace iter {
 
     template <typename T>
     struct is_random_access_iter<T,
-        std::enable_if_t<std::is_same<
-            typename std::iterator_traits<T>::iterator_category,
-            std::random_access_iterator_tag>::value>> : std::true_type {};
+        std::enable_if_t<
+            std::is_same<typename std::iterator_traits<T>::iterator_category,
+                std::random_access_iterator_tag>::value>> : std::true_type {};
 
     template <typename T>
     using has_random_access_iter = is_random_access_iter<iterator_type<T>>;
diff --git a/product.hpp b/product.hpp
index 38836fba..38c68243 100644
--- a/product.hpp
+++ b/product.hpp
@@ -80,9 +80,14 @@ class iter::impl::Productor {
   template <typename TupleTypeT, template <typename> class IteratorTuple,
       template <typename> class TupleDeref>
   class IteratorTempl {
+#if NO_GCC_FRIEND_ERROR
    private:
     template <typename, template <typename> class, template <typename> class>
     friend class IteratorTempl;
+#else
+   public:
+#endif
+
     using IterTupType = IteratorTuple<TupleTypeT>;
     IterTupType iters_;
     IterTupType begin_iters_;
@@ -126,7 +131,8 @@ class iter::impl::Productor {
     template <typename T, template <typename> class IT,
         template <typename> class TD>
     bool operator!=(const IteratorTempl<T, IT, TD>& other) const {
-      if constexpr (sizeof...(Is) == 0) return false;
+      if constexpr (sizeof...(Is) == 0)
+        return false;
       else
         return (... && (std::get<Is>(iters_) != std::get<Is>(other.iters_)));
     }
@@ -192,7 +198,6 @@ namespace iter {
   constexpr std::array<std::tuple<>, 1> product() {
     return {{}};
   }
-
 }
 
 namespace iter::impl {
diff --git a/zip.hpp b/zip.hpp
index ee973b9e..89e2e287 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -41,9 +41,14 @@ class iter::impl::Zipped {
   template <typename TupleTypeT, template <typename> class IteratorTuple,
       template <typename> class TupleDeref>
   class Iterator {
+    // see gcc bug 87651
+#if NO_GCC_FRIEND_ERROR
    private:
     template <typename, template <typename> class, template <typename> class>
     friend class Iterator;
+#else
+   public:
+#endif
     IteratorTuple<TupleTypeT> iters_;
 
    public:
@@ -69,7 +74,8 @@ class iter::impl::Zipped {
     template <typename T, template <typename> class IT,
         template <typename> class TD>
     bool operator!=(const Iterator<T, IT, TD>& other) const {
-      if constexpr (sizeof...(Is) == 0) return false;
+      if constexpr (sizeof...(Is) == 0)
+        return false;
       else
         return (... && (std::get<Is>(iters_) != std::get<Is>(other.iters_)));
     }
diff --git a/zip_longest.hpp b/zip_longest.hpp
index 89e637e3..238ec569 100644
--- a/zip_longest.hpp
+++ b/zip_longest.hpp
@@ -49,10 +49,14 @@ class iter::impl::ZippedLongest {
   template <typename TupleTypeT, template <typename> class IterTuple,
       template <std::size_t, typename> class OptTempl>
   class Iterator {
+#if NO_GCC_FRIEND_ERROR
    private:
     template <typename, template <typename> class,
         template <std::size_t, typename> class>
     friend class Iterator;
+#else
+   public:
+#endif
     IterTuple<TupleTypeT> iters_;
     IterTuple<TupleTypeT> ends_;
 

From b92529f8362903bcd3c349090b77e777f8e95913 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 27 Oct 2018 18:19:21 -0400
Subject: [PATCH 1755/1866] formatting from msvc fix merge

---
 internal/iterbase.hpp | 14 +++++++-------
 product.hpp           |  5 +++--
 zip.hpp               |  5 +++--
 3 files changed, 13 insertions(+), 11 deletions(-)

diff --git a/internal/iterbase.hpp b/internal/iterbase.hpp
index c857af52..e3d0d862 100644
--- a/internal/iterbase.hpp
+++ b/internal/iterbase.hpp
@@ -59,13 +59,13 @@ namespace iter {
     using AsConst = decltype(std::as_const(std::declval<T&>()));
 
     // iterator_type<C> is the type of C's iterator
-    template <typename T>  // TODO: See bug
-                           // https://developercommunity.visualstudio.com/content/problem/252157/sfinae-error-depends-on-name-of-template-parameter.html
-                           // for why we use T instead of Container.  Should be
-                           // changed back to Container when that bug is fixed in
-                           // MSVC.
-                           using iterator_type =
-                               decltype(get_begin(std::declval<T&>()));
+    // TODO: See bug
+    // https://developercommunity.visualstudio.com/content/problem/252157/sfinae-error-depends-on-name-of-template-parameter.html
+    // for why we use T instead of Container.  Should be
+    // changed back to Container when that bug is fixed in
+    // MSVC.
+    template <typename T>
+    using iterator_type = decltype(get_begin(std::declval<T&>()));
 
     // iterator_type<C> is the type of C's iterator
     template <typename Container>
diff --git a/product.hpp b/product.hpp
index 38c68243..d7bc61e9 100644
--- a/product.hpp
+++ b/product.hpp
@@ -131,10 +131,11 @@ class iter::impl::Productor {
     template <typename T, template <typename> class IT,
         template <typename> class TD>
     bool operator!=(const IteratorTempl<T, IT, TD>& other) const {
-      if constexpr (sizeof...(Is) == 0)
+      if constexpr (sizeof...(Is) == 0) {
         return false;
-      else
+      } else {
         return (... && (std::get<Is>(iters_) != std::get<Is>(other.iters_)));
+      }
     }
 
     template <typename T, template <typename> class IT,
diff --git a/zip.hpp b/zip.hpp
index 89e2e287..abadf45c 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -74,10 +74,11 @@ class iter::impl::Zipped {
     template <typename T, template <typename> class IT,
         template <typename> class TD>
     bool operator!=(const Iterator<T, IT, TD>& other) const {
-      if constexpr (sizeof...(Is) == 0)
+      if constexpr (sizeof...(Is) == 0) {
         return false;
-      else
+      } else {
         return (... && (std::get<Is>(iters_) != std::get<Is>(other.iters_)));
+      }
     }
 
     template <typename T, template <typename> class IT,

From 3f6ff3c56077efa805902b5d32b593409d79c8ff Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 27 Oct 2018 18:29:40 -0400
Subject: [PATCH 1756/1866] Adds travis build status

---
 README.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/README.md b/README.md
index 46ee3750..95f52602 100644
--- a/README.md
+++ b/README.md
@@ -1,3 +1,5 @@
+[![Build Status](https://travis-ci.com/ryanhaining/cppitertools.svg?branch=master)](https://travis-ci.com/ryanhaining/cppitertools)
+
 CPPItertools
 ============
 Range-based for loop add-ons inspired by the Python builtins and itertools

From eb07f97c1b8317510636c10b6e45c03a6b8bbaf8 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 28 Oct 2018 00:30:45 -0400
Subject: [PATCH 1757/1866] remove test_zip_longest.cpp from CMakeLists.txt

Just until I get boost worked out on appveyor
---
 test/CMakeLists.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 315e4b04..7d593210 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -22,6 +22,7 @@ endif()
 
 file(GLOB test_sources RELATIVE ${PROJECT_SOURCE_DIR} "test_*.cpp")
 list(REMOVE_ITEM test_sources test_main.cpp)
+list(REMOVE_ITEM test_sources test_zip_longest.cpp) # until I get boost figured out with appveyor
 add_library(test_main OBJECT test_main.cpp)
 
 foreach(_source_cpp ${test_sources})

From 94d2c4a81956c6f386a17381da0d760c367aaf16 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 28 Oct 2018 01:02:59 -0400
Subject: [PATCH 1758/1866] Adds boost check to CMakeLists.txt

---
 test/CMakeLists.txt | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 7d593210..e9140f47 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -9,10 +9,13 @@ cmake_minimum_required(VERSION 3.8)
 project(cppitertools_tests CXX)
 set (CMAKE_CXX_STANDARD 17)
 
+find_package(Boost 1.60.0 REQUIRED)
 include_directories(
 	..
+        ${Boost_INCLUDE_DIRS}
 )
 
+
 include(CheckIncludeFileCXX)
 set(CMAKE_REQUIRED_INCLUDES ${PROJECT_SOURCE_DIR})
 CHECK_INCLUDE_FILE_CXX(catch.hpp _has_catch)
@@ -22,7 +25,6 @@ endif()
 
 file(GLOB test_sources RELATIVE ${PROJECT_SOURCE_DIR} "test_*.cpp")
 list(REMOVE_ITEM test_sources test_main.cpp)
-list(REMOVE_ITEM test_sources test_zip_longest.cpp) # until I get boost figured out with appveyor
 add_library(test_main OBJECT test_main.cpp)
 
 foreach(_source_cpp ${test_sources})

From ede675ef161e0376dbe289f6a70c0ebde776efbb Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 28 Oct 2018 01:36:24 -0400
Subject: [PATCH 1759/1866] Updates catch version.

Was pretty out of date. yikes.
---
 test/download_catch.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/download_catch.sh b/test/download_catch.sh
index 2988d1b6..0cae9fd7 100755
--- a/test/download_catch.sh
+++ b/test/download_catch.sh
@@ -1,2 +1,2 @@
 #!/usr/bin/env sh
-wget -c https://github.com/catchorg/Catch2/releases/download/v2.0.1/catch.hpp
+wget -c https://github.com/catchorg/Catch2/releases/download/v2.4.2/catch.hpp

From 9bd671772e804c106b4522eae59a4347ffe0613b Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 28 Oct 2018 01:54:04 -0400
Subject: [PATCH 1760/1866] Adds appveyor status

---
 README.md | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 95f52602..e6744f18 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-[![Build Status](https://travis-ci.com/ryanhaining/cppitertools.svg?branch=master)](https://travis-ci.com/ryanhaining/cppitertools)
+
 
 CPPItertools
 ============
@@ -10,6 +10,12 @@ evaluation wherever possible.
 
 Follow [@cppitertools](https://twitter.com/cppitertools) for updates.
 
+#### Build and Test Status
+Status | Compilers
+---- | ---- 
+[![Travis Build Status](https://travis-ci.com/ryanhaining/cppitertools.svg?branch=master)](https://travis-ci.com/ryanhaining/cppitertools) | gcc-7  gcc-8 clang-5.0 clang-6.0
+[![Appveyor Build Status](https://ci.appveyor.com/api/projects/status/github/ryanhaining/cppitertools?svg=true)](https://ci.appveyor.com/project/ryanhaining/cppitertools) | MSVC 2017
+
 #### Table of Contents
 [range](#range)<br />
 [enumerate](#enumerate)<br />

From 55fb813a88b9fa2ef083f09cc927e9ead056d14e Mon Sep 17 00:00:00 2001
From: Tony RIVIERE <tony.riviere@hexagon.com>
Date: Sat, 22 Dec 2018 02:20:22 +0100
Subject: [PATCH 1761/1866] fix chain.from_iterable() when subiterables are
 empty

---
 chain.hpp                     | 14 +++++++++++++-
 internal/iterator_wrapper.hpp |  4 ++++
 test/test_chain.cpp           | 10 ++++++++++
 3 files changed, 27 insertions(+), 1 deletion(-)

diff --git a/chain.hpp b/chain.hpp
index 8a0522e3..d289a6a3 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -204,7 +204,14 @@ class iter::impl::ChainedFromIterable {
     std::optional<SubIter> sub_iter_p_;
     std::optional<SubIter> sub_end_p_;
 
-    void next_sub_iterable() {
+    void advance_while_empty_sub_iterable() {
+      while (top_level_iter_ != top_level_end_ && sub_iter_p_ == sub_end_p_) {
+        ++top_level_iter_;
+        update_sub_iterable();
+      }
+    }
+
+    void update_sub_iterable() {
       if (top_level_iter_ != top_level_end_) {
         sub_iterable_.reset(*top_level_iter_);
         sub_iter_p_ =
@@ -216,6 +223,11 @@ class iter::impl::ChainedFromIterable {
       }
     }
 
+    void next_sub_iterable() {
+      update_sub_iterable();
+      advance_while_empty_sub_iterable();
+    }
+
    public:
     using iterator_category = std::input_iterator_tag;
     using value_type = iterator_traits_deref<iterator_deref<ContainerT>>;
diff --git a/internal/iterator_wrapper.hpp b/internal/iterator_wrapper.hpp
index 2d91fc02..f068da97 100644
--- a/internal/iterator_wrapper.hpp
+++ b/internal/iterator_wrapper.hpp
@@ -94,6 +94,10 @@ class iter::impl::IteratorWrapperImpl {
     } not_equal;
     return std::visit(not_equal, sub_iter_or_end_, other.sub_iter_or_end_);
   }
+
+  bool operator==(const IteratorWrapperImpl& other) const {
+    return !(*this != other);
+  }
 };
 
 #endif
diff --git a/test/test_chain.cpp b/test/test_chain.cpp
index 32b9f184..6caabe3f 100644
--- a/test/test_chain.cpp
+++ b/test/test_chain.cpp
@@ -233,6 +233,16 @@ TEST_CASE("chain.fromm_iterable: Works with different begin and end types",
   REQUIRE(v == vc);
 }
 
+TEST_CASE("chain.from_iterable: Works with empty subiterable",
+    "[chain.from_iterable]") {
+  std::vector<std::vector<int>> ivv{
+      {}, {2, 4, 6}, {}, {8, 10, 12}, {14, 16, 18}, {}};
+  auto ch = chain.from_iterable(ivv);
+  const std::vector<int> v(std::begin(ch), std::end(ch));
+  const std::vector<int> vi = {2, 4, 6, 8, 10, 12, 14, 16, 18};
+  REQUIRE(v == vi);
+}
+
 TEST_CASE(
     "chain.from_iterable: iterators cant be copy constructed "
     "and assigned",

From af1e317864baeb7dee913b7219ffe4382ed885c7 Mon Sep 17 00:00:00 2001
From: Tony RIVIERE <tony.riviere@hexagon.com>
Date: Sat, 22 Dec 2018 02:52:49 +0100
Subject: [PATCH 1762/1866] Modify get_begin() get_end() to use either member
 functions if exist or use ADL in order to solve issues when ADL fails.

---
 internal/iterbase.hpp  | 57 ++++++++++++++++++++++++++++++------------
 test/test_iterbase.cpp | 28 +++++++++++++++++++++
 2 files changed, 69 insertions(+), 16 deletions(-)

diff --git a/internal/iterbase.hpp b/internal/iterbase.hpp
index e3d0d862..7b460bf5 100644
--- a/internal/iterbase.hpp
+++ b/internal/iterbase.hpp
@@ -26,25 +26,50 @@
 namespace iter {
   namespace impl {
     namespace get_iters {
-      // This has to be set up in a really weird way.
-      // This looks at first as if it could be
-      // decltype(auto) get_begin(T& t) {
-      //     using std::begin;
-      //     return begin(t);
-      // }
-      // However, without return types in the declaration, SFINAE gets
-      // messed up everywhere.
-      using std::begin;
-      // TODO add constexpr for c++17
+      // begin() for C arrays
+      template <typename T, std::size_t N>
+      T* get_begin_impl(T (&array)[N], int) {
+        return array;
+      }
+
+      // Prefer member begin().
+      template <typename T, typename I = decltype(std::declval<T&>().begin())>
+      I get_begin_impl(T& r, int) {
+        return r.begin();
+      }
+
+      // Use ADL otherwises.
+      template <typename T, typename I = decltype(begin(std::declval<T&>()))>
+      I get_begin_impl(T& r, long) {
+        return begin(r);
+      }
+
       template <typename T>
-      auto get_begin(T& t) -> decltype(begin(t)) {
-        return begin(t);
+      auto get_begin(T& t) -> decltype(get_begin_impl(std::declval<T&>(), 42)) {
+        return get_begin_impl(t, 42);
       }
-      using std::end;
-      // TODO add constexpr for c++17
+
+      // end() for C arrays
+      template <typename T, std::size_t N>
+      T* get_end_impl(T (&array)[N], int) {
+        return array + N;
+      }
+
+      // Prefer member end().
+      template <typename T, typename I = decltype(std::declval<T&>().end())>
+      I get_end_impl(T& r, int) {
+        return r.end();
+      }
+
+      // Use ADL otherwise.
+      template <typename T, typename I = decltype(end(std::declval<T&>()))>
+      I get_end_impl(T& r, long) {
+        return end(r);
+      }
+
       template <typename T>
-      auto get_end(T& t) -> decltype(end(t)) {
-        return end(t);
+      auto get_end(T& t) -> decltype(get_end_impl(std::declval<T&>(), 42)) {
+        return get_end_impl(t, 42);
       }
     }
     using get_iters::get_begin;
diff --git a/test/test_iterbase.cpp b/test/test_iterbase.cpp
index fecfb9a4..d27c4f7f 100644
--- a/test/test_iterbase.cpp
+++ b/test/test_iterbase.cpp
@@ -94,3 +94,31 @@ TEST_CASE("get_begin returns correct type", "[iterbase]") {
   std::vector<int> v;
   REQUIRE((std::is_same<decltype(it::get_begin(v)), decltype(v.begin())>{}));
 }
+
+namespace NS1 {
+
+  struct Dummy {
+    auto begin() {
+      return 0;
+    }
+    auto end() {
+      return 0;
+    }
+  };
+
+  template <typename T>
+  auto begin(T& t) {
+    return t.begin();
+  }
+
+  template <typename T>
+  auto end(T& t) {
+    return t.end();
+  }
+
+}  // namespace NS1
+
+TEST_CASE("Detects is_iterable with ADL conflicts", "[iterbase]") {
+  REQUIRE(iter::impl::is_iterable<NS1::Dummy>);
+  REQUIRE(iter::impl::is_iterable<std::vector<NS1::Dummy>>);
+}
\ No newline at end of file

From bcf48559b7fc762d87836212cb7b9cd44046c411 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 21 Dec 2018 22:35:42 -0500
Subject: [PATCH 1763/1866] Tests that arrays are iterable

---
 test/test_iterbase.cpp | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/test/test_iterbase.cpp b/test/test_iterbase.cpp
index d27c4f7f..89c7fef9 100644
--- a/test/test_iterbase.cpp
+++ b/test/test_iterbase.cpp
@@ -119,6 +119,10 @@ namespace NS1 {
 }  // namespace NS1
 
 TEST_CASE("Detects is_iterable with ADL conflicts", "[iterbase]") {
+  int a[1]{};
+  const int b[1]{};
   REQUIRE(iter::impl::is_iterable<NS1::Dummy>);
   REQUIRE(iter::impl::is_iterable<std::vector<NS1::Dummy>>);
-}
\ No newline at end of file
+  REQUIRE(iter::impl::is_iterable<decltype(a)>);
+  REQUIRE(iter::impl::is_iterable<decltype(b)>);
+}

From 520df7af0e509bec29fe73e31034b94ce57e50f1 Mon Sep 17 00:00:00 2001
From: Misha Brukman <mbrukman@google.com>
Date: Sat, 5 Jan 2019 23:42:20 -0500
Subject: [PATCH 1764/1866] Fixed typos, capitalizations, and added commas.

---
 README.md | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/README.md b/README.md
index e6744f18..d53c8da9 100644
--- a/README.md
+++ b/README.md
@@ -6,7 +6,7 @@ Range-based for loop add-ons inspired by the Python builtins and itertools
 library.  Like itertools and the Python3 builtins, this library uses lazy
 evaluation wherever possible.
 
-*Note*: Everthing is inside the `iter` namespace.
+*Note*: Everything is inside the `iter` namespace.
 
 Follow [@cppitertools](https://twitter.com/cppitertools) for updates.
 
@@ -95,7 +95,7 @@ underlying iterables, but if anything noteworthy is needed it is described
 in this document.
 
 #### Guarantees of implementations
-By implementations I mean the objects returned by the API's functions. All of
+By implementations, I mean the objects returned by the API's functions. All of
 the implementation classes are move-constructible, not copy-constructible,
 not assignable. All iterators that work over another iterable are tagged
 as InputIterators and behave as such.
@@ -104,11 +104,11 @@ as InputIterators and behave as such.
 If you find anything not working as you expect, not compiling when you believe
 it should, a divergence from the python itertools behavior, or any sort of
 error, please let me know. The preferable means would be to open an issue on
-github. If you want to talk about an issue that you don't feel would be
-appropriate as a github issue (or you just don't want to open one),
-You can email me directly with whatever code you have that describes the
-problem, I've been pretty responsive in the past. If I believe you are
-"misusing" the library I'll try to put the blame on myself for being unclear
+GitHub. If you want to talk about an issue that you don't feel would be
+appropriate as a GitHub issue (or you just don't want to open one),
+you can email me directly with whatever code you have that describes the
+problem; I've been pretty responsive in the past. If I believe you are
+"misusing" the library, I'll try to put the blame on myself for being unclear
 in this document and take the steps to clarify it.  So please, contact me with
 any concerns, I'm open to feedback.
 
@@ -150,8 +150,8 @@ result, itertools can be mixed and nested.
 
 
 #### Pipe syntax
-Wherever it makes sense I've implemented the "pipe" operator that has become
-common in similar libraries. When the syntax is available it is done by pulling
+Wherever it makes sense, I've implemented the "pipe" operator that has become
+common in similar libraries. When the syntax is available, it is done by pulling
 out the iterable from the call and placing it before the tool. For example:
 
 ```c++
@@ -411,7 +411,7 @@ step of 1.<br />
 `count(i, st)` will start counting from `i` with a step of `st`.
 
 *Technical limitations*: Unlike Python which can use its long integer
-types when needed, count() would eventually exceed the
+types when needed, `count()` would eventually exceed the
 maximum possible value for its type (or minimum with a negative step).
 `count` is actually implemented as a `range` with the stopping point
 being the `std::numeric_limits<T>::max()` for the integral type (`long`
@@ -749,7 +749,7 @@ chunked
 
 chunked will yield subsequent chunkes of an iterable in blocks of a specified
 size. The final chunk may be shorter than the rest if the chunk size given
-does not evenly divide the length of the iterable
+does not evenly divide the length of the iterable.
 
 Example usage:
 ```c++

From 44207cdd947dc765d29951384823ac4fbafb29ed Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sat, 9 Mar 2019 13:17:59 -0500
Subject: [PATCH 1765/1866] Puts main.cpp in own bazel cc_library

Fixes #53
---
 test/BUILD          | 6 ++++++
 test/make_tests.bzl | 9 ++++++---
 2 files changed, 12 insertions(+), 3 deletions(-)

diff --git a/test/BUILD b/test/BUILD
index 5c7c5d9c..b7bdc149 100644
--- a/test/BUILD
+++ b/test/BUILD
@@ -36,4 +36,10 @@ progs = [
     "helpers",
 ]
 
+cc_library(
+  name = "test_main",
+  srcs = ["test_main.cpp", "catch.hpp"],
+  copts = ["-std=c++17", "-g"]
+)
+
 itertools_tests(progs)
diff --git a/test/make_tests.bzl b/test/make_tests.bzl
index 883f0576..68a428b8 100644
--- a/test/make_tests.bzl
+++ b/test/make_tests.bzl
@@ -2,7 +2,10 @@ def itertools_tests(progs):
   for p in progs:
     native.cc_test(
         name = "test_{}".format(p),
-        srcs = ["test_{}.cpp".format(p), "test_main.cpp", "catch.hpp", "helpers.hpp"],
-        deps = ["//:cppitertools",],
-        copts = ["-I.",  "-std=c++17", "-Wall", "-Wextra", "-pedantic", "-g"],
+        srcs = ["test_{}.cpp".format(p), "catch.hpp", "helpers.hpp"],
+        deps = [
+            "//:cppitertools",
+            ":test_main",
+            ],
+        copts = ["-I.", "-std=c++17", "-Wall", "-Wextra", "-pedantic", "-g"],
     )

From b7a3c38a388da3f24714c73dd7d34c823d80043d Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 22 Mar 2019 18:10:24 -0400
Subject: [PATCH 1766/1866] Adds range .start() .step() and .stop()

First part of #55
---
 range.hpp           | 22 +++++++++++++------
 test/test_range.cpp | 52 +++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 68 insertions(+), 6 deletions(-)

diff --git a/range.hpp b/range.hpp
index d4727b4b..c30f35f0 100644
--- a/range.hpp
+++ b/range.hpp
@@ -124,6 +124,18 @@ class iter::impl::Range {
       : start_{start}, stop_{stop}, step_{step} {}
 
  public:
+  constexpr T start() const noexcept {
+    return start_;
+  }
+
+  constexpr T stop() const noexcept {
+    return stop_;
+  }
+
+  constexpr T step() const noexcept {
+    return step_;
+  }
+
   // the reference type here is T, which doesn't strictly follow all
   // of the rules, but std::vector<bool>::iterator::reference isn't
   // a reference type either, this isn't any worse
@@ -139,11 +151,9 @@ class iter::impl::Range {
         const Iterator& lhs, const Iterator& rhs) noexcept {
       assert(!lhs.is_end);
       assert(rhs.is_end);
-      if
-        constexpr(std::is_unsigned<T>{}) {
-          return lhs.data.value() < rhs.data.value();
-        }
-      else {
+      if constexpr (std::is_unsigned<T>{}) {
+        return lhs.data.value() < rhs.data.value();
+      } else {
         return !(lhs.data.step() > 0 && lhs.data.value() >= rhs.data.value())
                && !(lhs.data.step() < 0
                       && lhs.data.value() <= rhs.data.value());
@@ -183,7 +193,7 @@ class iter::impl::Range {
       return *this;
     }
 
-    Iterator operator++(int)noexcept {
+    Iterator operator++(int) noexcept {
       auto ret = *this;
       ++*this;
       return ret;
diff --git a/test/test_range.cpp b/test/test_range.cpp
index dab748e3..23833e03 100644
--- a/test/test_range.cpp
+++ b/test/test_range.cpp
@@ -10,6 +10,58 @@
 using Vec = const std::vector<int>;
 using iter::range;
 
+TEST_CASE("range: .start(), .stop(), and .step()", "[range]") {
+  SECTION("one arg") {
+    auto r = range(3);
+    REQUIRE(r.start() == 0);
+    REQUIRE(r.stop() == 3);
+    REQUIRE(r.step() == 1);
+
+    // make sure iterators aren't changing the value
+    auto it = r.begin();
+    ++it;
+
+    REQUIRE(r.start() == 0);
+    REQUIRE(r.stop() == 3);
+    REQUIRE(r.step() == 1);
+  }
+
+  SECTION("two args") {
+    auto r = range(2, 10);
+    REQUIRE(r.start() == 2);
+    REQUIRE(r.stop() == 10);
+    REQUIRE(r.step() == 1);
+  }
+
+  SECTION("three args") {
+    auto r = range(-6, 20, 3);
+    REQUIRE(r.start() == -6);
+    REQUIRE(r.stop() == 20);
+    REQUIRE(r.step() == 3);
+  }
+
+  SECTION("one arg (double)") {
+    auto r = range(3.5);
+    REQUIRE(r.start() == 0);
+    REQUIRE(r.stop() == Approx(3.5));
+    REQUIRE(r.step() == Approx(1.0));
+  }
+
+  SECTION("two args (double)") {
+    auto r = range(20.1, 31.7);
+    REQUIRE(r.start() == Approx(20.1));
+    REQUIRE(r.stop() == Approx(31.7));
+    REQUIRE(r.step() == Approx(1.0));
+  }
+
+  SECTION("three args (double)") {
+    auto r = range(-6.3, 5.7, 0.1);
+    REQUIRE(r.start() == Approx(-6.3));
+    REQUIRE(r.stop() == Approx(5.7));
+    REQUIRE(r.step() == Approx(0.1));
+  }
+}
+
 TEST_CASE("range: works with only stop", "[range]") {
   auto r = range(5);
   Vec v(std::begin(r), std::end(r));

From 449d9de526f8b953e2ec307946a43f5f5a2e09cd Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 14 Apr 2019 01:32:46 -0400
Subject: [PATCH 1767/1866] Updates catch version to 2.6.0

---
 test/download_catch.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/download_catch.sh b/test/download_catch.sh
index 0cae9fd7..487e1233 100755
--- a/test/download_catch.sh
+++ b/test/download_catch.sh
@@ -1,2 +1,2 @@
 #!/usr/bin/env sh
-wget -c https://github.com/catchorg/Catch2/releases/download/v2.4.2/catch.hpp
+wget -c https://github.com/catchorg/Catch2/releases/download/v2.6.0/catch.hpp

From a24fcdcf40dd76ce5b46cde363be8c3231e7b940 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 14 Apr 2019 01:34:37 -0400
Subject: [PATCH 1768/1866] Adds .size() to range

Second Part of #55. Not supporting floating point types. I can't yet
get the float version perfect.
---
 range.hpp           | 37 ++++++++++++++++++++++++++++++-------
 test/test_range.cpp | 39 +++++++++++++++++++++++++++++++++++++++
 2 files changed, 69 insertions(+), 7 deletions(-)

diff --git a/range.hpp b/range.hpp
index c30f35f0..fb222c7c 100644
--- a/range.hpp
+++ b/range.hpp
@@ -123,6 +123,17 @@ class iter::impl::Range {
   constexpr Range(T start, T stop, T step = 1) noexcept
       : start_{start}, stop_{stop}, step_{step} {}
 
+  // if val is "before" the stopping point.
+  static constexpr bool is_within_range(
+      T val, T stop_val, [[maybe_unused]] T step_val) {
+    if constexpr (std::is_unsigned<T>{}) {
+      return val < stop_val;
+    } else {
+      return !(step_val > 0 && val >= stop_val)
+             && !(step_val < 0 && val <= stop_val);
+    }
+  }
+
  public:
   constexpr T start() const noexcept {
     return start_;
@@ -136,6 +147,23 @@ class iter::impl::Range {
     return step_;
   }
 
+  constexpr std::size_t size() const noexcept {
+    static_assert(!std::is_floating_point_v<T>,
+        "range size() not supperted with floating point types");
+    if (!is_within_range(start(), stop(), step())) {
+      return 0;
+    }
+
+    auto diff = stop() - start();
+    auto res = diff / step();
+    assert(res >= 0);
+    auto result = static_cast<std::size_t>(res);
+    if (diff % step()) {
+      ++result;
+    }
+    return result;
+  }
+
   // the reference type here is T, which doesn't strictly follow all
   // of the rules, but std::vector<bool>::iterator::reference isn't
   // a reference type either, this isn't any worse
@@ -151,13 +179,8 @@ class iter::impl::Range {
         const Iterator& lhs, const Iterator& rhs) noexcept {
       assert(!lhs.is_end);
       assert(rhs.is_end);
-      if constexpr (std::is_unsigned<T>{}) {
-        return lhs.data.value() < rhs.data.value();
-      } else {
-        return !(lhs.data.step() > 0 && lhs.data.value() >= rhs.data.value())
-               && !(lhs.data.step() < 0
-                      && lhs.data.value() <= rhs.data.value());
-      }
+      return is_within_range(
+          lhs.data.value(), rhs.data.value(), lhs.data.step());
     }
 
     static bool not_equal_to_end(
diff --git a/test/test_range.cpp b/test/test_range.cpp
index 23833e03..7bfa85ac 100644
--- a/test/test_range.cpp
+++ b/test/test_range.cpp
@@ -312,3 +312,42 @@ TEST_CASE("range: iterator meets forward iterator requirements", "[range]") {
   REQUIRE(itertest::IsForwardIterator<decltype(std::begin(r))>::value);
   REQUIRE(itertest::IsForwardIterator<decltype(std::begin(r2))>::value);
 }
+
+TEMPLATE_TEST_CASE("range: .size() with signed integrals", "[range]",
+    signed char, short, int, long, long long) {
+  constexpr TestType N = 5;
+  constexpr TestType INC = 1;
+  for (TestType start = -N; start < N; start += INC) {
+    for (TestType stop = -N; stop < N; stop += INC) {
+      for (TestType step = -N; step < N; step += INC) {
+        if (step == 0) {
+          continue;
+        }
+        auto r = range(start, stop, step);
+        REQUIRE(r.size()
+                == static_cast<std::size_t>(
+                       std::distance(std::begin(r), std::end(r))));
+      }
+    }
+  }
+}
+
+TEMPLATE_TEST_CASE("range: .size() with unsigned integrals", "[range]",
+    unsigned char, unsigned short, unsigned int, unsigned long,
+    unsigned long long) {
+  constexpr TestType N = 5;
+  constexpr TestType INC = 1;
+  for (TestType start = 0; start < N; start += INC) {
+    for (TestType stop = 0; stop < N; stop += INC) {
+      for (TestType step = 0; step < N; step += INC) {
+        if (step == 0) {
+          continue;
+        }
+        auto r = range(start, stop, step);
+        REQUIRE(r.size()
+                == static_cast<std::size_t>(
+                       std::distance(std::begin(r), std::end(r))));
+      }
+    }
+  }
+}

From 0e1765270dbb7254416e251f8764c2895977e236 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 14 Apr 2019 01:49:25 -0400
Subject: [PATCH 1769/1866] Adds range operator[]

To the range object, not to the iterator.
---
 range.hpp           |  4 ++++
 test/test_range.cpp | 32 ++++++++++++++++++++++++++++++++
 2 files changed, 36 insertions(+)

diff --git a/range.hpp b/range.hpp
index fb222c7c..2efa7396 100644
--- a/range.hpp
+++ b/range.hpp
@@ -147,6 +147,10 @@ class iter::impl::Range {
     return step_;
   }
 
+  constexpr T operator[](std::size_t index) const noexcept {
+    return start() + (step() * index);
+  }
+
   constexpr std::size_t size() const noexcept {
     static_assert(!std::is_floating_point_v<T>,
         "range size() not supperted with floating point types");
diff --git a/test/test_range.cpp b/test/test_range.cpp
index 7bfa85ac..4a25211a 100644
--- a/test/test_range.cpp
+++ b/test/test_range.cpp
@@ -313,6 +313,38 @@ TEST_CASE("range: iterator meets forward iterator requirements", "[range]") {
   REQUIRE(itertest::IsForwardIterator<decltype(std::begin(r2))>::value);
 }
 
+TEST_CASE("range: operator[] simple tests", "[range]") {
+  SECTION("range(start)") {
+    auto r = range(4);
+    REQUIRE(r[0] == 0);
+    REQUIRE(r[1] == 1);
+    REQUIRE(r[2] == 2);
+    REQUIRE(r[3] == 3);
+  }
+  SECTION("range(start, stop)") {
+    auto r = range(10, 14);
+    REQUIRE(r[0] == 10);
+    REQUIRE(r[1] == 11);
+    REQUIRE(r[2] == 12);
+    REQUIRE(r[3] == 13);
+  }
+  SECTION("range(start, stop, step)") {
+    auto r = range(20, 30, 3);
+    REQUIRE(r[0] == 20);
+    REQUIRE(r[1] == 23);
+    REQUIRE(r[2] == 26);
+    REQUIRE(r[3] == 29);
+  }
+  SECTION("range(start, stop, step) with double") {
+    auto r = range(50.0, 50.99, 0.2);
+    REQUIRE(r[0] == Approx(50.0));
+    REQUIRE(r[1] == Approx(50.2));
+    REQUIRE(r[2] == Approx(50.4));
+    REQUIRE(r[3] == Approx(50.6));
+    REQUIRE(r[4] == Approx(50.8));
+  }
+}
+
 TEMPLATE_TEST_CASE("range: .size() with signed integrals", "[range]",
     signed char, short, int, long, long long) {
   constexpr TestType N = 5;

From 97bfd33cdc268426b20f189c13d3ed88f5e1f4c2 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 14 Apr 2019 02:08:41 -0400
Subject: [PATCH 1770/1866] Adds range updates to README

---
 README.md | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/README.md b/README.md
index d53c8da9..1c85fd38 100644
--- a/README.md
+++ b/README.md
@@ -250,6 +250,12 @@ recomputed at each step to avoid accumulating floating point inaccuracies
 (`value = start + (step * steps_taken`). The result of the latter is a bit
 slower but more accurate.
 
+`range` also supports the following operations:
+  - `.size()` to get the number of elements in the range (not enabled for 
+  floating point ranges). 
+  - Accessors for `.start()`, `.stop()`, and `.step()`.
+  - Indexing. Given a range `r`, `r[n]` is the `n`th element in the range.
+  
 enumerate
 ---------
 

From f6573bd394a24c5febf2943453d354d2adacaad8 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 7 Jun 2019 00:00:34 -0400
Subject: [PATCH 1771/1866] Small fix and cleanup to DerefHolder

get_ptr() wasn't valid for DerefHolder with values
---
 internal/iterbase.hpp  | 29 +++++++++++++++++++----------
 test/test_iterbase.cpp |  3 +++
 2 files changed, 22 insertions(+), 10 deletions(-)

diff --git a/internal/iterbase.hpp b/internal/iterbase.hpp
index 7b460bf5..df1df2ba 100644
--- a/internal/iterbase.hpp
+++ b/internal/iterbase.hpp
@@ -7,6 +7,7 @@
 // also applies to the name of the file.  No user code should include
 // this file directly.
 
+#include <cassert>
 #include <cstddef>
 #include <functional>
 #include <iterator>
@@ -276,28 +277,32 @@ namespace iter {
       // it could still be an rvalue reference
       using TPlain = std::remove_reference_t<T>;
 
-      std::optional<TPlain> item_p;
+      std::optional<TPlain> item_p_;
 
      public:
       using reference = TPlain&;
       using pointer = TPlain*;
 
+      static constexpr bool stores_value = true;
+
       DerefHolder() = default;
 
       reference get() {
-        return *this->item_p;
+        assert(item_p_.has_value());
+        return *item_p_;
       }
 
       pointer get_ptr() {
-        return this->item_p.get();
+        assert(item_p_.has_value());
+        return &item_p_.value();
       }
 
       void reset(T&& item) {
-        item_p = std::move(item);
+        item_p_ = std::move(item);
       }
 
       explicit operator bool() const {
-        return static_cast<bool>(this->item_p);
+        return static_cast<bool>(item_p_);
       }
     };
 
@@ -309,25 +314,29 @@ namespace iter {
       using pointer = T*;
 
      private:
-      pointer item_p{};
+      pointer item_p_{};
 
      public:
+      static constexpr bool stores_value = false;
+
       DerefHolder() = default;
 
       reference get() {
-        return *this->item_p;
+        assert(item_p_);
+        return *item_p_;
       }
 
       pointer get_ptr() {
-        return this->item_p;
+        assert(item_p_);
+        return item_p_;
       }
 
       void reset(reference item) {
-        this->item_p = &item;
+        item_p_ = &item;
       }
 
       explicit operator bool() const {
-        return this->item_p != nullptr;
+        return item_p_ != nullptr;
       }
     };
 
diff --git a/test/test_iterbase.cpp b/test/test_iterbase.cpp
index 89c7fef9..c8783f32 100644
--- a/test/test_iterbase.cpp
+++ b/test/test_iterbase.cpp
@@ -63,6 +63,7 @@ TEST_CASE("are_same", "[iterbase]") {
 }
 
 TEST_CASE("DerefHolder lvalue reference", "[iterbase]") {
+  REQUIRE_FALSE(it::DerefHolder<int&>::stores_value);
   it::DerefHolder<int&> dh;
   int a = 2;
   int b = 5;
@@ -78,6 +79,7 @@ TEST_CASE("DerefHolder lvalue reference", "[iterbase]") {
 }
 
 TEST_CASE("DerefHolder non-reference", "[iterbase]") {
+  REQUIRE(it::DerefHolder<int>::stores_value);
   it::DerefHolder<int> dh;
   int a = 2;
   int b = 5;
@@ -85,6 +87,7 @@ TEST_CASE("DerefHolder non-reference", "[iterbase]") {
   dh.reset(std::move(a));
   REQUIRE(dh.get() == 2);
   REQUIRE(&dh.get() != &a);
+  REQUIRE(dh.get_ptr() != &a);
 
   dh.reset(std::move(b));
   REQUIRE(dh.get() == 5);

From b42772dc0e35bece4eee7b30870f78013fab5703 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 7 Jun 2019 00:14:57 -0400
Subject: [PATCH 1772/1866] Uses shared_ptr for vector in chunked()

Addresses part of #57
---
 chunked.hpp         | 16 +++++++++-------
 test/test_mixed.cpp | 33 +++++++++++++++++++++++++++++----
 2 files changed, 38 insertions(+), 11 deletions(-)

diff --git a/chunked.hpp b/chunked.hpp
index 87f0a0de..1d03b6e1 100644
--- a/chunked.hpp
+++ b/chunked.hpp
@@ -8,6 +8,7 @@
 #include <algorithm>
 #include <functional>
 #include <iterator>
+#include <memory>
 #include <type_traits>
 #include <utility>
 #include <vector>
@@ -45,20 +46,21 @@ class iter::impl::Chunker {
    private:
     template <typename>
     friend class Iterator;
+    std::shared_ptr<DerefVec<ContainerT>> chunk_ =
+        std::make_shared<DerefVec<ContainerT>>();
     IteratorWrapper<ContainerT> sub_iter_;
     IteratorWrapper<ContainerT> sub_end_;
-    DerefVec<ContainerT> chunk_;
     std::size_t chunk_size_ = 0;
 
     bool done() const {
-      return chunk_.empty();
+      return chunk_->empty();
     }
 
     void refill_chunk() {
-      chunk_.get().clear();
+      chunk_->get().clear();
       std::size_t i{0};
       while (i < chunk_size_ && sub_iter_ != sub_end_) {
-        chunk_.get().push_back(sub_iter_);
+        chunk_->get().push_back(sub_iter_);
         ++sub_iter_;
         ++i;
       }
@@ -76,7 +78,7 @@ class iter::impl::Chunker {
         : sub_iter_{std::move(sub_iter)},
           sub_end_{std::move(sub_end)},
           chunk_size_{s} {
-      chunk_.get().reserve(chunk_size_);
+      chunk_->get().reserve(chunk_size_);
       refill_chunk();
     }
 
@@ -103,11 +105,11 @@ class iter::impl::Chunker {
     }
 
     DerefVec<ContainerT>& operator*() {
-      return chunk_;
+      return *chunk_;
     }
 
     DerefVec<ContainerT>* operator->() {
-      return &chunk_;
+      return chunk_.get();
     }
   };
 
diff --git a/test/test_mixed.cpp b/test/test_mixed.cpp
index 46d47f03..4f5acc02 100644
--- a/test/test_mixed.cpp
+++ b/test/test_mixed.cpp
@@ -75,8 +75,8 @@ TEST_CASE("filtering doesn't dereference multiple times", "[imap][filter]") {
 }
 
 TEST_CASE("dropwhile doesn't dereference multiple times", "[imap][dropwhile]") {
-  using iter::imap;
   using iter::dropwhile;
+  using iter::imap;
 
   std::array<MyUnMovable, 3> arr = {{{41}, {42}, {43}}};
 
@@ -128,9 +128,9 @@ TEST_CASE("sorted(chain.from_iterable)", "[sorted][chain.from_iterable]") {
 }
 
 TEST_CASE("filter into enumerate with pipe", "[filter][enumerate]") {
-  using iter::imap;
-  using iter::filter;
   using iter::enumerate;
+  using iter::filter;
+  using iter::imap;
 
   std::array<MyUnMovable, 4> arr = {{{41}, {42}, {43}, {44}}};
   auto seq =
@@ -144,8 +144,33 @@ TEST_CASE("filter into enumerate with pipe", "[filter][enumerate]") {
   REQUIRE(v == vc);
 }
 
+TEST_CASE("enumerate(filter(chunked()))", "[filter][enumerate][chunked]") {
+  using iter::chunked;
+  using iter::enumerate;
+  using iter::filter;
+  std::vector<int16_t> v(500);
+  auto chunks = chunked(v, 100);
+  auto filtered = filter([](auto&) { return true; }, chunks);
+  for (auto&& [i, chunk] : enumerate(filtered)) {
+    (void)i;
+    REQUIRE(chunk.size() == 100);
+  }
+}
+
+TEST_CASE("zip(filter(chunked()))", "[filter][chunked][zip]") {
+  using iter::chunked;
+  using iter::filter;
+  using iter::zip;
+  std::vector<int16_t> v(500);
+  auto chunks = chunked(v, 100);
+  auto filtered = filter([](auto&) { return true; }, chunks);
+  for (auto&& [chunk] : zip(filtered)) {
+    REQUIRE(chunk.size() == 100);
+  }
+}
+
 TEST_CASE("chain.from_iterable: accept imap result that yields rvalues",
-          "[chain.from_iterable][imap]") {
+    "[chain.from_iterable][imap]") {
   using iter::chain;
   using iter::imap;
   const std::vector<std::vector<char>> ns = {{'a'}, {'q'}, {'x', 'z'}};

From 512dbd975af2517f894d11c2b728e3669ad5d5a8 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 7 Jun 2019 00:36:00 -0400
Subject: [PATCH 1773/1866] Uses shared_ptr of vector in sliding_window

Addresses part of #57
---
 sliding_window.hpp  | 14 ++++++++------
 test/test_mixed.cpp | 12 ++++++++++++
 2 files changed, 20 insertions(+), 6 deletions(-)

diff --git a/sliding_window.hpp b/sliding_window.hpp
index fcb41e00..d4ab6cbc 100644
--- a/sliding_window.hpp
+++ b/sliding_window.hpp
@@ -7,6 +7,7 @@
 
 #include <deque>
 #include <iterator>
+#include <memory>
 #include <utility>
 
 namespace iter {
@@ -41,8 +42,9 @@ class iter::impl::WindowSlider {
    private:
     template <typename>
     friend class Iterator;
+    std::shared_ptr<DerefVec<ContainerT>> window_ =
+        std::make_shared<DerefVec<ContainerT>>();
     IteratorWrapper<ContainerT> sub_iter_;
-    DerefVec<ContainerT> window_;
 
    public:
     using iterator_category = std::input_iterator_tag;
@@ -56,7 +58,7 @@ class iter::impl::WindowSlider {
         : sub_iter_(std::move(sub_iter)) {
       std::size_t i{0};
       while (i < window_sz && sub_iter_ != sub_end) {
-        window_.get().push_back(sub_iter_);
+        window_->get().push_back(sub_iter_);
         ++i;
         if (i != window_sz) {
           ++sub_iter_;
@@ -75,17 +77,17 @@ class iter::impl::WindowSlider {
     }
 
     DerefVec<ContainerT>& operator*() {
-      return window_;
+      return *window_;
     }
 
     DerefVec<ContainerT>* operator->() {
-      return window_;
+      return window_.get();
     }
 
     Iterator& operator++() {
       ++sub_iter_;
-      window_.get().pop_front();
-      window_.get().push_back(sub_iter_);
+      window_->get().pop_front();
+      window_->get().push_back(sub_iter_);
       return *this;
     }
 
diff --git a/test/test_mixed.cpp b/test/test_mixed.cpp
index 4f5acc02..a9f45e24 100644
--- a/test/test_mixed.cpp
+++ b/test/test_mixed.cpp
@@ -169,6 +169,18 @@ TEST_CASE("zip(filter(chunked()))", "[filter][chunked][zip]") {
   }
 }
 
+TEST_CASE("zip(filter(sliding_window()))", "[filter][sliding_window][zip]") {
+  using iter::filter;
+  using iter::sliding_window;
+  using iter::zip;
+  std::vector<int16_t> v(15);
+  auto windows = sliding_window(v, 10);
+  auto filtered = filter([](auto&) { return true; }, windows);
+  for (auto&& [window] : zip(filtered)) {
+    REQUIRE(window.size() == 10);
+  }
+}
+
 TEST_CASE("chain.from_iterable: accept imap result that yields rvalues",
     "[chain.from_iterable][imap]") {
   using iter::chain;

From a06b18af7a1ffb6a3db7c650070b1fa7c68cc9e0 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Wed, 12 Jun 2019 01:37:29 -0400
Subject: [PATCH 1774/1866] Tests imap(filter(groupby())) from #59

---
 test/test_mixed.cpp | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/test/test_mixed.cpp b/test/test_mixed.cpp
index a9f45e24..67ffa2ca 100644
--- a/test/test_mixed.cpp
+++ b/test/test_mixed.cpp
@@ -181,6 +181,22 @@ TEST_CASE("zip(filter(sliding_window()))", "[filter][sliding_window][zip]") {
   }
 }
 
+TEST_CASE("imap(filter(groupby()))", "[filter][groupby][imap])") {
+  using iter::filter;
+  using iter::groupby;
+  using iter::imap;
+
+  std::vector<int> v{true, true, true, false, false, true, true};
+  auto a = groupby(v, [](bool b) { return b; });
+  auto b = filter([](auto& g) { return g.first; }, a);
+  auto c = imap(
+      [](auto& g) { return std::distance(g.second.begin(), g.second.end()); },
+      b);
+  for (auto x : c) {
+    (void)x;
+  }
+}
+
 TEST_CASE("chain.from_iterable: accept imap result that yields rvalues",
     "[chain.from_iterable][imap]") {
   using iter::chain;

From 662f7116d95cb3d17b73b73014e2e85d7ed8695a Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Wed, 12 Jun 2019 01:40:47 -0400
Subject: [PATCH 1775/1866] Lazily find first element of filter()

I believe the right approach is to not bind any references to elements
until one actually starts iterating. This way the iterator can be passed
around before iteration starts without a dangling reference. This should
actually fix the filter() issues of #57 and #59
---
 filter.hpp | 29 +++++++++++++++++++----------
 1 file changed, 19 insertions(+), 10 deletions(-)

diff --git a/filter.hpp b/filter.hpp
index 10a793c6..2a632be2 100644
--- a/filter.hpp
+++ b/filter.hpp
@@ -50,12 +50,14 @@ class iter::impl::Filtered {
     template <typename>
     friend class Iterator;
     using Holder = DerefHolder<iterator_deref<ContainerT>>;
-    IteratorWrapper<ContainerT> sub_iter_;
+    mutable IteratorWrapper<ContainerT> sub_iter_;
     IteratorWrapper<ContainerT> sub_end_;
-    Holder item_;
+    mutable Holder item_;
     FilterFunc* filter_func_;
 
-    void inc_sub_iter() {
+    // All of these are marked const because the sub_iter_ is lazily
+    // initialized. The morality of this is questionable.
+    void inc_sub_iter() const {
       ++sub_iter_;
       if (sub_iter_ != sub_end_) {
         item_.reset(*sub_iter_);
@@ -64,13 +66,20 @@ class iter::impl::Filtered {
 
     // increment until the iterator points to is true on the
     // predicate.  Called by constructor and operator++
-    void skip_failures() {
+    void skip_failures() const {
       while (
           sub_iter_ != sub_end_ && !std::invoke(*filter_func_, item_.get())) {
         inc_sub_iter();
       }
     }
 
+    void init_if_first_use() const {
+      if (!item_ && sub_iter_ != sub_end_) {
+        item_.reset(*sub_iter_);
+        skip_failures();
+      }
+    }
+
    public:
     using iterator_category = std::input_iterator_tag;
     using value_type = iterator_traits_deref<ContainerT>;
@@ -82,22 +91,20 @@ class iter::impl::Filtered {
         IteratorWrapper<ContainerT>&& sub_end, FilterFunc& filter_func)
         : sub_iter_{std::move(sub_iter)},
           sub_end_{std::move(sub_end)},
-          filter_func_(&filter_func) {
-      if (sub_iter_ != sub_end_) {
-        item_.reset(*sub_iter_);
-      }
-      skip_failures();
-    }
+          filter_func_(&filter_func) {}
 
     typename Holder::reference operator*() {
+      init_if_first_use();
       return item_.get();
     }
 
     typename Holder::pointer operator->() {
+      init_if_first_use();
       return item_.get_ptr();
     }
 
     Iterator& operator++() {
+      init_if_first_use();
       inc_sub_iter();
       skip_failures();
       return *this;
@@ -111,6 +118,8 @@ class iter::impl::Filtered {
 
     template <typename T>
     bool operator!=(const Iterator<T>& other) const {
+      init_if_first_use();
+      other.init_if_first_use();
       return sub_iter_ != other.sub_iter_;
     }
 

From bacdcb2199314bc3c382190884e1d24976133c9f Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Wed, 12 Jun 2019 02:05:13 -0400
Subject: [PATCH 1776/1866] Adds imap(dropwhile(groupby())) like from #59

---
 test/test_mixed.cpp | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/test/test_mixed.cpp b/test/test_mixed.cpp
index 67ffa2ca..ff364271 100644
--- a/test/test_mixed.cpp
+++ b/test/test_mixed.cpp
@@ -197,6 +197,22 @@ TEST_CASE("imap(filter(groupby()))", "[filter][groupby][imap])") {
   }
 }
 
+TEST_CASE("imap(dropwhile(groupby()))", "[dropwhile][groupby][imap])") {
+  using iter::dropwhile;
+  using iter::groupby;
+  using iter::imap;
+
+  std::vector<int> v{false, false, true, true, false, true, true};
+  auto a = groupby(v, [](bool b) { return b; });
+  auto b = dropwhile([](auto& g) { return g.first; }, a);
+  auto c = imap(
+      [](auto& g) { return std::distance(g.second.begin(), g.second.end()); },
+      b);
+  for (auto x : c) {
+    (void)x;
+  }
+}
+
 TEST_CASE("chain.from_iterable: accept imap result that yields rvalues",
     "[chain.from_iterable][imap]") {
   using iter::chain;

From 29b1e4799d45c419047a89d8d00e8a89bb8be2da Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Wed, 12 Jun 2019 02:09:56 -0400
Subject: [PATCH 1777/1866] Lazily finds first element in dropwhile for #57

---
 dropwhile.hpp | 28 ++++++++++++++++++----------
 1 file changed, 18 insertions(+), 10 deletions(-)

diff --git a/dropwhile.hpp b/dropwhile.hpp
index ca190471..dc1874b0 100644
--- a/dropwhile.hpp
+++ b/dropwhile.hpp
@@ -39,12 +39,13 @@ class iter::impl::Dropper {
     template <typename>
     friend class Iterator;
     using Holder = DerefHolder<iterator_deref<ContainerT>>;
-    IteratorWrapper<ContainerT> sub_iter_;
+    mutable IteratorWrapper<ContainerT> sub_iter_;
     IteratorWrapper<ContainerT> sub_end_;
-    Holder item_;
+    mutable Holder item_;
     FilterFunc* filter_func_;
 
-    void inc_sub_iter() {
+    // see comments from filter about mutability
+    void inc_sub_iter() const {
       ++sub_iter_;
       if (sub_iter_ != sub_end_) {
         item_.reset(*sub_iter_);
@@ -52,12 +53,19 @@ class iter::impl::Dropper {
     }
 
     // skip all values for which the predicate is true
-    void skip_passes() {
+    void skip_passes() const {
       while (sub_iter_ != sub_end_ && std::invoke(*filter_func_, item_.get())) {
         inc_sub_iter();
       }
     }
 
+    void init_if_first_use() const {
+      if (!item_ && sub_iter_ != sub_end_) {
+        item_.reset(*sub_iter_);
+        skip_passes();
+      }
+    }
+
    public:
     using iterator_category = std::input_iterator_tag;
     using value_type = iterator_traits_deref<ContainerT>;
@@ -69,22 +77,20 @@ class iter::impl::Dropper {
         IteratorWrapper<ContainerT>&& sub_end, FilterFunc& filter_func)
         : sub_iter_{std::move(sub_iter)},
           sub_end_{std::move(sub_end)},
-          filter_func_(&filter_func) {
-      if (sub_iter_ != sub_end_) {
-        item_.reset(*sub_iter_);
-      }
-      skip_passes();
-    }
+          filter_func_(&filter_func) {}
 
     typename Holder::reference operator*() {
+      init_if_first_use();
       return item_.get();
     }
 
     typename Holder::pointer operator->() {
+      init_if_first_use();
       return item_.get_ptr();
     }
 
     Iterator& operator++() {
+      init_if_first_use();
       inc_sub_iter();
       return *this;
     }
@@ -97,6 +103,8 @@ class iter::impl::Dropper {
 
     template <typename T>
     bool operator!=(const Iterator<T>& other) const {
+      init_if_first_use();
+      other.init_if_first_use();
       return sub_iter_ != other.sub_iter_;
     }
 

From a430b460eaa385ca911106a23ef5ee1d06371b0e Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Wed, 12 Jun 2019 02:18:40 -0400
Subject: [PATCH 1778/1866] Adds imap(takewhile(groupby())) test from #59

---
 test/test_mixed.cpp | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/test/test_mixed.cpp b/test/test_mixed.cpp
index ff364271..1e4ee949 100644
--- a/test/test_mixed.cpp
+++ b/test/test_mixed.cpp
@@ -213,6 +213,22 @@ TEST_CASE("imap(dropwhile(groupby()))", "[dropwhile][groupby][imap])") {
   }
 }
 
+TEST_CASE("imap(takewhile(groupby()))", "[takewhile][groupby][imap])") {
+  using iter::groupby;
+  using iter::imap;
+  using iter::takewhile;
+
+  std::vector<int> v{true, true, true, false, false};
+  auto a = groupby(v, [](bool b) { return b; });
+  auto b = takewhile([](auto& g) { return g.first; }, a);
+  auto c = imap(
+      [](auto& g) { return std::distance(g.second.begin(), g.second.end()); },
+      b);
+  for (auto x : c) {
+    (void)x;
+  }
+}
+
 TEST_CASE("chain.from_iterable: accept imap result that yields rvalues",
     "[chain.from_iterable][imap]") {
   using iter::chain;

From fbd57d345c037f4c39720027b14901dc61f9436f Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Wed, 12 Jun 2019 02:21:19 -0400
Subject: [PATCH 1779/1866] Lazily checks first element under predicate for #57

---
 takewhile.hpp | 28 +++++++++++++++++++---------
 1 file changed, 19 insertions(+), 9 deletions(-)

diff --git a/takewhile.hpp b/takewhile.hpp
index 8e28fcf2..a04d86b2 100644
--- a/takewhile.hpp
+++ b/takewhile.hpp
@@ -40,11 +40,14 @@ class iter::impl::Taker {
     template <typename>
     friend class Iterator;
     using Holder = DerefHolder<iterator_deref<ContainerT>>;
-    IteratorWrapper<ContainerT> sub_iter_;
+    // I want this mutable so I can use operator* reliably in the const
+    // context of init_if_first_use
+    mutable IteratorWrapper<ContainerT> sub_iter_;
     IteratorWrapper<ContainerT> sub_end_;
-    Holder item_;
+    mutable Holder item_;
     FilterFunc* filter_func_;
 
+    // see comments from filter about mutability
     void inc_sub_iter() {
       ++sub_iter_;
       if (sub_iter_ != sub_end_) {
@@ -52,12 +55,19 @@ class iter::impl::Taker {
       }
     }
 
-    void check_current() {
+    void check_current() const {
       if (sub_iter_ != sub_end_ && !std::invoke(*filter_func_, item_.get())) {
         sub_iter_ = sub_end_;
       }
     }
 
+    void init_if_first_use() const {
+      if (!item_ && sub_iter_ != sub_end_) {
+        item_.reset(*sub_iter_);
+        check_current();
+      }
+    }
+
    public:
     using iterator_category = std::input_iterator_tag;
     using value_type = iterator_traits_deref<ContainerT>;
@@ -69,22 +79,20 @@ class iter::impl::Taker {
         IteratorWrapper<ContainerT>&& sub_end, FilterFunc& filter_func)
         : sub_iter_{std::move(sub_iter)},
           sub_end_{std::move(sub_end)},
-          filter_func_(&filter_func) {
-      if (sub_iter_ != sub_end_) {
-        item_.reset(*sub_iter_);
-      }
-      check_current();
-    }
+          filter_func_(&filter_func) {}
 
     typename Holder::reference operator*() {
+      init_if_first_use();
       return item_.get();
     }
 
     typename Holder::pointer operator->() {
+      init_if_first_use();
       return item_.get_ptr();
     }
 
     Iterator& operator++() {
+      init_if_first_use();
       inc_sub_iter();
       check_current();
       return *this;
@@ -98,6 +106,8 @@ class iter::impl::Taker {
 
     template <typename T>
     bool operator!=(const Iterator<T>& other) const {
+      init_if_first_use();
+      other.init_if_first_use();
       return sub_iter_ != other.sub_iter_;
     }
 

From a166113a3de4f5609745f24e789a43eace914c8f Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Wed, 12 Jun 2019 02:28:31 -0400
Subject: [PATCH 1780/1866] Adds flipped == iterator compare for dropwhile

---
 test/test_dropwhile.cpp | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/test/test_dropwhile.cpp b/test/test_dropwhile.cpp
index 55370092..2b85c607 100644
--- a/test/test_dropwhile.cpp
+++ b/test/test_dropwhile.cpp
@@ -105,7 +105,12 @@ TEST_CASE("dropwhile: skips all elements when all are true under predicate",
     "[dropwhile]") {
   Vec ns{3, 4, 5, 6};
   auto d = dropwhile([](int i) { return i != 0; }, ns);
-  REQUIRE(std::begin(d) == std::end(d));
+  SECTION("normal compare") {
+    REQUIRE(std::begin(d) == std::end(d));
+  }
+  SECTION("reversed compare") {
+    REQUIRE(std::end(d) == std::begin(d));
+  }
 }
 
 TEST_CASE("dropwhile: identity", "[dropwhile]") {
@@ -119,7 +124,12 @@ TEST_CASE("dropwhile: identity", "[dropwhile]") {
 TEST_CASE("dropwhile: empty case is empty", "[dropwhile]") {
   Vec ns{};
   auto d = dropwhile([](int i) { return i != 0; }, ns);
-  REQUIRE(std::begin(d) == std::end(d));
+  SECTION("normal compare") {
+    REQUIRE(std::begin(d) == std::end(d));
+  }
+  SECTION("reversed compare") {
+    REQUIRE(std::end(d) == std::begin(d));
+  }
 }
 
 TEST_CASE("dropwhile: only drops from beginning", "[dropwhile]") {

From 7712c2abce1a486e5ea70eb655ec8b918fb24769 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Wed, 12 Jun 2019 02:29:18 -0400
Subject: [PATCH 1781/1866] Adds flipped == iterator compare for filter

---
 test/test_filter.cpp | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/test/test_filter.cpp b/test/test_filter.cpp
index 73f684ee..b10dd5be 100644
--- a/test/test_filter.cpp
+++ b/test/test_filter.cpp
@@ -149,7 +149,12 @@ TEST_CASE("filter: all elements fail predicate", "[filter]") {
   Vec ns{10, 20, 30, 40, 50};
   auto f = filter(less_than_five, ns);
 
-  REQUIRE(std::begin(f) == std::end(f));
+  SECTION("normal compare") {
+    REQUIRE(std::begin(f) == std::end(f));
+  }
+  SECTION("reversed compare") {
+    REQUIRE(std::end(f) == std::begin(f));
+  }
 }
 
 TEST_CASE("filter: doesn't move or copy elements of iterable", "[filter]") {

From 357961341543f4453ce2e5c2a85f2aa92da2ac56 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Wed, 12 Jun 2019 02:29:32 -0400
Subject: [PATCH 1782/1866] Adds flipped == iterator compare for takewhile

---
 test/test_takewhile.cpp | 21 ++++++++++++++++++---
 1 file changed, 18 insertions(+), 3 deletions(-)

diff --git a/test/test_takewhile.cpp b/test/test_takewhile.cpp
index 23ad8462..903f6a9f 100644
--- a/test/test_takewhile.cpp
+++ b/test/test_takewhile.cpp
@@ -125,7 +125,12 @@ TEST_CASE("takewhile: everything passes predicate", "[takewhile]") {
 TEST_CASE("takewhile: empty iterable is empty", "[takewhile]") {
   Vec ns{};
   auto tw = takewhile(under_ten, ns);
-  REQUIRE(std::begin(tw) == std::end(tw));
+  SECTION("normal compare") {
+    REQUIRE(std::begin(tw) == std::end(tw));
+  }
+  SECTION("reversed compare") {
+    REQUIRE(std::end(tw) == std::begin(tw));
+  }
 }
 
 TEST_CASE(
@@ -134,13 +139,23 @@ TEST_CASE(
   SECTION("First element is only element") {
     Vec ns = {20};
     auto tw = takewhile(under_ten, ns);
-    REQUIRE(std::begin(tw) == std::end(tw));
+    SECTION("normal compare") {
+      REQUIRE(std::begin(tw) == std::end(tw));
+    }
+    SECTION("reversed compare") {
+      REQUIRE(std::end(tw) == std::begin(tw));
+    }
   }
 
   SECTION("First element followed by elements that pass") {
     Vec ns = {20, 1, 1};
     auto tw = takewhile(under_ten, ns);
-    REQUIRE(std::begin(tw) == std::end(tw));
+    SECTION("normal compare") {
+      REQUIRE(std::begin(tw) == std::end(tw));
+    }
+    SECTION("reversed compare") {
+      REQUIRE(std::end(tw) == std::begin(tw));
+    }
   }
 }
 

From dd34859b1cbd5fe8c7013fd0ab6888430fcaaef0 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 23 Jun 2019 12:32:41 -0400
Subject: [PATCH 1783/1866] Replaces count's min() call with lowest()

Fixes #60
---
 count.hpp           |  3 +--
 test/test_count.cpp | 62 +++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 63 insertions(+), 2 deletions(-)

diff --git a/count.hpp b/count.hpp
index 1694589c..327596bf 100644
--- a/count.hpp
+++ b/count.hpp
@@ -8,8 +8,7 @@
 namespace iter {
   template <typename T>
   constexpr auto count(T start, T step) noexcept {
-    // if step is < 0, set the stop to numeric min, otherwise numeric max
-    T stop = step < T(0) ? std::numeric_limits<T>::min()
+    T stop = step < T(0) ? std::numeric_limits<T>::lowest()
                          : std::numeric_limits<T>::max();
     return range(start, stop, step);
   }
diff --git a/test/test_count.cpp b/test/test_count.cpp
index f0f0de68..8998f1eb 100644
--- a/test/test_count.cpp
+++ b/test/test_count.cpp
@@ -65,6 +65,68 @@ TEST_CASE("count: with step > 1", "[count]") {
   REQUIRE(v == vc);
 }
 
+TEST_CASE("count: with unsigned", "[count]") {
+  constexpr unsigned int uint_max =
+      static_cast<unsigned int>(std::numeric_limits<int>::max());
+  std::vector<unsigned int> v{};
+  int steps = 0;
+  for (auto i : count(uint_max)) {
+    v.push_back(i);
+    if (steps == 2) {
+      break;
+    }
+    ++steps;
+  }
+  const std::vector<unsigned int> vc{uint_max, uint_max + 1, uint_max + 2};
+
+  REQUIRE(v == vc);
+}
+
+TEST_CASE("count: with negative step", "[count]") {
+  std::vector<int> v{};
+  int steps = 0;
+  for (auto i : count(0, -1)) {
+    v.push_back(i);
+    if (steps == 2) {
+      break;
+    }
+    ++steps;
+  }
+  const std::vector<int> vc{0, -1, -2};
+
+  REQUIRE(v == vc);
+}
+
+TEST_CASE("count: with double", "[count]") {
+  std::vector<double> v{};
+  int steps = 0;
+  for (auto i : count(1.0, 0.5)) {
+    v.push_back(i);
+    if (steps == 3) {
+      break;
+    }
+    ++steps;
+  }
+  const std::vector<double> vc{1.0, 1.5, 2.0, 2.5};
+
+  REQUIRE(v == vc);
+}
+
+TEST_CASE("count: with negative double step", "[count]") {
+  std::vector<double> v{};
+  int steps = 0;
+  for (auto i : count(1.0, -0.5)) {
+    v.push_back(i);
+    if (steps == 3) {
+      break;
+    }
+    ++steps;
+  }
+  const std::vector<double> vc{1.0, 0.5, 0.0, -0.5};
+
+  REQUIRE(v == vc);
+}
+
 TEST_CASE("count: can bo constexpr", "[count]") {
   constexpr auto c = count();
   constexpr auto c2 = count(5);

From 93d70efe2416d05ae74dde22e0fd0d60378798e0 Mon Sep 17 00:00:00 2001
From: botelho <botelho@rocketml>
Date: Fri, 2 Aug 2019 11:50:24 -0700
Subject: [PATCH 1784/1866] First rev of batched

---
 BUILD                         |   1 +
 batched.hpp                   | 141 ++++++++++++++++++++++++++++++++++
 examples/SConstruct           |   1 +
 examples/batched_examples.cpp |  23 ++++++
 itertools.hpp                 |   1 +
 test/BUILD                    |   1 +
 test/SConstruct               |   1 +
 test/test_batched.cpp         | 101 ++++++++++++++++++++++++
 8 files changed, 270 insertions(+)
 create mode 100644 batched.hpp
 create mode 100644 examples/batched_examples.cpp
 create mode 100644 test/test_batched.cpp

diff --git a/BUILD b/BUILD
index 8b162b86..bab14566 100644
--- a/BUILD
+++ b/BUILD
@@ -2,6 +2,7 @@ cc_library(
     name = "cppitertools",
     hdrs = [
         "accumulate.hpp",
+        "batched.hpp",
         "chain.hpp",
         "chunked.hpp",
         "combinations.hpp",
diff --git a/batched.hpp b/batched.hpp
new file mode 100644
index 00000000..b57f0e28
--- /dev/null
+++ b/batched.hpp
@@ -0,0 +1,141 @@
+#ifndef ITER_BATCHED_HPP_
+#define ITER_BATCHED_HPP_
+
+#include "internal/iterator_wrapper.hpp"
+#include "internal/iteratoriterator.hpp"
+#include "internal/iterbase.hpp"
+
+#include <algorithm>
+#include <functional>
+#include <iterator>
+#include <memory>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+namespace iter {
+  namespace impl {
+    template <typename Container>
+    class Batcher;
+
+    using BatchedFn = IterToolFnBindSizeTSecond<Batcher>;
+  }
+  constexpr impl::BatchedFn batched{};
+}
+
+template <typename Container>
+class iter::impl::Batcher {
+ private:
+  Container container_;
+  std::size_t num_batches_;
+
+  Batcher(Container&& container, std::size_t const num_batches)
+      : container_(std::forward<Container>(container)), num_batches_{num_batches} {}
+
+  friend BatchedFn;
+
+  template <typename T>
+  using IndexVector = std::vector<IteratorWrapper<T>>;
+  template <typename T>
+  using DerefVec = IterIterWrapper<IndexVector<T>>;
+
+ public:
+  Batcher(Batcher&&) = default;
+  template <typename ContainerT>
+  class Iterator {
+   private:
+    template <typename>
+    friend class Iterator;
+    std::shared_ptr<DerefVec<ContainerT>> batch_ =
+        std::make_shared<DerefVec<ContainerT>>();
+    IteratorWrapper<ContainerT> sub_iter_;
+    IteratorWrapper<ContainerT> sub_end_;
+    std::size_t num_batches_;
+    std::size_t size_;
+    std::size_t count_;
+
+    bool done() const {
+      return batch_->empty();
+    }
+
+    void refill_batch() {
+      batch_->get().clear();
+      if (count_ < num_batches_) {
+        std::size_t const batch_size(size_ / num_batches_ + std::min<std::size_t>(1, (size_ % num_batches_) / (count_ + 1)));
+        batch_->get().reserve(batch_size);
+        for (std::size_t i = 0; i < batch_size; ++i) {
+          batch_->get().push_back(sub_iter_);
+          ++sub_iter_;
+        }
+        ++count_;
+      }
+    }
+
+   public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = DerefVec<ContainerT>;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
+    Iterator(IteratorWrapper<ContainerT>&& sub_iter,
+        IteratorWrapper<ContainerT>&& sub_end, std::size_t num_batches)
+        : sub_iter_{std::move(sub_iter)},
+          sub_end_{std::move(sub_end)},
+          num_batches_{num_batches},
+          size_{static_cast<std::size_t>(std::distance(sub_iter_, sub_end_))},
+          count_{0} {
+      refill_batch();
+    }
+
+    Iterator& operator++() {
+      refill_batch();
+      return *this;
+    }
+
+    Iterator operator++(int) {
+      auto ret = *this;
+      ++*this;
+      return ret;
+    }
+
+    template <typename T>
+    bool operator!=(const Iterator<T>& other) const {
+      return !(*this == other);
+    }
+
+    template <typename T>
+    bool operator==(const Iterator<T>& other) const {
+      return done() == other.done()
+             && (done() || !(sub_iter_ != other.sub_iter_));
+    }
+
+    DerefVec<ContainerT>& operator*() {
+      return *batch_;
+    }
+
+    DerefVec<ContainerT>* operator->() {
+      return batch_.get();
+    }
+  };
+
+  Iterator<Container> begin() {
+    return {get_begin(container_), get_end(container_), num_batches_};
+  }
+
+  Iterator<Container> end() {
+    return {get_end(container_), get_end(container_), num_batches_};
+  }
+
+  Iterator<AsConst<Container>> begin() const {
+    return {get_begin(std::as_const(container_)),
+        get_end(std::as_const(container_)), num_batches_};
+  }
+
+  Iterator<AsConst<Container>> end() const {
+    return {get_end(std::as_const(container_)),
+        get_end(std::as_const(container_)), num_batches_};
+  }
+};
+
+#endif
diff --git a/examples/SConstruct b/examples/SConstruct
index c1ed4d10..5f9110c9 100644
--- a/examples/SConstruct
+++ b/examples/SConstruct
@@ -15,6 +15,7 @@ env['ENV']['TERM'] = os.environ['TERM']
 progs = Split(
     '''
     accumulate
+    batched
     chain
     chunked
     combinatoric
diff --git a/examples/batched_examples.cpp b/examples/batched_examples.cpp
new file mode 100644
index 00000000..1d2d4a6c
--- /dev/null
+++ b/examples/batched_examples.cpp
@@ -0,0 +1,23 @@
+#include <batched.hpp>
+
+#include <iostream>
+#include <vector>
+
+int main() {
+    std::vector<int> v {1,2,3,4,5,6,7,8,9}; 
+    std::cout << "num batches: 5\n";
+    for (auto&& sec : iter::batched(v, 5)) {
+        for (auto&& i : sec) {
+            std::cout << i << " ";
+        }
+        std::cout << '\n';
+    }
+
+    std::cout << "num batches: 4\n";
+    for (auto&& sec : iter::batched(v,4)) {
+        for (auto&& i : sec) {
+            std::cout << i << " ";
+        }
+        std::cout << '\n';
+    }
+}
diff --git a/itertools.hpp b/itertools.hpp
index 7dd9b9a8..bf824196 100644
--- a/itertools.hpp
+++ b/itertools.hpp
@@ -2,6 +2,7 @@
 #define ITERTOOLS_ALL_HPP_
 
 #include "accumulate.hpp"
+#include "batched.hpp"
 #include "chain.hpp"
 #include "chunked.hpp"
 #include "combinations.hpp"
diff --git a/test/BUILD b/test/BUILD
index b7bdc149..9ceefecd 100644
--- a/test/BUILD
+++ b/test/BUILD
@@ -2,6 +2,7 @@ load(":make_tests.bzl", "itertools_tests")
 
 progs = [
     "accumulate",
+    "batched",
     "chain",
     "chunked",
     "combinations",
diff --git a/test/SConstruct b/test/SConstruct
index e338b923..98af3051 100644
--- a/test/SConstruct
+++ b/test/SConstruct
@@ -23,6 +23,7 @@ if env['CXX'].startswith('clang++'):
 progs = Split(
     '''
     accumulate
+    batched
     chain
     chunked
     combinations
diff --git a/test/test_batched.cpp b/test/test_batched.cpp
new file mode 100644
index 00000000..209edc42
--- /dev/null
+++ b/test/test_batched.cpp
@@ -0,0 +1,101 @@
+#include <batched.hpp>
+
+#include <array>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "catch.hpp"
+#include "helpers.hpp"
+
+using iter::batched;
+using Vec = std::vector<int>;
+using ResVec = std::vector<Vec>;
+
+TEST_CASE("batched: basic test", "[batched]") {
+  Vec ns = {1, 2, 3, 4, 5, 6};
+  ResVec results;
+  SECTION("Normal call") {
+    for (auto&& g : batched(ns, 2)) {
+      results.emplace_back(std::begin(g), std::end(g));
+    }
+  }
+  SECTION("Pipe") {
+    for (auto&& g : ns | batched(2)) {
+      results.emplace_back(std::begin(g), std::end(g));
+    }
+  }
+
+  ResVec rc = {{1, 2, 3}, {4 ,5, 6}};
+
+  REQUIRE(results == rc);
+}
+
+TEST_CASE("batched: const batched", "[batched][const]") {
+  Vec ns = {1, 2, 3, 4, 5, 6};
+  ResVec results;
+  SECTION("Normal call") {
+    const auto& ch = batched(ns, 2);
+    for (auto&& g : ch) {
+      results.emplace_back(std::begin(g), std::end(g));
+    }
+  }
+  ResVec rc = {{1, 2, 3}, {4, 5, 6}};
+
+  REQUIRE(results == rc);
+}
+
+TEST_CASE("batched: const iterators can be compared to non-const iterators",
+    "[batched][const]") {
+  auto c = batched(Vec{}, 1);
+  const auto& cc = c;
+  (void)(std::begin(c) == std::end(cc));
+}
+
+TEST_CASE("batched: len(iterable) % groupsize != 0", "[batched]") {
+  Vec ns = {1, 2, 3, 4, 5, 6, 7};
+  ResVec results;
+  for (auto&& g : batched(ns, 3)) {
+    results.emplace_back(std::begin(g), std::end(g));
+  }
+
+  ResVec rc = {{1, 2, 3}, {4, 5}, {6, 7}};
+
+  REQUIRE(results == rc);
+}
+
+TEST_CASE("batched: iterators can be compared", "[batched]") {
+  Vec ns = {1, 2, 3, 4, 5, 6, 7};
+  auto g = batched(ns, 3);
+  auto it = std::begin(g);
+  REQUIRE(it == std::begin(g));
+  REQUIRE_FALSE(it != std::begin(g));
+  ++it;
+  REQUIRE(it != std::begin(g));
+  REQUIRE_FALSE(it == std::begin(g));
+}
+
+TEST_CASE("batched: size 0 is empty", "[batched]") {
+  Vec ns{1, 2, 3};
+  auto g = batched(ns, 0);
+  REQUIRE(std::begin(g) == std::end(g));
+}
+
+TEST_CASE("batched: empty iterable gives empty batched", "[batched]") {
+  Vec ns{};
+  auto g = batched(ns, 1);
+  REQUIRE(std::begin(g) == std::end(g));
+}
+
+TEST_CASE("batched: iterator meets requirements", "[batched]") {
+  std::string s{};
+  auto c = batched(s, 1);
+  REQUIRE(itertest::IsIterator<decltype(std::begin(c))>::value);
+}
+
+template <typename T>
+using ImpT = decltype(batched(std::declval<T>(), 1));
+TEST_CASE("batched: has correct ctor and assign ops", "[batched]") {
+  REQUIRE(itertest::IsMoveConstructibleOnly<ImpT<std::string&>>::value);
+  REQUIRE(itertest::IsMoveConstructibleOnly<ImpT<std::string>>::value);
+}

From 95b1d3881941c431aa389f24970db93abbee6976 Mon Sep 17 00:00:00 2001
From: botelho <botelho@rocketml>
Date: Fri, 2 Aug 2019 15:39:18 -0700
Subject: [PATCH 1785/1866] Minor

---
 examples/batched_examples.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/batched_examples.cpp b/examples/batched_examples.cpp
index 1d2d4a6c..dfe67486 100644
--- a/examples/batched_examples.cpp
+++ b/examples/batched_examples.cpp
@@ -14,7 +14,7 @@ int main() {
     }
 
     std::cout << "num batches: 4\n";
-    for (auto&& sec : iter::batched(v,4)) {
+    for (auto&& sec : iter::batched(v, 4)) {
         for (auto&& i : sec) {
             std::cout << i << " ";
         }

From 3e7ceca38cc17b2f6707da1615896628a47fecdb Mon Sep 17 00:00:00 2001
From: botelho <botelho@rocketml>
Date: Fri, 2 Aug 2019 18:17:18 -0700
Subject: [PATCH 1786/1866] Added support for containers with different begin
 and end types

---
 batched.hpp           | 24 +++++++++++++++++++++++-
 test/test_batched.cpp | 10 ++++++++++
 2 files changed, 33 insertions(+), 1 deletion(-)

diff --git a/batched.hpp b/batched.hpp
index b57f0e28..e5eadf13 100644
--- a/batched.hpp
+++ b/batched.hpp
@@ -78,12 +78,34 @@ class iter::impl::Batcher {
     using pointer = value_type*;
     using reference = value_type&;
 
+    template <typename Iter1, typename Iter2, typename = void>
+    struct distance_helper {
+      static constexpr difference_type distance(Iter1 it1, Iter2 it2) {
+        difference_type dist(0);
+        for (; it1 != it2; ++it1)
+          ++dist;
+        return dist;
+      } 
+    };
+
+    template <typename Iter1, typename Iter2>
+    struct distance_helper<Iter1, Iter2, typename std::enable_if_t<std::is_arithmetic_v<typename Iter1::difference_type> && std::is_arithmetic_v<typename Iter2::difference_type>>> {
+      static constexpr difference_type distance(Iter1 it1, Iter2 it2) {
+        return std::distance(it1, it2);
+      }
+    };
+
+    template <typename Iter1, typename Iter2>
+    difference_type distance(Iter1 it1, Iter2 it2) const {
+      return distance_helper<Iter1, Iter2>::distance(it1, it2);
+    }
+
     Iterator(IteratorWrapper<ContainerT>&& sub_iter,
         IteratorWrapper<ContainerT>&& sub_end, std::size_t num_batches)
         : sub_iter_{std::move(sub_iter)},
           sub_end_{std::move(sub_end)},
           num_batches_{num_batches},
-          size_{static_cast<std::size_t>(std::distance(sub_iter_, sub_end_))},
+          size_{static_cast<std::size_t>(distance(sub_iter_, sub_end_))},
           count_{0} {
       refill_batch();
     }
diff --git a/test/test_batched.cpp b/test/test_batched.cpp
index 209edc42..962b77ec 100644
--- a/test/test_batched.cpp
+++ b/test/test_batched.cpp
@@ -81,6 +81,16 @@ TEST_CASE("batched: size 0 is empty", "[batched]") {
   REQUIRE(std::begin(g) == std::end(g));
 }
 
+TEST_CASE("batched: Works with different begin and end types", "[batched]") {
+  CharRange cr{'f'};
+  std::vector<std::vector<char>> results;
+  for (auto&& g : batched(cr, 3)) {
+    results.emplace_back(std::begin(g), std::end(g));
+  }
+  std::vector<std::vector<char>> rc = {{'a', 'b'}, {'c', 'd'}, {'e'}};
+  REQUIRE(results == rc);
+}
+
 TEST_CASE("batched: empty iterable gives empty batched", "[batched]") {
   Vec ns{};
   auto g = batched(ns, 1);

From 4ba6e0469b2868fc3cf8c430b060263847236c26 Mon Sep 17 00:00:00 2001
From: ssbotelh <ssbotelh@users.noreply.github.com>
Date: Sat, 3 Aug 2019 10:54:50 -0700
Subject: [PATCH 1787/1866] Added batched to README.md

---
 README.md | 30 +++++++++++++++++++++++++++++-
 1 file changed, 29 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 1c85fd38..758b6491 100644
--- a/README.md
+++ b/README.md
@@ -42,6 +42,7 @@ Status | Compilers
 [slice](#slice)<br />
 [sliding\_window](#sliding_window)<br />
 [chunked](#chunked)<br />
+[batched](#batched)<br />
 
 ##### Combinatoric fuctions
 [product](#product)<br />
@@ -168,6 +169,7 @@ would expect them to behave:
 - accumulate
 - chain.from\_iterable
 - chunked
+- batched
 - combinations
 - combinations\_with\_replacement
 - cycle
@@ -753,7 +755,7 @@ for (auto&& sec : sliding_window(v,4)) {
 chunked
 ------
 
-chunked will yield subsequent chunkes of an iterable in blocks of a specified
+chunked will yield subsequent chunks of an iterable in blocks of a specified
 size. The final chunk may be shorter than the rest if the chunk size given
 does not evenly divide the length of the iterable.
 
@@ -774,6 +776,32 @@ The above prints:
 5 6 7 8
 9
 ```
+batched
+-------
+
+batched will yield a given number N of batches containing subsequent elements from an iterable,
+assuming the iterable contains at least N elements.
+The size of each batch is immaterial, but the implementation guarantees that no two batches will
+differ in size by more than 1. 
+
+Example usage:
+```c++
+vector<int> v {1,2,3,4,5,6,7,8,9};
+for (auto&& sec : batched(v,4)) {
+    for (auto&& i : sec) {
+        cout << i << ' ';
+    }
+    cout << '\n';
+}
+```
+
+The above prints:
+```
+1 2 3
+4 5
+6 7
+8 9
+```
 
 product
 ------

From 91d091fe884a6731d3c329a4c19b8e87552afc2f Mon Sep 17 00:00:00 2001
From: botelho <botelho@rocketml>
Date: Sun, 4 Aug 2019 23:15:02 -0700
Subject: [PATCH 1788/1866] Added test case

---
 test/test_batched.cpp | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/test/test_batched.cpp b/test/test_batched.cpp
index 962b77ec..e32adfc1 100644
--- a/test/test_batched.cpp
+++ b/test/test_batched.cpp
@@ -52,7 +52,7 @@ TEST_CASE("batched: const iterators can be compared to non-const iterators",
   (void)(std::begin(c) == std::end(cc));
 }
 
-TEST_CASE("batched: len(iterable) % groupsize != 0", "[batched]") {
+TEST_CASE("batched: len(iterable) % num_batches != 0", "[batched]") {
   Vec ns = {1, 2, 3, 4, 5, 6, 7};
   ResVec results;
   for (auto&& g : batched(ns, 3)) {
@@ -64,6 +64,18 @@ TEST_CASE("batched: len(iterable) % groupsize != 0", "[batched]") {
   REQUIRE(results == rc);
 }
 
+TEST_CASE("batched: num_batches > len(iterable)", "[batched]") {
+  Vec ns = {1, 2, 3, 4, 5, 6, 7};
+  ResVec results;
+  for (auto&& g : batched(ns, 9)) {
+    results.emplace_back(std::begin(g), std::end(g));
+  }
+
+  ResVec rc = {{1}, {2}, {3}, {4}, {5}, {6}, {7}};
+
+  REQUIRE(results == rc);
+}
+
 TEST_CASE("batched: iterators can be compared", "[batched]") {
   Vec ns = {1, 2, 3, 4, 5, 6, 7};
   auto g = batched(ns, 3);

From 2a5de0c2b41f33dde724cb0442d272ea620078b4 Mon Sep 17 00:00:00 2001
From: botelho <botelho@rocketml>
Date: Mon, 5 Aug 2019 09:20:41 -0700
Subject: [PATCH 1789/1866] Added another example

---
 examples/batched_examples.cpp | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/examples/batched_examples.cpp b/examples/batched_examples.cpp
index dfe67486..c63c05b3 100644
--- a/examples/batched_examples.cpp
+++ b/examples/batched_examples.cpp
@@ -20,4 +20,12 @@ int main() {
         }
         std::cout << '\n';
     }
+
+    std::cout << "num batches: 6\n";
+    for (auto&& sec : iter::batched(v, 6)) {
+        for (auto&& i : sec) {
+            std::cout << i << " ";
+        }
+        std::cout << '\n';
+    }
 }

From c8b32d1ff8ec4273bed2d99ec32383529ce348c9 Mon Sep 17 00:00:00 2001
From: botelho <botelho@rocketml>
Date: Mon, 5 Aug 2019 09:34:02 -0700
Subject: [PATCH 1790/1866] Added test for uneven batch sizes

---
 test/test_batched.cpp | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/test/test_batched.cpp b/test/test_batched.cpp
index e32adfc1..bdd5e2a3 100644
--- a/test/test_batched.cpp
+++ b/test/test_batched.cpp
@@ -31,6 +31,18 @@ TEST_CASE("batched: basic test", "[batched]") {
   REQUIRE(results == rc);
 }
 
+TEST_CASE("batched: uneven batch sizes", "[batched]") {
+  Vec ns = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+  ResVec results;
+  for (auto&& g : batched(ns, 6)) {
+    results.emplace_back(std::begin(g), std::end(g));
+  }
+
+  ResVec rc = {{1, 2}, {3, 4}, {5, 6}, {7}, {8}, {9}};
+
+  REQUIRE(results == rc);
+}
+
 TEST_CASE("batched: const batched", "[batched][const]") {
   Vec ns = {1, 2, 3, 4, 5, 6};
   ResVec results;

From 41f7d221fe452dfc198914560355b837423e2a1d Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 25 Aug 2019 17:50:17 -0400
Subject: [PATCH 1791/1866] Replaces assignment with emplace in DerefHolder

Fixes #62
---
 internal/iterbase.hpp |  2 +-
 test/test_mixed.cpp   | 15 +++++++++++++++
 2 files changed, 16 insertions(+), 1 deletion(-)

diff --git a/internal/iterbase.hpp b/internal/iterbase.hpp
index df1df2ba..57cc1b78 100644
--- a/internal/iterbase.hpp
+++ b/internal/iterbase.hpp
@@ -298,7 +298,7 @@ namespace iter {
       }
 
       void reset(T&& item) {
-        item_p_ = std::move(item);
+        item_p_.emplace(std::move(item));
       }
 
       explicit operator bool() const {
diff --git a/test/test_mixed.cpp b/test/test_mixed.cpp
index 1e4ee949..e9b92d34 100644
--- a/test/test_mixed.cpp
+++ b/test/test_mixed.cpp
@@ -241,3 +241,18 @@ TEST_CASE("chain.from_iterable: accept imap result that yields rvalues",
 
   REQUIRE(v == vc);
 }
+
+TEST_CASE(
+    "filter(enumerate()), DerefHolder works correctly (see github issue #62",
+    "[filter][enumerate]") {
+  using iter::enumerate;
+  using iter::filter;
+  std::vector<int> ns = {50, 55, 60, 65};
+  auto f =
+      iter::filter([](auto& i) { return std::get<0>(i) > 1; }, enumerate(ns));
+  const std::vector<std::pair<int, int>> v(std::begin(f), std::end(f));
+
+  const std::vector<std::pair<int, int>> vc = {{2, 60}, {3, 65}};
+
+  REQUIRE(v == vc);
+}

From 334c7155638a916244234678f3922bd063d68d95 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 16 Sep 2019 10:44:29 -0700
Subject: [PATCH 1792/1866] Adds MSVC 2019 to appveyor build status description

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 758b6491..5f473218 100644
--- a/README.md
+++ b/README.md
@@ -14,7 +14,7 @@ Follow [@cppitertools](https://twitter.com/cppitertools) for updates.
 Status | Compilers
 ---- | ---- 
 [![Travis Build Status](https://travis-ci.com/ryanhaining/cppitertools.svg?branch=master)](https://travis-ci.com/ryanhaining/cppitertools) | gcc-7  gcc-8 clang-5.0 clang-6.0
-[![Appveyor Build Status](https://ci.appveyor.com/api/projects/status/github/ryanhaining/cppitertools?svg=true)](https://ci.appveyor.com/project/ryanhaining/cppitertools) | MSVC 2017
+[![Appveyor Build Status](https://ci.appveyor.com/api/projects/status/github/ryanhaining/cppitertools?svg=true)](https://ci.appveyor.com/project/ryanhaining/cppitertools) | MSVC 2017 MSVC 2019
 
 #### Table of Contents
 [range](#range)<br />

From cb3635456bdb531121b82b4d2e3afc7ae1f56d47 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Sun, 22 Dec 2019 21:29:36 -0500
Subject: [PATCH 1793/1866] Fixes const iteration for chain()

Fixes #65
---
 chain.hpp           | 14 ++++++++++++--
 test/test_chain.cpp | 14 +++++++-------
 2 files changed, 19 insertions(+), 9 deletions(-)

diff --git a/chain.hpp b/chain.hpp
index d289a6a3..23d1e054 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -25,6 +25,16 @@ namespace iter {
     // rather than a chain function, use a callable object to support
     // from_iterable
     class ChainMaker;
+
+    template <typename>
+    struct AsTupleOfConstImpl;
+
+    template <typename... Ts>
+    struct AsTupleOfConstImpl<std::tuple<Ts...>>
+        : type_is<std::tuple<AsConst<Ts>...>> {};
+
+    template <typename T>
+    using AsTupleOfConst = typename AsTupleOfConstImpl<T>::type;
   }
 }
 
@@ -169,12 +179,12 @@ class iter::impl::Chained {
         {get_end(std::get<Is>(tup_))...}};
   }
 
-  Iterator<AsConst<TupType>> begin() const {
+  Iterator<AsTupleOfConst<TupType>> begin() const {
     return {0, {get_begin(std::as_const(std::get<Is>(tup_)))...},
         {get_end(std::as_const(std::get<Is>(tup_)))...}};
   }
 
-  Iterator<AsConst<TupType>> end() const {
+  Iterator<AsTupleOfConst<TupType>> end() const {
     return {sizeof...(Is), {get_end(std::as_const(std::get<Is>(tup_)))...},
         {get_end(std::as_const(std::get<Is>(tup_)))...}};
   }
diff --git a/test/test_chain.cpp b/test/test_chain.cpp
index 6caabe3f..b4b77cf2 100644
--- a/test/test_chain.cpp
+++ b/test/test_chain.cpp
@@ -10,8 +10,8 @@
 #include "catch.hpp"
 
 using iter::chain;
-using itertest::SolidInt;
 using itertest::BasicIterable;
+using itertest::SolidInt;
 using Vec = const std::vector<char>;
 
 TEST_CASE("chain: three strings", "[chain]") {
@@ -28,8 +28,8 @@ TEST_CASE("chain: three strings", "[chain]") {
 
 TEST_CASE("chain: const iteration", "[chain][const]") {
   std::string s1{"abc"};
-  /* const */ std::string s2{"mno"};
-  auto ch = chain(s1, s2, std::string{"xyz"});
+  const std::string s2{"mno"};
+  const auto ch = chain(s1, s2, std::string{"xyz"});
 
   Vec v(std::begin(ch), std::end(ch));
   Vec vc{'a', 'b', 'c', 'm', 'n', 'o', 'x', 'y', 'z'};
@@ -309,8 +309,8 @@ template <typename T>
 using ImpT2 = decltype(chain.from_iterable(std::declval<T>()));
 TEST_CASE("chain.from_iterable: has correct ctor and assign ops",
     "[chain.from_iterable]") {
-  REQUIRE(itertest::IsMoveConstructibleOnly<ImpT2<std::vector<std::string>>>::
-          value);
-  REQUIRE(itertest::IsMoveConstructibleOnly<ImpT2<std::vector<std::string>&>>::
-          value);
+  REQUIRE(itertest::IsMoveConstructibleOnly<
+      ImpT2<std::vector<std::string>>>::value);
+  REQUIRE(itertest::IsMoveConstructibleOnly<
+      ImpT2<std::vector<std::string>&>>::value);
 }

From 2cc82d2be666aabd66279a8693fd2c6f196117c1 Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Thu, 26 Dec 2019 15:04:25 -0800
Subject: [PATCH 1794/1866] Adds information to imap return type. Fixes #66

---
 imap.hpp | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/imap.hpp b/imap.hpp
index f022e6d0..1e84faf0 100644
--- a/imap.hpp
+++ b/imap.hpp
@@ -1,17 +1,21 @@
 #ifndef ITER_IMAP_H_
 #define ITER_IMAP_H_
 
+#include <utility>
+
 #include "starmap.hpp"
 #include "zip.hpp"
 
-#include <utility>
-
 namespace iter {
   namespace impl {
     struct IMapFn : PipeableAndBindFirst<IMapFn> {
       template <typename MapFunc, typename... Containers>
-      decltype(auto) operator()(
-          MapFunc map_func, Containers&&... containers) const {
+      auto operator()(MapFunc map_func, Containers&&... containers) const
+          // explicitly specifying type here to allow more expressions that only
+          // care about the type, and don't need a valid implementation.
+          // See #66
+          -> StarMapper<MapFunc,
+              decltype(zip(std::forward<Containers>(containers)...))> {
         return starmap(map_func, zip(std::forward<Containers>(containers)...));
       }
       using PipeableAndBindFirst<IMapFn>::operator();

From 0ebfbd60a05fe6ac2b9c39759dd91cc2cf69c136 Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Thu, 26 Dec 2019 15:08:45 -0800
Subject: [PATCH 1795/1866] Removes trailing whitespace in README

---
 README.md | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/README.md b/README.md
index 5f473218..bd52d172 100644
--- a/README.md
+++ b/README.md
@@ -12,7 +12,7 @@ Follow [@cppitertools](https://twitter.com/cppitertools) for updates.
 
 #### Build and Test Status
 Status | Compilers
----- | ---- 
+---- | ----
 [![Travis Build Status](https://travis-ci.com/ryanhaining/cppitertools.svg?branch=master)](https://travis-ci.com/ryanhaining/cppitertools) | gcc-7  gcc-8 clang-5.0 clang-6.0
 [![Appveyor Build Status](https://ci.appveyor.com/api/projects/status/github/ryanhaining/cppitertools?svg=true)](https://ci.appveyor.com/project/ryanhaining/cppitertools) | MSVC 2017 MSVC 2019
 
@@ -253,11 +253,11 @@ recomputed at each step to avoid accumulating floating point inaccuracies
 slower but more accurate.
 
 `range` also supports the following operations:
-  - `.size()` to get the number of elements in the range (not enabled for 
-  floating point ranges). 
+  - `.size()` to get the number of elements in the range (not enabled for
+  floating point ranges).
   - Accessors for `.start()`, `.stop()`, and `.step()`.
   - Indexing. Given a range `r`, `r[n]` is the `n`th element in the range.
-  
+
 enumerate
 ---------
 
@@ -782,7 +782,7 @@ batched
 batched will yield a given number N of batches containing subsequent elements from an iterable,
 assuming the iterable contains at least N elements.
 The size of each batch is immaterial, but the implementation guarantees that no two batches will
-differ in size by more than 1. 
+differ in size by more than 1.
 
 Example usage:
 ```c++

From 342e7523e35470ce93e032e37a41eba4893c45c6 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Wed, 1 Jan 2020 23:45:47 -0500
Subject: [PATCH 1796/1866] Travis: add gcc-9, clang-7,8,9, upgrade to xenial

---
 .travis.yml | 78 ++++++++++++++++++++++++++++++++++++++++++++++++++---
 README.md   |  2 +-
 2 files changed, 76 insertions(+), 4 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index d4d97a0d..349a41d2 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,5 +1,5 @@
 language: cpp
-dist: trusty
+dist: xenial
 sudo: require
 
 matrix:
@@ -10,7 +10,7 @@ matrix:
         apt:
           sources:
             - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-5.0
+            - llvm-toolchain-xenial
           packages:
             - clang-5.0
             - clang++-5.0
@@ -18,6 +18,7 @@ matrix:
             - gcc-8-base
             - libc6
             - libgcc1
+            - scons
       env:
         - COMPILER=clang++-5.0
         - USE_LIBCXX=1
@@ -27,7 +28,7 @@ matrix:
         apt:
           sources:
             - ubuntu-toolchain-r-test
-            - llvm-toolchain-trusty-6.0
+            - llvm-toolchain-xenial
           packages:
             - clang-6.0
             - clang++-6.0
@@ -35,9 +36,67 @@ matrix:
             - gcc-8-base
             - libc6
             - libgcc1
+            - scons
       env:
         - COMPILER=clang++-6.0
         - USE_LIBCXX=1
+    - os: linux
+      compiler: clang
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-xenial-7
+          packages:
+            - clang-7
+            - clang++-7
+            - valgrind
+            - gcc-8-base
+            - libc6
+            - libgcc1
+            - scons
+      env:
+        - COMPILER=clang++-7
+        - USE_LIBCXX=1
+    - os: linux
+      compiler: clang
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-xenial-8
+          packages:
+            - clang-8
+            - clang++-8
+            - valgrind
+            - gcc-8-base
+            - libc6
+            - libgcc1
+            - scons
+      env:
+        - COMPILER=clang++-8
+        - USE_LIBCXX=1
+    - os: linux
+      compiler: clang
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+              # travis complains about an unlisted source here if I do it with a plain
+              # llvm-toolchain-xenial-9
+            - sourceline: 'deb https://apt.llvm.org/xenial/ llvm-toolchain-xenial-9 main'
+              key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
+          packages:
+            - clang-9
+            - clang++-9
+            - valgrind
+            - gcc-8-base
+            - libc6
+            - libgcc1
+            - scons
+      env:
+        - COMPILER=clang++-9
+        - USE_LIBCXX=1
     - os: linux
       addons:
         apt:
@@ -46,6 +105,7 @@ matrix:
           packages:
             - g++-7
             - valgrind
+            - scons
       env:
         - COMPILER=g++-7
     - os: linux
@@ -56,8 +116,20 @@ matrix:
           packages:
             - g++-8
             - valgrind
+            - scons
       env:
         - COMPILER=g++-8
+    - os: linux
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+            - g++-9
+            - valgrind
+            - scons
+      env:
+        - COMPILER=g++-9
 
 script:
   - ${COMPILER} --version
diff --git a/README.md b/README.md
index bd52d172..a7f6e5ca 100644
--- a/README.md
+++ b/README.md
@@ -13,7 +13,7 @@ Follow [@cppitertools](https://twitter.com/cppitertools) for updates.
 #### Build and Test Status
 Status | Compilers
 ---- | ----
-[![Travis Build Status](https://travis-ci.com/ryanhaining/cppitertools.svg?branch=master)](https://travis-ci.com/ryanhaining/cppitertools) | gcc-7  gcc-8 clang-5.0 clang-6.0
+[![Travis Build Status](https://travis-ci.com/ryanhaining/cppitertools.svg?branch=master)](https://travis-ci.com/ryanhaining/cppitertools) | gcc-7 gcc-8 gcc-9 clang-5.0 clang-6.0 clang-7 clang-8 clang-9
 [![Appveyor Build Status](https://ci.appveyor.com/api/projects/status/github/ryanhaining/cppitertools?svg=true)](https://ci.appveyor.com/project/ryanhaining/cppitertools) | MSVC 2017 MSVC 2019
 
 #### Table of Contents

From 96ee0635e338a895502fe74ec1df7103ebc3e49e Mon Sep 17 00:00:00 2001
From: Alexander Bigerl <bigerl@mail.uni-paderborn.de>
Date: Fri, 17 Jan 2020 11:53:01 +0100
Subject: [PATCH 1797/1866] added conan build

---
 CMakeLists.txt              | 41 +++++++++++++++++++++++++++++++++++++
 cmake/dummy-config.cmake.in |  5 +++++
 conanfile.py                | 31 ++++++++++++++++++++++++++++
 3 files changed, 77 insertions(+)
 create mode 100644 CMakeLists.txt
 create mode 100644 cmake/dummy-config.cmake.in
 create mode 100644 conanfile.py

diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 00000000..59c84944
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,41 @@
+cmake_minimum_required(VERSION 3.12)
+project(cppitertools VERSION 2.0)
+set(CMAKE_CXX_STANDARD 17)
+
+
+# installation directories
+set(cppitertools_INSTALL_INCLUDE_DIR "include" CACHE STRING "The installation include directory")
+set(cppitertools_INSTALL_CMAKE_DIR "share/cppitertools/cmake" CACHE STRING "The installation cmake directory")
+
+
+# define a header-only library
+add_library(cppitertools INTERFACE)
+add_library(cppitertools::cppitertools ALIAS cppitertools)
+
+target_include_directories(cppitertools INTERFACE
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
+        $<INSTALL_INTERFACE:${cppitertools_INSTALL_CMAKE_DIR}>
+        )
+
+
+# require C++17
+target_compile_features(cppitertools INTERFACE cxx_std_17)
+
+# Make package findable
+configure_file(cmake/dummy-config.cmake.in cppitertools-config.cmake @ONLY)
+
+# Enable version checks in find_package
+include(CMakePackageConfigHelpers)
+write_basic_package_version_file(cppitertools-config-version.cmake COMPATIBILITY SameMajorVersion)
+
+# install and export target
+install(TARGETS cppitertools EXPORT cppitertools-targets)
+
+install(EXPORT cppitertools-targets
+        FILE cppitertools-config.cmake
+        NAMESPACE cppitertools::
+        DESTINATION ${cppitertools_INSTALL_CMAKE_DIR}
+        )
+
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/cppitertools-config-version.cmake DESTINATION ${cppitertools_INSTALL_CMAKE_DIR})
+install(DIRECTORY . DESTINATION ${cppitertools_INSTALL_INCLUDE_DIR})
diff --git a/cmake/dummy-config.cmake.in b/cmake/dummy-config.cmake.in
new file mode 100644
index 00000000..d8c788f1
--- /dev/null
+++ b/cmake/dummy-config.cmake.in
@@ -0,0 +1,5 @@
+# Dummy config file
+# When a dependency is added with add_subdirectory, but searched with find_package
+
+# Redirect to the directory added with add_subdirectory
+add_subdirectory(@PROJECT_SOURCE_DIR@ @PROJECT_BINARY_DIR@)
\ No newline at end of file
diff --git a/conanfile.py b/conanfile.py
new file mode 100644
index 00000000..4427b7a8
--- /dev/null
+++ b/conanfile.py
@@ -0,0 +1,31 @@
+from conans import ConanFile, CMake
+
+import os
+
+
+class Tentris_Parser(ConanFile):
+    name = "cppitertools"
+    version = "1.0"
+    author = "Ryan Haining"
+    description = "Implementation of python itertools and builtin iteration functions for C++17 "
+    topics = ("please add topics here")
+    settings = "build_type", "compiler", "os", "arch"
+    generators = "cmake", "cmake_find_package", "cmake_paths"
+
+    exports_sources = list()
+    for file in os.listdir("."):
+        if file.endswith(".hpp"):
+            exports_sources.append(str(file))
+    print("found files: " + str(exports_sources))
+
+    exports_sources = tuple(exports_sources) + \
+                      ("internal/*", "CMakeLists.txt", "cmake/dummy-config.cmake.in", "LICENSE.md")
+    no_copy_source = True
+
+    def package(self):
+        cmake = CMake(self)
+        cmake.configure()
+        cmake.install()
+
+    def package_id(self):
+        self.info.header_only()

From d716cf6c8281ab6383d1fbecb456e0b9d808694c Mon Sep 17 00:00:00 2001
From: Alexander Bigerl <bigerl@mail.uni-paderborn.de>
Date: Fri, 17 Jan 2020 14:08:21 +0100
Subject: [PATCH 1798/1866] make the headers available at cppitertools/*

---
 CMakeLists.txt | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 59c84944..3caa4114 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -14,7 +14,7 @@ add_library(cppitertools::cppitertools ALIAS cppitertools)
 
 target_include_directories(cppitertools INTERFACE
         $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
-        $<INSTALL_INTERFACE:${cppitertools_INSTALL_CMAKE_DIR}>
+        $<INSTALL_INTERFACE:${cppitertools_INSTALL_CMAKE_DIR}/cppitertools>
         )
 
 
@@ -34,8 +34,8 @@ install(TARGETS cppitertools EXPORT cppitertools-targets)
 install(EXPORT cppitertools-targets
         FILE cppitertools-config.cmake
         NAMESPACE cppitertools::
-        DESTINATION ${cppitertools_INSTALL_CMAKE_DIR}
+        DESTINATION ${cppitertools_INSTALL_CMAKE_DIR}/cppitertools
         )
 
 install(FILES ${CMAKE_CURRENT_BINARY_DIR}/cppitertools-config-version.cmake DESTINATION ${cppitertools_INSTALL_CMAKE_DIR})
-install(DIRECTORY . DESTINATION ${cppitertools_INSTALL_INCLUDE_DIR})
+install(DIRECTORY . DESTINATION ${cppitertools_INSTALL_INCLUDE_DIR}/cppitertools)

From 2547739b3ca1c1f08071b4c85df57f160df1f111 Mon Sep 17 00:00:00 2001
From: Alexander Bigerl <bigerl@mail.uni-paderborn.de>
Date: Fri, 17 Jan 2020 14:24:46 +0100
Subject: [PATCH 1799/1866] updated conan meta data

---
 conanfile.py | 18 +++++++++++-------
 1 file changed, 11 insertions(+), 7 deletions(-)

diff --git a/conanfile.py b/conanfile.py
index 4427b7a8..b47cbab4 100644
--- a/conanfile.py
+++ b/conanfile.py
@@ -3,23 +3,27 @@
 import os
 
 
-class Tentris_Parser(ConanFile):
+class CppIterTools(ConanFile):
     name = "cppitertools"
-    version = "1.0"
-    author = "Ryan Haining"
-    description = "Implementation of python itertools and builtin iteration functions for C++17 "
-    topics = ("please add topics here")
+    version = "2.0"
+    author = "Ryan Haining <haining.cpp@gmail.com>"
+    homepage = "https://github.com/ryanhaining/cppitertools"
+    url = homepage
+    topics = ("conan", "itertools", "cppitertools")
+    license = 'BSD 2-Clause "Simplified" License'
+    description = "Range-based for loop add-ons inspired by the Python builtins and itertools library. " \
+                  "Like itertools and the Python3 builtins, this library uses lazy evaluation wherever possible."
     settings = "build_type", "compiler", "os", "arch"
     generators = "cmake", "cmake_find_package", "cmake_paths"
+    exports = "LICENSE.md"
 
     exports_sources = list()
     for file in os.listdir("."):
         if file.endswith(".hpp"):
             exports_sources.append(str(file))
     print("found files: " + str(exports_sources))
-
     exports_sources = tuple(exports_sources) + \
-                      ("internal/*", "CMakeLists.txt", "cmake/dummy-config.cmake.in", "LICENSE.md")
+                      ("internal/*", "CMakeLists.txt", "cmake/dummy-config.cmake.in")
     no_copy_source = True
 
     def package(self):

From d245e3be3504a00acfe71fbbf153338519ea448c Mon Sep 17 00:00:00 2001
From: Nicole Mazzuca <nicole@strega-nil.co>
Date: Mon, 20 Apr 2020 16:42:03 -0700
Subject: [PATCH 1800/1866] Fix CMakeLists.txt install paths

The old code defaulted the cmake config install paths to
  share/cppitertools/cmake/cppitertools
whereas CMake expects the config install directory to be one of
(simplifying):
  share/cmake/cppitertools
  share/cppitertools
  share/cppitertools/cmake

Unfortunately, the existing code chose to put `cppitertools` at the end
of the install path unconditionally, and so we're left with either
`share/cppitertools`, or `share/cmake/cppitertools` as options.
Since other projects seemed to choose `share/${PROJECT_NAME}`, I figured
that was a fine option, as long as the default is not broken. Therefore,
this changes the default to
  share/cppitertools

Additionally, the old code didn't unconditionally put `cppitertools` at
the end of the config.version file, and so that was never being picked
up. Since it was unlikely that anyone was depending on the
config.version file being installed in the wrong location, we now
install it at the same place as the config file.
---
 CMakeLists.txt | 52 +++++++++++++++++++++++++++++++++-----------------
 1 file changed, 35 insertions(+), 17 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 3caa4114..2bd4bc31 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,22 +1,34 @@
 cmake_minimum_required(VERSION 3.12)
 project(cppitertools VERSION 2.0)
-set(CMAKE_CXX_STANDARD 17)
 
+if(NOT DEFINED ENV{cppitertools_INSTALL_CMAKE_DIR})
+  message(WARNING [[
+The default value of cppitertools_INSTALL_CMAKE_DIR changed recently, from
+  "share/cppitertools/cmake"
+to
+  "share"
+in order to behave better with existing CMake practice.
+
+In order to get the previous behavior, pass
+  -Dcppitertools_INSTALL_CMAKE_DIR=share/cppitertools/cmake
+to the CMake invocation; in order to get the new behavior without the warning,
+pass
+  -Dcppitertools_INSTALL_CMAKE_DIR=share
+explicitly.
+]])
+endif()
 
 # installation directories
 set(cppitertools_INSTALL_INCLUDE_DIR "include" CACHE STRING "The installation include directory")
-set(cppitertools_INSTALL_CMAKE_DIR "share/cppitertools/cmake" CACHE STRING "The installation cmake directory")
-
+set(cppitertools_INSTALL_CMAKE_DIR "share" CACHE STRING "The installation cmake directory")
 
 # define a header-only library
 add_library(cppitertools INTERFACE)
 add_library(cppitertools::cppitertools ALIAS cppitertools)
 
 target_include_directories(cppitertools INTERFACE
-        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
-        $<INSTALL_INTERFACE:${cppitertools_INSTALL_CMAKE_DIR}/cppitertools>
-        )
-
+  $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
+  $<INSTALL_INTERFACE:${cppitertools_INSTALL_INCLUDE_DIR}/cppitertools>)
 
 # require C++17
 target_compile_features(cppitertools INTERFACE cxx_std_17)
@@ -29,13 +41,19 @@ include(CMakePackageConfigHelpers)
 write_basic_package_version_file(cppitertools-config-version.cmake COMPATIBILITY SameMajorVersion)
 
 # install and export target
-install(TARGETS cppitertools EXPORT cppitertools-targets)
-
-install(EXPORT cppitertools-targets
-        FILE cppitertools-config.cmake
-        NAMESPACE cppitertools::
-        DESTINATION ${cppitertools_INSTALL_CMAKE_DIR}/cppitertools
-        )
-
-install(FILES ${CMAKE_CURRENT_BINARY_DIR}/cppitertools-config-version.cmake DESTINATION ${cppitertools_INSTALL_CMAKE_DIR})
-install(DIRECTORY . DESTINATION ${cppitertools_INSTALL_INCLUDE_DIR}/cppitertools)
+install(
+  TARGETS cppitertools
+  EXPORT cppitertools-targets)
+
+install(
+  DIRECTORY .
+  DESTINATION ${cppitertools_INSTALL_INCLUDE_DIR}/cppitertools)
+
+install(
+  EXPORT cppitertools-targets
+  FILE cppitertools-config.cmake
+  NAMESPACE cppitertools::
+  DESTINATION ${cppitertools_INSTALL_CMAKE_DIR}/cppitertools)
+install(
+  FILES ${CMAKE_CURRENT_BINARY_DIR}/cppitertools-config-version.cmake
+  DESTINATION ${cppitertools_INSTALL_CMAKE_DIR}/cppitertools)

From dc63b373020289012756b37f203d5cc75e355b2f Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Wed, 8 Sep 2021 20:34:14 -0700
Subject: [PATCH 1801/1866] Replaces class with struct on tuple_(size|element)

-Wmismatched-tags warns because the standard tuple_size and
tuple_element are declared as struct.

Fixes #82
---
 enumerate.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/enumerate.hpp b/enumerate.hpp
index 6580b783..e2dda12b 100644
--- a/enumerate.hpp
+++ b/enumerate.hpp
@@ -38,11 +38,11 @@ namespace iter {
 
 namespace std {
   template <typename Index, typename Elem>
-  class tuple_size<iter::impl::EnumIterYield<Index, Elem>>
+  struct tuple_size<iter::impl::EnumIterYield<Index, Elem>>
       : public tuple_size<iter::impl::EnumBasePair<Index, Elem>> {};
 
   template <std::size_t N, typename Index, typename Elem>
-  class tuple_element<N, iter::impl::EnumIterYield<Index, Elem>>
+  struct tuple_element<N, iter::impl::EnumIterYield<Index, Elem>>
       : public tuple_element<N, iter::impl::EnumBasePair<Index, Elem>> {};
 }
 

From d4611ebd9664df7d92be4407d7c1c4675cd1ecd6 Mon Sep 17 00:00:00 2001
From: Patrick Fasano <patrick@patrickfasano.com>
Date: Thu, 9 Sep 2021 04:08:30 -0400
Subject: [PATCH 1802/1866] cmake: Fix warning about
 cppitertools_INSTALL_CMAKE_DIR

Fixes #76.
---
 CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 2bd4bc31..f4f7eaeb 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 3.12)
 project(cppitertools VERSION 2.0)
 
-if(NOT DEFINED ENV{cppitertools_INSTALL_CMAKE_DIR})
+if(NOT DEFINED CACHE{cppitertools_INSTALL_CMAKE_DIR})
   message(WARNING [[
 The default value of cppitertools_INSTALL_CMAKE_DIR changed recently, from
   "share/cppitertools/cmake"

From b338df3a17276f1458236a2715a7f2cd2cae9619 Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Tue, 29 Mar 2022 11:18:49 -0700
Subject: [PATCH 1803/1866] Adds rbegin() and rend() to repeat

Fixes #86
---
 repeat.hpp           |  8 ++++++++
 test/test_mixed.cpp  | 10 ++++++++++
 test/test_repeat.cpp |  7 +++++++
 3 files changed, 25 insertions(+)

diff --git a/repeat.hpp b/repeat.hpp
index 01739c6c..7167c388 100644
--- a/repeat.hpp
+++ b/repeat.hpp
@@ -83,6 +83,14 @@ class iter::impl::RepeaterWithCount {
   constexpr Iterator end() const {
     return {&this->elem_, 0};
   }
+
+  constexpr Iterator rbegin() const {
+    return begin();
+  }
+
+  constexpr Iterator rend() const {
+    return end();
+  }
 };
 
 template <typename T>
diff --git a/test/test_mixed.cpp b/test/test_mixed.cpp
index e9b92d34..e6b58bab 100644
--- a/test/test_mixed.cpp
+++ b/test/test_mixed.cpp
@@ -256,3 +256,13 @@ TEST_CASE(
 
   REQUIRE(v == vc);
 }
+
+TEST_CASE("reversed(repeat())", "[repeat][reversed]") {
+  using iter::reversed;
+  using iter::repeat;
+
+  auto rr = reversed(repeat('x', 5));
+  std::string s(rr.begin(), rr.end());
+
+  REQUIRE(s == "xxxxx");
+}
diff --git a/test/test_repeat.cpp b/test/test_repeat.cpp
index 0fc62e72..c972c4c2 100644
--- a/test/test_repeat.cpp
+++ b/test/test_repeat.cpp
@@ -56,6 +56,7 @@ TEST_CASE("repeat: iterators compare to const iterators", "[repeat]") {
   (void)(std::begin(r) == std::end(cr));
 }
 
+
 TEST_CASE("repeat: two argument repeats a number of times", "[repeat]") {
   auto r = repeat('a', 3);
   std::string s(std::begin(r), std::end(r));
@@ -86,6 +87,12 @@ TEST_CASE("repeat: iterator meets requirements", "[repeat]") {
   REQUIRE(itertest::IsIterator<decltype(std::begin(r))>::value);
 }
 
+TEST_CASE("repeat: is reversible", "[repeat]") {
+  auto r = repeat('b', 4);
+  std::string s(std::rbegin(r), std::rend(r));
+  REQUIRE(s == "bbbb");
+}
+
 template <typename T>
 using ImpT = decltype(repeat(std::declval<T>()));
 

From fda93ac505bb29404f6704e2d616ec2cbc101395 Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Tue, 29 Mar 2022 22:15:12 -0700
Subject: [PATCH 1804/1866] Adds rbegin() and rend() to two-argument repeat

Fixes #86
---
 repeat.hpp           | 10 +++++++++-
 test/test_mixed.cpp  | 21 +++++++++++++++------
 test/test_repeat.cpp | 19 +++++++++++++------
 3 files changed, 37 insertions(+), 13 deletions(-)

diff --git a/repeat.hpp b/repeat.hpp
index 7167c388..327c21b0 100644
--- a/repeat.hpp
+++ b/repeat.hpp
@@ -139,7 +139,7 @@ class iter::impl::Repeater {
       return *this;
     }
 
-    constexpr Iterator operator++(int)const {
+    constexpr Iterator operator++(int) const {
       return *this;
     }
 
@@ -167,6 +167,14 @@ class iter::impl::Repeater {
   constexpr Iterator end() const {
     return {nullptr};
   }
+
+  constexpr Iterator rbegin() const {
+    return begin();
+  }
+
+  constexpr Iterator rend() const {
+    return end();
+  }
 };
 
 template <typename T>
diff --git a/test/test_mixed.cpp b/test/test_mixed.cpp
index e6b58bab..9c4c3ed6 100644
--- a/test/test_mixed.cpp
+++ b/test/test_mixed.cpp
@@ -1,12 +1,11 @@
 // mixing different itertools, there is nothing called iter::mixed()
 
-#include "itertools.hpp"
-
-#include "catch.hpp"
-
 #include <iostream>
 #include <vector>
 
+#include "catch.hpp"
+#include "itertools.hpp"
+
 class MyUnMovable {
   int val;
 
@@ -257,12 +256,22 @@ TEST_CASE(
   REQUIRE(v == vc);
 }
 
-TEST_CASE("reversed(repeat())", "[repeat][reversed]") {
-  using iter::reversed;
+TEST_CASE("reversed(repeat(v, n))", "[repeat][reversed]") {
   using iter::repeat;
+  using iter::reversed;
 
   auto rr = reversed(repeat('x', 5));
   std::string s(rr.begin(), rr.end());
 
   REQUIRE(s == "xxxxx");
 }
+
+TEST_CASE("reversed(repeat(v))", "[repeat][reversed]") {
+  using iter::repeat;
+  using iter::reversed;
+
+  auto rr = reversed(repeat('x'));
+  auto it = rr.begin();
+
+  REQUIRE(*it == 'x');
+}
diff --git a/test/test_repeat.cpp b/test/test_repeat.cpp
index c972c4c2..ab92cbc1 100644
--- a/test/test_repeat.cpp
+++ b/test/test_repeat.cpp
@@ -1,12 +1,10 @@
-#include <repeat.hpp>
-
-#include "helpers.hpp"
-
 #include <iterator>
+#include <repeat.hpp>
 #include <string>
 #include <vector>
 
 #include "catch.hpp"
+#include "helpers.hpp"
 
 using iter::repeat;
 
@@ -56,7 +54,6 @@ TEST_CASE("repeat: iterators compare to const iterators", "[repeat]") {
   (void)(std::begin(r) == std::end(cr));
 }
 
-
 TEST_CASE("repeat: two argument repeats a number of times", "[repeat]") {
   auto r = repeat('a', 3);
   std::string s(std::begin(r), std::end(r));
@@ -87,7 +84,17 @@ TEST_CASE("repeat: iterator meets requirements", "[repeat]") {
   REQUIRE(itertest::IsIterator<decltype(std::begin(r))>::value);
 }
 
-TEST_CASE("repeat: is reversible", "[repeat]") {
+TEST_CASE("repeat: one-argument is reversible", "[repeat]") {
+  auto r = repeat('c');
+  auto it = std::rbegin(r);
+  (void)(it != std::rend(r));
+
+  REQUIRE(*it == 'c');
+  ++it;
+  REQUIRE(*it == 'c');
+}
+
+TEST_CASE("repeat: two-argument is reversible", "[repeat]") {
   auto r = repeat('b', 4);
   std::string s(std::rbegin(r), std::rend(r));
   REQUIRE(s == "bbbb");

From affe89e17d8121e3c26391b7e8a63de0e8e4a78d Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 19 Jul 2022 09:51:47 -0700
Subject: [PATCH 1805/1866] Removes note on (discouraged) .index and .element
 in enumerate

---
 README.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index a7f6e5ca..107ca507 100644
--- a/README.md
+++ b/README.md
@@ -262,7 +262,8 @@ enumerate
 ---------
 
 Continually "yields" containers similar to pairs.  They are basic structs with a
-.index and a .element, and also work with structured binding declarations.
+an index in .first, and the element in .second, and also work with structured 
+binding declarations.
 Usage appears as:
 
 ```c++

From c703a135d6bec700a5e687b60e834d05f0915894 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Tue, 19 Jul 2022 09:52:57 -0700
Subject: [PATCH 1806/1866] fixes enumerate typos

---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 107ca507..66f48aae 100644
--- a/README.md
+++ b/README.md
@@ -261,8 +261,8 @@ slower but more accurate.
 enumerate
 ---------
 
-Continually "yields" containers similar to pairs.  They are basic structs with a
-an index in .first, and the element in .second, and also work with structured 
+Continually "yields" containers similar to pairs.  They are structs with
+the index in `.first`, and the element in `.second`, and also work with structured 
 binding declarations.
 Usage appears as:
 

From ad94c5a89a89bff8b2168b03a7d1442e2f768552 Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Wed, 17 Aug 2022 14:08:35 -0700
Subject: [PATCH 1807/1866] Updates starmap ::reference to match *

Updates the Iterator::reference type to match the type of operator*()
---
 starmap.hpp           | 21 +++++++++++------
 test/test_starmap.cpp | 53 +++++++++++++++++++++++++++++++++++++++++--
 2 files changed, 65 insertions(+), 9 deletions(-)

diff --git a/starmap.hpp b/starmap.hpp
index d3fb678b..fbeaad68 100644
--- a/starmap.hpp
+++ b/starmap.hpp
@@ -34,8 +34,10 @@ class iter::impl::StarMapper {
   mutable Func func_;
   Container container_;
 
-  using StarIterDeref = std::remove_reference_t<decltype(
-      std::apply(func_, std::declval<iterator_deref<Container>>()))>;
+  using StarIterDeref =
+      decltype(std::apply(func_, std::declval<iterator_deref<Container>>()));
+  using StarIterDerefValue =
+      std::remove_cv_t<std::remove_reference_t<StarIterDeref>>;
 
   StarMapper(Func f, Container&& c)
       : func_(std::move(f)), container_(std::forward<Container>(c)) {}
@@ -53,10 +55,10 @@ class iter::impl::StarMapper {
 
    public:
     using iterator_category = std::input_iterator_tag;
-    using value_type = StarIterDeref;
+    using value_type = StarIterDerefValue;
     using difference_type = std::ptrdiff_t;
     using pointer = value_type*;
-    using reference = value_type&;
+    using reference = StarIterDeref;
 
     Iterator(Func& f, IteratorWrapper<ContainerT>&& sub_iter)
         : func_(&f), sub_iter_(std::move(sub_iter)) {}
@@ -86,7 +88,7 @@ class iter::impl::StarMapper {
       return std::apply(*func_, *sub_iter_);
     }
 
-    auto operator-> () -> ArrowProxy<decltype(**this)> {
+    auto operator->() -> ArrowProxy<decltype(**this)> {
       return {**this};
     }
   };
@@ -130,7 +132,12 @@ class iter::impl::TupleStarMapper {
   class IteratorData {
    public:
     template <std::size_t Idx>
-    static auto get_and_call_with_tuple(Func& f, TupTypeT& t) -> decltype(std::apply(f, std::get<Idx>(t))) { //TODO: Remove duplicated expression in decltype, using decltype(auto) as return type, when all compilers correctly deduce type (i.e. MSVC cl 19.15 does not do it).
+    static auto get_and_call_with_tuple(Func& f, TupTypeT& t)
+        -> decltype(std::apply(f,
+            std::get<Idx>(t))) {  // TODO: Remove duplicated expression in
+                                  // decltype, using decltype(auto) as return
+                                  // type, when all compilers correctly deduce
+                                  // type (i.e. MSVC cl 19.15 does not do it).
       return std::apply(f, std::get<Idx>(t));
     }
 
@@ -169,7 +176,7 @@ class iter::impl::TupleStarMapper {
       return IteratorData<TupTypeT>::callers[index_](*func_, *tup_);
     }
 
-    auto operator-> () {
+    auto operator->() {
       return ArrowProxy<decltype(**this)>{**this};
     }
 
diff --git a/test/test_starmap.cpp b/test/test_starmap.cpp
index 4c12b7c1..528d5f0f 100644
--- a/test/test_starmap.cpp
+++ b/test/test_starmap.cpp
@@ -1,10 +1,10 @@
 #include <starmap.hpp>
-
 #include "helpers.hpp"
 
 #include <iterator>
 #include <list>
 #include <string>
+#include <type_traits>
 #include <vector>
 
 #include "catch.hpp"
@@ -16,6 +16,18 @@ namespace {
     return d * i;
   }
 
+  int& larger_ref(int& a, int& b) {
+    return a > b ? a : b;
+  }
+
+  const int& larger_const_ref(const int& a, const int& b) {
+    return a > b ? a : b;
+  }
+
+  int larger(int a, int b) {
+    return a > b ? a : b;
+  }
+
   std::string g(const std::string& s, int i, char c) {
     std::stringstream ss;
     ss << s << ' ' << i << ' ' << c;
@@ -74,7 +86,8 @@ TEST_CASE("starmap: works with pointer to member function", "[starmap]") {
 
 TEST_CASE("starmap: vector of pairs const iteration", "[starmap][const]") {
   using Vec = const std::vector<int>;
-  const std::vector<std::pair<double, int>> v1 = {{1.0, 2}, {3.0, 11}, {6.0, 7}};
+  const std::vector<std::pair<double, int>> v1 = {
+      {1.0, 2}, {3.0, 11}, {6.0, 7}};
 
   const auto sm = starmap(Callable{}, v1);
   std::vector<int> v(std::begin(sm), std::end(sm));
@@ -182,3 +195,39 @@ TEST_CASE(
   auto sm = starmap(Callable{}, tup);
   REQUIRE(itertest::IsIterator<decltype(std::begin(sm))>::value);
 }
+
+TEST_CASE("starmap: iterator dereference type matches 'reference' type alias",
+    "[starmap]") {
+  std::vector<std::pair<int, int>> input;
+  SECTION("with reference return type") {
+    auto sm = iter::starmap(larger_ref, input);
+    REQUIRE(
+        std::is_same_v<decltype(*sm.begin()), decltype(sm.begin())::reference>);
+  }
+  SECTION("with const reference return type") {
+    auto sm = iter::starmap(larger_const_ref, input);
+    REQUIRE(
+        std::is_same_v<decltype(*sm.begin()), decltype(sm.begin())::reference>);
+  }
+  SECTION("with value return type") {
+    auto sm = iter::starmap(larger, input);
+    REQUIRE(
+        std::is_same_v<decltype(*sm.begin()), decltype(sm.begin())::reference>);
+  }
+}
+
+TEST_CASE("starmap: iterator has correct 'value' type alias", "[starmap]") {
+  std::vector<std::pair<int, int>> input;
+  SECTION("with reference return type") {
+    auto sm = iter::starmap(larger_ref, input);
+    REQUIRE(std::is_same_v<int, decltype(sm.begin())::value_type>);
+  }
+  SECTION("with const reference return type") {
+    auto sm = iter::starmap(larger_const_ref, input);
+    REQUIRE(std::is_same_v<int, decltype(sm.begin())::value_type>);
+  }
+  SECTION("with value return type") {
+    auto sm = iter::starmap(larger, input);
+    REQUIRE(std::is_same_v<int, decltype(sm.begin())::value_type>);
+  }
+}

From e4fb18534092ae001f4af47b5a3420beba4c4390 Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Thu, 18 Aug 2022 16:23:55 -0700
Subject: [PATCH 1808/1866] Adds test helper for reference correctness

operator* needs to match Iterator::reference
Issue #88
---
 test/helpers.hpp | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/test/helpers.hpp b/test/helpers.hpp
index aa80cd3c..93112519 100644
--- a/test/helpers.hpp
+++ b/test/helpers.hpp
@@ -2,7 +2,6 @@
 #define TEST_HELPER_H_
 
 #include <internal/iterbase.hpp>
-
 #include <iostream>
 #include <sstream>
 #include <stdexcept>
@@ -208,6 +207,10 @@ namespace itertest {
   template <typename, typename = void>
   struct IsIterator : std::false_type {};
 
+  template <typename T>
+  struct ReferenceMatchesDeref
+      : std::is_same<typename T::reference, decltype(*std::declval<T&>())> {};
+
   template <typename T>
   struct IsIterator<T,
       std::void_t<decltype(T(std::declval<const T&>())),            // copyctor
@@ -216,8 +219,8 @@ namespace itertest {
           decltype(std::declval<T&>().operator->()),  // operator->
           decltype(++std::declval<T&>()),             // prefix ++
           decltype(std::declval<T&>()++),             // postfix ++
-          decltype(
-              std::declval<const T&>() != std::declval<const T&>()),      //  !=
+          decltype(std::declval<const T&>()
+                   != std::declval<const T&>()),                          //  !=
           decltype(std::declval<const T&>() == std::declval<const T&>())  //  ==
           >> : std::true_type {};
 

From d70c2b1a7f478ce1d6d6eddfe49ea273c0e34c71 Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Thu, 18 Aug 2022 16:31:40 -0700
Subject: [PATCH 1809/1866] Uses ReferenceMatchesDeref in starmap test

Issue #88
---
 test/test_starmap.cpp | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/test/test_starmap.cpp b/test/test_starmap.cpp
index 528d5f0f..feae8da9 100644
--- a/test/test_starmap.cpp
+++ b/test/test_starmap.cpp
@@ -201,18 +201,15 @@ TEST_CASE("starmap: iterator dereference type matches 'reference' type alias",
   std::vector<std::pair<int, int>> input;
   SECTION("with reference return type") {
     auto sm = iter::starmap(larger_ref, input);
-    REQUIRE(
-        std::is_same_v<decltype(*sm.begin()), decltype(sm.begin())::reference>);
+    REQUIRE(itertest::ReferenceMatchesDeref<decltype(std::begin(sm))>::value);
   }
   SECTION("with const reference return type") {
     auto sm = iter::starmap(larger_const_ref, input);
-    REQUIRE(
-        std::is_same_v<decltype(*sm.begin()), decltype(sm.begin())::reference>);
+    REQUIRE(itertest::ReferenceMatchesDeref<decltype(std::begin(sm))>::value);
   }
   SECTION("with value return type") {
     auto sm = iter::starmap(larger, input);
-    REQUIRE(
-        std::is_same_v<decltype(*sm.begin()), decltype(sm.begin())::reference>);
+    REQUIRE(itertest::ReferenceMatchesDeref<decltype(std::begin(sm))>::value);
   }
 }
 

From 5e8ddb3f13a2f1974a3b01137f68d4e4896a1ede Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Thu, 18 Aug 2022 16:34:45 -0700
Subject: [PATCH 1810/1866] Fixes reference type in accumulate

Issue #88
---
 accumulate.hpp           | 13 +++++++------
 test/test_accumulate.cpp | 23 ++++++++++++++++++-----
 2 files changed, 25 insertions(+), 11 deletions(-)

diff --git a/accumulate.hpp b/accumulate.hpp
index 0d43a20e..94c0c369 100644
--- a/accumulate.hpp
+++ b/accumulate.hpp
@@ -28,8 +28,9 @@ class iter::impl::Accumulator {
 
   friend AccumulateFn;
 
-  using AccumVal = std::remove_reference_t<std::invoke_result_t<AccumulateFunc,
-      iterator_deref<Container>, iterator_deref<Container>>>;
+  using AccumVal = std::remove_cv_t<
+      std::remove_reference_t<std::invoke_result_t<AccumulateFunc,
+          iterator_deref<Container>, iterator_deref<Container>>>>;
 
   Accumulator(Container&& container, AccumulateFunc accumulate_func)
       : container_(std::forward<Container>(container)),
@@ -52,8 +53,8 @@ class iter::impl::Accumulator {
     using iterator_category = std::input_iterator_tag;
     using value_type = AccumVal;
     using difference_type = std::ptrdiff_t;
-    using pointer = value_type*;
-    using reference = value_type&;
+    using pointer = const value_type*;
+    using reference = const value_type&;
 
     Iterator(IteratorWrapper<ContainerT>&& sub_iter,
         IteratorWrapper<ContainerT>&& sub_end, AccumulateFunc& accumulate_fun)
@@ -65,11 +66,11 @@ class iter::impl::Accumulator {
                        ? std::nullopt
                        : std::make_optional<AccumVal>(*sub_iter_)} {}
 
-    const AccumVal& operator*() const {
+    reference operator*() const {
       return *acc_val_;
     }
 
-    const AccumVal* operator->() const {
+    pointer operator->() const {
       return &*acc_val_;
     }
 
diff --git a/test/test_accumulate.cpp b/test/test_accumulate.cpp
index 02467fb2..f91f32b6 100644
--- a/test/test_accumulate.cpp
+++ b/test/test_accumulate.cpp
@@ -131,11 +131,24 @@ TEST_CASE("accumulate: operator->", "[accumulate]") {
 }
 
 TEST_CASE("accumulate: iterator meets requirements", "[accumulate]") {
-  Vec ns{};
-  auto a = accumulate(ns, [](int a, int b) { return a + b; });
-  auto it = std::begin(a);
-  it = std::begin(a);
-  REQUIRE(itertest::IsIterator<decltype(std::begin(a))>::value);
+  std::vector<int> ns{};
+  SECTION("with reference return type") {
+    auto acc = accumulate(ns, [](int& a, int&) -> int& { return a; });
+    REQUIRE(itertest::IsIterator<decltype(std::begin(acc))>::value);
+    REQUIRE(itertest::ReferenceMatchesDeref<decltype(std::begin(acc))>::value);
+  }
+
+  SECTION("with const reference return type") {
+    auto acc = accumulate(ns, [](int& a, int&) -> const int& { return a; });
+    REQUIRE(itertest::IsIterator<decltype(std::begin(acc))>::value);
+    REQUIRE(itertest::ReferenceMatchesDeref<decltype(std::begin(acc))>::value);
+  }
+
+  SECTION("with value return type") {
+    auto acc = accumulate(ns, [](int a, int) -> int { return a; });
+    REQUIRE(itertest::IsIterator<decltype(std::begin(acc))>::value);
+    REQUIRE(itertest::ReferenceMatchesDeref<decltype(std::begin(acc))>::value);
+  }
 }
 
 TEST_CASE(

From 038a4363a1bc8c9af4edc73b0d825256241aa2d8 Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Thu, 18 Aug 2022 16:35:44 -0700
Subject: [PATCH 1811/1866] Fixes reference type in product

Issue #88
---
 product.hpp           | 4 ++--
 test/test_product.cpp | 1 +
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/product.hpp b/product.hpp
index d7bc61e9..7de5727a 100644
--- a/product.hpp
+++ b/product.hpp
@@ -98,7 +98,7 @@ class iter::impl::Productor {
     using value_type = TupleDeref<TupleTypeT>;
     using difference_type = std::ptrdiff_t;
     using pointer = value_type*;
-    using reference = value_type&;
+    using reference = value_type;
 
     IteratorTempl(IteratorTuple<TupleTypeT>&& iters,
         IteratorTuple<TupleTypeT>&& end_iters)
@@ -148,7 +148,7 @@ class iter::impl::Productor {
       return {(*std::get<Is>(iters_))...};
     }
 
-    auto operator-> () -> ArrowProxy<decltype(**this)> {
+    auto operator->() -> ArrowProxy<decltype(**this)> {
       return {**this};
     }
   };
diff --git a/test/test_product.cpp b/test/test_product.cpp
index aa7ed1bb..6a580bc9 100644
--- a/test/test_product.cpp
+++ b/test/test_product.cpp
@@ -221,6 +221,7 @@ TEST_CASE("product: iterator meets requirements", "[product]") {
   std::string s{"abc"};
   auto c = product(s, s);
   REQUIRE(itertest::IsIterator<decltype(std::begin(c))>::value);
+  REQUIRE(itertest::ReferenceMatchesDeref<decltype(std::begin(c))>::value);
 }
 
 template <typename... Ts>

From 86e8a0cdd30a00152ff82633ace8e86386c9cd2c Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Thu, 18 Aug 2022 16:37:26 -0700
Subject: [PATCH 1812/1866] Fixes reference type in zip

Issue #88
---
 test/test_zip.cpp | 2 ++
 zip.hpp           | 4 ++--
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/test/test_zip.cpp b/test/test_zip.cpp
index 7bf8ff96..cb49981c 100644
--- a/test/test_zip.cpp
+++ b/test/test_zip.cpp
@@ -140,8 +140,10 @@ TEST_CASE("zip: iterator meets requirements", "[zip]") {
   std::string s{};
   auto c = zip(s);
   REQUIRE(itertest::IsIterator<decltype(std::begin(c))>::value);
+  REQUIRE(itertest::ReferenceMatchesDeref<decltype(std::begin(c))>::value);
   auto c2 = zip(s, s);
   REQUIRE(itertest::IsIterator<decltype(std::begin(c2))>::value);
+  REQUIRE(itertest::ReferenceMatchesDeref<decltype(std::begin(c2))>::value);
 }
 
 template <typename... Ts>
diff --git a/zip.hpp b/zip.hpp
index abadf45c..98bfd3c4 100644
--- a/zip.hpp
+++ b/zip.hpp
@@ -56,7 +56,7 @@ class iter::impl::Zipped {
     using value_type = TupleDeref<TupleTypeT>;
     using difference_type = std::ptrdiff_t;
     using pointer = value_type*;
-    using reference = value_type&;
+    using reference = value_type;
 
     Iterator(IteratorTuple<TupleTypeT>&& iters) : iters_(std::move(iters)) {}
 
@@ -91,7 +91,7 @@ class iter::impl::Zipped {
       return {(*std::get<Is>(iters_))...};
     }
 
-    auto operator-> () -> ArrowProxy<decltype(**this)> {
+    auto operator->() -> ArrowProxy<decltype(**this)> {
       return {**this};
     }
   };

From cc5f11f9311d8670b50d52ccb08eb1c984f8294c Mon Sep 17 00:00:00 2001
From: ryanhaining <haining.cpp@gmail.com>
Date: Thu, 18 Aug 2022 16:38:21 -0700
Subject: [PATCH 1813/1866] Fixes reference type in slice

Issue #88
---
 slice.hpp           | 13 ++++++-------
 test/test_slice.cpp | 15 ++++++++++++---
 2 files changed, 18 insertions(+), 10 deletions(-)

diff --git a/slice.hpp b/slice.hpp
index 22855645..a926ecbb 100644
--- a/slice.hpp
+++ b/slice.hpp
@@ -51,7 +51,7 @@ class iter::impl::Sliced {
     using value_type = iterator_traits_deref<ContainerT>;
     using difference_type = std::ptrdiff_t;
     using pointer = value_type*;
-    using reference = value_type&;
+    using reference = iterator_deref<ContainerT>;
 
     Iterator(IteratorWrapper<ContainerT>&& sub_iter,
         IteratorWrapper<ContainerT>&& sub_end, DifferenceType start,
@@ -131,10 +131,9 @@ struct iter::impl::SliceFn {
 
    private:
     friend SliceFn;
-    constexpr FnPartial(DifferenceType start, DifferenceType stop,
-        DifferenceType step) noexcept : start_{start},
-                                        stop_{stop},
-                                        step_{step} {}
+    constexpr FnPartial(
+        DifferenceType start, DifferenceType stop, DifferenceType step) noexcept
+        : start_{start}, stop_{stop}, step_{step} {}
     DifferenceType start_;
     DifferenceType stop_;
     DifferenceType step_;
@@ -159,8 +158,8 @@ struct iter::impl::SliceFn {
 
   template <typename DifferenceType,
       typename = std::enable_if_t<!is_iterable<DifferenceType>>>
-  constexpr FnPartial<DifferenceType> operator()(DifferenceType stop) const
-      noexcept {
+  constexpr FnPartial<DifferenceType> operator()(
+      DifferenceType stop) const noexcept {
     return {0, stop, 1};
   }
 
diff --git a/test/test_slice.cpp b/test/test_slice.cpp
index 38386b73..5fae78f4 100644
--- a/test/test_slice.cpp
+++ b/test/test_slice.cpp
@@ -148,9 +148,18 @@ TEST_CASE("slice: with iterable doesn't move or copy elems", "[slice]") {
 }
 
 TEST_CASE("slice: iterator meets requirements", "[slice]") {
-  std::string s{"abcdef"};
-  auto c = slice(s, 1, 3);
-  REQUIRE(itertest::IsIterator<decltype(std::begin(c))>::value);
+  SECTION("with iterable yielding references") {
+    std::string s{"abcdef"};
+    auto c = slice(s, 1, 3);
+    REQUIRE(itertest::IsIterator<decltype(std::begin(c))>::value);
+    REQUIRE(itertest::ReferenceMatchesDeref<decltype(std::begin(c))>::value);
+  }
+  SECTION("with iterable yielding values") {
+    itertest::InputIterable it{};
+    auto c = slice(it, 1, 3);
+    REQUIRE(itertest::IsIterator<decltype(std::begin(c))>::value);
+    REQUIRE(itertest::ReferenceMatchesDeref<decltype(std::begin(c))>::value);
+  }
 }
 
 template <typename T>

From 6f7a3d042da474126f519fd4e70d0db06e28a82c Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 26 Dec 2022 18:30:02 -0800
Subject: [PATCH 1814/1866] Updates catch.hpp version

---
 test/download_catch.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/download_catch.sh b/test/download_catch.sh
index 487e1233..4f1ed06b 100755
--- a/test/download_catch.sh
+++ b/test/download_catch.sh
@@ -1,2 +1,2 @@
 #!/usr/bin/env sh
-wget -c https://github.com/catchorg/Catch2/releases/download/v2.6.0/catch.hpp
+wget -c https://github.com/catchorg/Catch2/releases/download/v2.13.10/catch.hpp

From 09e472243bdaf81c11ebeb9806092037c35253f1 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 26 Dec 2022 18:36:21 -0800
Subject: [PATCH 1815/1866] Adds unique_everseen taking hash and eq functions

Fixes #90
---
 test/test_unique_everseen.cpp | 30 ++++++++++++++++++++++++++++++
 unique_everseen.hpp           | 32 ++++++++++++++++++++++++++------
 2 files changed, 56 insertions(+), 6 deletions(-)

diff --git a/test/test_unique_everseen.cpp b/test/test_unique_everseen.cpp
index d70de075..68cb319a 100644
--- a/test/test_unique_everseen.cpp
+++ b/test/test_unique_everseen.cpp
@@ -85,3 +85,33 @@ TEST_CASE(
   REQUIRE(itertest::IsMoveConstructibleOnly<ImpT<std::string&>>::value);
   REQUIRE(itertest::IsMoveConstructibleOnly<ImpT<std::string>>::value);
 }
+
+struct IntWrapper {
+  int n;
+};
+
+struct IntWrapperHash {
+  int operator()(const IntWrapper& iw) const {
+    return iw.n % 10;
+  }
+};
+
+struct IntWrapperEq {
+  int operator()(const IntWrapper& lhs, const IntWrapper& rhs) const {
+    return lhs.n == rhs.n;
+  }
+};
+
+TEST_CASE("unique_everseen: works with custom hash and equality functions",
+    "[unique_everseen]") {
+  std::vector<IntWrapper> iwv = {
+      {2}, {3}, {4}, {2}, {10}, {2}, {2}, {12}, {10}};
+  Vec vc{2, 3, 4, 10, 12};
+
+  std::vector<int> v;
+  for (auto&& iw : unique_everseen(iwv, IntWrapperHash{}, IntWrapperEq{})) {
+    v.push_back(iw.n);
+  }
+
+  REQUIRE(v == vc);
+}
diff --git a/unique_everseen.hpp b/unique_everseen.hpp
index 35322ca8..1e138d63 100644
--- a/unique_everseen.hpp
+++ b/unique_everseen.hpp
@@ -13,15 +13,35 @@
 namespace iter {
   namespace impl {
     struct UniqueEverseenFn : Pipeable<UniqueEverseenFn> {
+     private:
       template <typename Container>
-      auto operator()(Container&& container) const {
-        using elem_type = impl::iterator_deref<Container>;
-        auto func = [elem_seen = std::unordered_set<std::decay_t<elem_type>>()](
-            const std::remove_reference_t<elem_type>& e) mutable {
-          return elem_seen.insert(e).second;
-        };
+      using Key = std::decay_t<iterator_deref<Container>>;
+
+     public:
+      template <typename Container, typename Hash, typename KeyEqual>
+      auto operator()(Container&& container, const Hash& hash,
+          const KeyEqual& key_equal) const {
+        // You can't pass a hash function or an equality function without
+        // passing a bucket_count as well. We get the default bucket count here
+        // the first time this function runs.
+        static auto default_bucket_count =
+            std::unordered_set<char>{}.bucket_count();
+        using elem_type = iterator_deref<Container>;
+        auto func =
+            [elem_seen =
+                    std::unordered_set<std::decay_t<elem_type>, Hash, KeyEqual>(
+                        default_bucket_count, hash, key_equal)](
+                const std::remove_reference_t<elem_type>& e) mutable {
+              return elem_seen.insert(e).second;
+            };
         return filter(func, std::forward<Container>(container));
       }
+
+      template <typename Container>
+      auto operator()(Container&& container) const {
+        return (*this)(std::forward<Container>(container),
+            std::hash<Key<Container>>{}, std::equal_to<Key<Container>>{});
+      }
     };
   }
 

From a788a37bcf4a1f996181e7639efbf506484c0d1e Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 26 Dec 2022 18:52:12 -0800
Subject: [PATCH 1816/1866] Describes unique_everseen with hash and eq
 functions

Issue #90
---
 README.md | 16 ++++++++++++++--
 1 file changed, 14 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 66f48aae..c405d760 100644
--- a/README.md
+++ b/README.md
@@ -187,7 +187,7 @@ would expect them to behave:
 - sorted
 - starmap
 - takewhile
-- unique\_everseen
+- unique\_everseen (\*only without custom hash and equality callables)
 - unique\_justseen
 
 I don't personally care for the piping style, but it seemed to be desired by
@@ -323,7 +323,7 @@ unique\_everseen
 *Additional Requirements*: Underlying values must be copy-constructible.
 
 This is a filter adaptor that only generates values that have never been seen
-before. For this to work your object must be specialized for `std::hash`.
+before.
 
 Prints `1 2 3 4 5 6 7 8 9`
 ```c++
@@ -333,6 +333,18 @@ for (auto&& i : unique_everseen(v)) {
 }
 ```
 
+`unique_everseen` uses an `undordered_set` so it needs hashable elements. For
+types that don't work with `std::hash` or `std::equal_to`, `unique_everseen`
+also provides an overload taking a hash callable and an equality callable.
+This **does not** work with the pipe syntax.
+
+```c++
+vector<Widget> v { /* ... */ };
+for (auto&& w : unique_everseen(v, WidgetHash{}, WidgetEq{})) {
+  cout << w.name() << ' ';
+}
+```
+
 unique\_justseen
 --------------
 Another filter adaptor that only omits consecutive duplicates.

From 57e5494a22a06757059f8d6b12f41d80abe778b3 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 30 Dec 2022 10:34:21 -0800
Subject: [PATCH 1817/1866] Moves Identity function from groupby to iterbase.

Issue #90
---
 groupby.hpp           | 7 -------
 internal/iterbase.hpp | 7 +++++++
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/groupby.hpp b/groupby.hpp
index 4f2fffb5..cac82426 100644
--- a/groupby.hpp
+++ b/groupby.hpp
@@ -18,13 +18,6 @@ namespace iter {
     template <typename Container, typename KeyFunc>
     class GroupProducer;
 
-    struct Identity {
-      template <typename T>
-      const T& operator()(const T& t) const {
-        return t;
-      }
-    };
-
     using GroupByFn = IterToolFnOptionalBindSecond<GroupProducer, Identity>;
   }
   constexpr impl::GroupByFn groupby{};
diff --git a/internal/iterbase.hpp b/internal/iterbase.hpp
index 57cc1b78..69db7599 100644
--- a/internal/iterbase.hpp
+++ b/internal/iterbase.hpp
@@ -129,6 +129,13 @@ namespace iter {
     template <typename T>
     constexpr bool is_iterable = IsIterable<T>::value;
 
+    struct Identity {
+      template <typename T>
+      const T& operator()(const T& t) const {
+        return t;
+      }
+    };
+
     namespace detail {
       template <typename T, typename = void>
       struct ArrowHelper {

From 22be440497442098015cab4d5403628df2e7e8fa Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 30 Dec 2022 10:41:17 -0800
Subject: [PATCH 1818/1866] Adds overload taking KeyFunc for types without ==

Issue #90
---
 test/test_unique_justseen.cpp | 24 ++++++++++++++++++++++++
 unique_justseen.hpp           | 16 ++++++++++++----
 2 files changed, 36 insertions(+), 4 deletions(-)

diff --git a/test/test_unique_justseen.cpp b/test/test_unique_justseen.cpp
index c6671e5f..455ac927 100644
--- a/test/test_unique_justseen.cpp
+++ b/test/test_unique_justseen.cpp
@@ -91,3 +91,27 @@ TEST_CASE(
   REQUIRE(itertest::IsMoveConstructibleOnly<ImpT<std::string&>>::value);
   REQUIRE(itertest::IsMoveConstructibleOnly<ImpT<std::string>>::value);
 }
+
+struct IntWrapper {
+  int n;
+};
+
+struct IntWrapperKey {
+  int operator()(const IntWrapper& iw) const {
+    return iw.n;
+  }
+};
+
+TEST_CASE("unique_justseen: works with key function",
+    "[unique_justseen]") {
+  std::vector<IntWrapper> iwv = {
+      {2}, {3}, {4}, {2}, {10}, {2}, {2}, {12}, {10}};
+  Vec vc{2, 3, 4, 2, 10, 2, 12, 10};
+
+  std::vector<int> v;
+  for (auto&& iw : unique_justseen(iwv, IntWrapperKey{})) {
+    v.push_back(iw.n);
+  }
+
+  REQUIRE(v == vc);
+}
diff --git a/unique_justseen.hpp b/unique_justseen.hpp
index 2d63b7ea..b717392f 100644
--- a/unique_justseen.hpp
+++ b/unique_justseen.hpp
@@ -10,12 +10,20 @@
 namespace iter {
   namespace impl {
     struct UniqueJustseenFn : Pipeable<UniqueJustseenFn> {
+     public:
+      template <typename Container, typename KeyFunc>
+      auto operator()(Container&& container, KeyFunc key_fn) const {
+        // decltype(auto) return type in lambda so reference types are preserved
+        return imap(
+            [](auto&& group) -> decltype(auto) {
+              return *get_begin(group.second);
+            },
+            groupby(std::forward<Container>(container), key_fn));
+      }
+
       template <typename Container>
       auto operator()(Container&& container) const {
-        // decltype(auto) return type in lambda so reference types are preserved
-        return imap([](auto&& group) -> decltype(
-                        auto) { return *get_begin(group.second); },
-            groupby(std::forward<Container>(container)));
+        return (*this)(std::forward<Container>(container), Identity{});
       }
     };
   }

From 2584f419309e785290036666036e34e73c64690f Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 30 Dec 2022 11:27:32 -0800
Subject: [PATCH 1819/1866] Adds PipeableAndBindOptionalSecond

---
 internal/iterbase.hpp | 35 +++++++++++++++++++++++++++++++++--
 1 file changed, 33 insertions(+), 2 deletions(-)

diff --git a/internal/iterbase.hpp b/internal/iterbase.hpp
index 69db7599..6f654828 100644
--- a/internal/iterbase.hpp
+++ b/internal/iterbase.hpp
@@ -95,8 +95,8 @@ namespace iter {
 
     // iterator_type<C> is the type of C's iterator
     template <typename Container>
-    using const_iterator_type = decltype(
-        get_begin(std::declval<const std::remove_reference_t<Container>&>()));
+    using const_iterator_type = decltype(get_begin(
+        std::declval<const std::remove_reference_t<Container>&>()));
 
     // iterator_deref<C> is the type obtained by dereferencing an iterator
     // to an object of type C
@@ -391,6 +391,37 @@ namespace iter {
       }
     };
 
+    // Pipeable callable which allows binding of the second argument
+    // f(a, b) is the same as a | f(b)
+    // f(a) with an iterable is the same as f(a, DefaultT{})
+    template <typename F, typename DefaultT>
+    struct PipeableAndBindOptionalSecond : Pipeable<F> {
+     protected:
+      template <typename T>
+      struct FnPartial : Pipeable<FnPartial<T>> {
+        mutable T stored_arg;
+        constexpr FnPartial(T in_t) : stored_arg(in_t) {}
+
+        template <typename Container>
+        auto operator()(Container&& container) const {
+          return F{}(std::forward<Container>(container), stored_arg);
+        }
+      };
+
+     public:
+      template <typename T, typename = std::enable_if_t<!is_iterable<T>>>
+      FnPartial<std::decay_t<T>> operator()(T&& t) const {
+        return {std::forward<T>(t)};
+      }
+
+      template <typename Container,
+          typename = std::enable_if_t<is_iterable<Container>>>
+      auto operator()(Container&& container) const {
+        return static_cast<const F&>(*this)(
+            std::forward<Container>(container), DefaultT{});
+      }
+    };
+
     // This is a complicated class to generate a callable that can work:
     //  (1) with just a single (iterable) passed, and DefaultT substituted
     //  (2) with an iterable and a callable

From 06cc4fe4479b8e51a1bd08115ca370cbee5771ff Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 30 Dec 2022 11:28:03 -0800
Subject: [PATCH 1820/1866] Updates unique_justseen overload to be pipeable

Issue #90
---
 test/test_unique_justseen.cpp | 11 +++++++++--
 unique_justseen.hpp           |  8 ++------
 2 files changed, 11 insertions(+), 8 deletions(-)

diff --git a/test/test_unique_justseen.cpp b/test/test_unique_justseen.cpp
index 455ac927..72af19b8 100644
--- a/test/test_unique_justseen.cpp
+++ b/test/test_unique_justseen.cpp
@@ -109,8 +109,15 @@ TEST_CASE("unique_justseen: works with key function",
   Vec vc{2, 3, 4, 2, 10, 2, 12, 10};
 
   std::vector<int> v;
-  for (auto&& iw : unique_justseen(iwv, IntWrapperKey{})) {
-    v.push_back(iw.n);
+  SECTION("Normal call") {
+    for (auto&& iw : unique_justseen(iwv, IntWrapperKey{})) {
+      v.push_back(iw.n);
+    }
+  }
+  SECTION("Pipe") {
+    for (auto&& iw : iwv | unique_justseen(IntWrapperKey{})) {
+      v.push_back(iw.n);
+    }
   }
 
   REQUIRE(v == vc);
diff --git a/unique_justseen.hpp b/unique_justseen.hpp
index b717392f..5a566e78 100644
--- a/unique_justseen.hpp
+++ b/unique_justseen.hpp
@@ -9,8 +9,9 @@
 
 namespace iter {
   namespace impl {
-    struct UniqueJustseenFn : Pipeable<UniqueJustseenFn> {
+    struct UniqueJustseenFn : PipeableAndBindOptionalSecond<UniqueJustseenFn, Identity> {
      public:
+      using PipeableAndBindOptionalSecond<UniqueJustseenFn, Identity>::operator();
       template <typename Container, typename KeyFunc>
       auto operator()(Container&& container, KeyFunc key_fn) const {
         // decltype(auto) return type in lambda so reference types are preserved
@@ -20,11 +21,6 @@ namespace iter {
             },
             groupby(std::forward<Container>(container), key_fn));
       }
-
-      template <typename Container>
-      auto operator()(Container&& container) const {
-        return (*this)(std::forward<Container>(container), Identity{});
-      }
     };
   }
   constexpr impl::UniqueJustseenFn unique_justseen{};

From 8a8b6d0f12e9b5a1fe505820ba81d787b8c610c5 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 30 Dec 2022 11:32:33 -0800
Subject: [PATCH 1821/1866] Adds unique_justseen with key to README

Issue #90
---
 README.md | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/README.md b/README.md
index c405d760..c9d99d3a 100644
--- a/README.md
+++ b/README.md
@@ -358,6 +358,15 @@ for (auto&& i : unique_justseen(v)) {
 }
 ```
 
+If elements cannot be directly compared with equality, you can pass in a key
+callable.
+```c++
+vector<Person> v { /* ... */ };
+for (auto&& p : unique_justseen(v, [] (const Person& p) { return p.name; }))
+  cout << p.name() << ' ' << p.age() << '\n';
+}
+```
+
 takewhile
 ---------
 Yields elements from an iterable until the first element that is false under

From add5acc932dea2c78acd80747bab71ec0b5bce27 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 30 Dec 2022 11:39:31 -0800
Subject: [PATCH 1822/1866] Switches flag from c++1z to c++17

---
 examples/SConstruct | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/SConstruct b/examples/SConstruct
index 5f9110c9..cb5c373c 100644
--- a/examples/SConstruct
+++ b/examples/SConstruct
@@ -3,7 +3,7 @@ import os
 env = Environment(
     ENV=os.environ,
     CXXFLAGS= ['-g', '-Wall', '-Wextra',
-               '-pedantic', '-std=c++1z',
+               '-pedantic', '-std=c++17',
                '-I/usr/local/include'
     ],
     CPPPATH='..',

From eecaaf71ee2103f2afef0567bc22ce1502cc1f0a Mon Sep 17 00:00:00 2001
From: Pedro Kaj Kjellerup Nacht <pnacht@google.com>
Date: Tue, 6 Jun 2023 14:20:58 +0000
Subject: [PATCH 1823/1866] Add security policy

Signed-off-by: Pedro Kaj Kjellerup Nacht <pnacht@google.com>
---
 SECURITY.md | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 SECURITY.md

diff --git a/SECURITY.md b/SECURITY.md
new file mode 100644
index 00000000..201281d4
--- /dev/null
+++ b/SECURITY.md
@@ -0,0 +1,19 @@
+# Security Policy
+
+If you have discovered a security vulnerability in this project, please report it
+privately. **Do not disclose it as a public issue.** This gives me time to work with you
+to fix the issue before public exposure, reducing the chance that the exploit will be
+used before a patch is released.
+
+You may submit the report in the following ways:
+
+- send an email to haining.cpp@gmail.com; and/or
+- send me a [private vulnerability report](https://github.com/ryanhaining/cppitertools/security/advisories/new)
+
+Please provide the following information in your report:
+
+- A description of the vulnerability and its impact
+- How to reproduce the issue
+
+This project is maintained by a single maintainer on a reasonable-effort basis. As such,
+I ask that you give me 90 days to work on a fix before public exposure.

From 492c15aab96f4ca3938a6b734d6a08cb7feea75a Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 3 Jul 2023 20:37:50 -0700
Subject: [PATCH 1824/1866] Update travis-ci link

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index c9d99d3a..64c1430f 100644
--- a/README.md
+++ b/README.md
@@ -13,7 +13,7 @@ Follow [@cppitertools](https://twitter.com/cppitertools) for updates.
 #### Build and Test Status
 Status | Compilers
 ---- | ----
-[![Travis Build Status](https://travis-ci.com/ryanhaining/cppitertools.svg?branch=master)](https://travis-ci.com/ryanhaining/cppitertools) | gcc-7 gcc-8 gcc-9 clang-5.0 clang-6.0 clang-7 clang-8 clang-9
+[![Travis Build Status](https://travis-ci.com/ryanhaining/cppitertools.svg?branch=master)](https://app.travis-ci.com/github/ryanhaining/cppitertools) | gcc-7 gcc-8 gcc-9 clang-5.0 clang-6.0 clang-7 clang-8 clang-9
 [![Appveyor Build Status](https://ci.appveyor.com/api/projects/status/github/ryanhaining/cppitertools?svg=true)](https://ci.appveyor.com/project/ryanhaining/cppitertools) | MSVC 2017 MSVC 2019
 
 #### Table of Contents

From 556fca33235b6ad1fba6e37df104ca23a01a5b45 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Wed, 20 Sep 2023 23:38:56 -0700
Subject: [PATCH 1825/1866] Removes "recently changed" cmake warning

fixes #97
---
 CMakeLists.txt | 17 -----------------
 1 file changed, 17 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index f4f7eaeb..32d26fde 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,23 +1,6 @@
 cmake_minimum_required(VERSION 3.12)
 project(cppitertools VERSION 2.0)
 
-if(NOT DEFINED CACHE{cppitertools_INSTALL_CMAKE_DIR})
-  message(WARNING [[
-The default value of cppitertools_INSTALL_CMAKE_DIR changed recently, from
-  "share/cppitertools/cmake"
-to
-  "share"
-in order to behave better with existing CMake practice.
-
-In order to get the previous behavior, pass
-  -Dcppitertools_INSTALL_CMAKE_DIR=share/cppitertools/cmake
-to the CMake invocation; in order to get the new behavior without the warning,
-pass
-  -Dcppitertools_INSTALL_CMAKE_DIR=share
-explicitly.
-]])
-endif()
-
 # installation directories
 set(cppitertools_INSTALL_INCLUDE_DIR "include" CACHE STRING "The installation include directory")
 set(cppitertools_INSTALL_CMAKE_DIR "share" CACHE STRING "The installation cmake directory")

From 9b2cee49f4ce9725513e9a12d303de9471078e89 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining@google.com>
Date: Tue, 16 Jan 2024 23:53:55 -0800
Subject: [PATCH 1826/1866] Modifies combinations(c, 0) to produce {{}}

Instead of no elements, a sequence of a single empty iterable, to match
python's behavior.

Issue #101
---
 combinations.hpp           | 22 +++++++++++++++++++---
 test/test_combinations.cpp | 28 ++++++++++++++++++++++++----
 2 files changed, 43 insertions(+), 7 deletions(-)

diff --git a/combinations.hpp b/combinations.hpp
index 7572142c..7aca3115 100644
--- a/combinations.hpp
+++ b/combinations.hpp
@@ -73,6 +73,12 @@ class iter::impl::Combinator {
       }
     }
 
+    static Iterator zero_length_end(ContainerT& container) {
+      Iterator it{container, 0};
+      it.steps_ = 0;
+      return it;
+    }
+
     CombIteratorDeref<ContainerT>& operator*() {
       return indices_;
     }
@@ -82,6 +88,11 @@ class iter::impl::Combinator {
     }
 
     Iterator& operator++() {
+      if (indices_.get().empty()) {
+        // zero-length case.
+        ++steps_;
+        return *this;
+      }
       for (auto iter = indices_.get().rbegin(); iter != indices_.get().rend();
            ++iter) {
         ++(*iter);
@@ -94,11 +105,10 @@ class iter::impl::Combinator {
         if (!(dumb_next(*iter, dist) != get_end(*container_p_))) {
           if ((iter + 1) != indices_.get().rend()) {
             size_t inc = 1;
-            for (auto down = iter; ; --down) {
+            for (auto down = iter;; --down) {
               (*down) = dumb_next(*(iter + 1), 1 + inc);
               ++inc;
-              if (down == indices_.get().rbegin())
-                break;
+              if (down == indices_.get().rbegin()) break;
             }
           } else {
             steps_ = COMPLETE;
@@ -138,6 +148,9 @@ class iter::impl::Combinator {
   }
 
   Iterator<Container> end() {
+    if (length_ == 0) {
+      return Iterator<Container>::zero_length_end(container_);
+    }
     return {container_, 0};
   }
 
@@ -146,6 +159,9 @@ class iter::impl::Combinator {
   }
 
   Iterator<AsConst<Container>> end() const {
+    if (length_ == 0) {
+      return Iterator<AsConst<Container>>::zero_length_end(container_);
+    }
     return {std::as_const(container_), 0};
   }
 };
diff --git a/test/test_combinations.cpp b/test/test_combinations.cpp
index f5c153cf..6d9718dc 100644
--- a/test/test_combinations.cpp
+++ b/test/test_combinations.cpp
@@ -5,7 +5,6 @@
 #undef DEFINE_DEFAULT_ITERATOR_CTOR
 
 #include <combinations.hpp>
-
 #include <iterator>
 #include <set>
 #include <string>
@@ -95,10 +94,31 @@ TEST_CASE("combinations: size too large gives no results", "[combinations]") {
   REQUIRE(std::begin(c) == std::end(c));
 }
 
-TEST_CASE("combinations: size 0 gives nothing", "[combinations]") {
+TEST_CASE("combinations: size 0 gives one empty result", "[combinations]") {
   std::string s{"ABCD"};
-  auto c = combinations(s, 0);
-  REQUIRE(std::begin(c) == std::end(c));
+
+  CharCombSet ans = {{}};
+
+  CharCombSet sc;
+  for (auto&& v : combinations(s, 0)) {
+    sc.emplace_back(std::begin(v), std::end(v));
+  }
+
+  REQUIRE(ans == sc);
+}
+
+TEST_CASE("combinations: size 0 gives one empty result for empty input",
+    "[combinations]") {
+  std::string s{};
+
+  CharCombSet ans = {{}};
+
+  CharCombSet sc;
+  for (auto&& v : combinations(s, 0)) {
+    sc.emplace_back(std::begin(v), std::end(v));
+  }
+
+  REQUIRE(ans == sc);
 }
 
 TEST_CASE(

From 60171c0c987f98751f9b06a5e44b3e3733f429bd Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining@google.com>
Date: Tue, 16 Jan 2024 23:56:25 -0800
Subject: [PATCH 1827/1866] Modifies combinations_with_replacement(c, 0) to
 produce {{}}

Issue #101
---
 combinations_with_replacement.hpp           | 22 ++++++++++++++++++---
 test/test_combinations_with_replacement.cpp | 20 ++++++++++++++++---
 2 files changed, 36 insertions(+), 6 deletions(-)

diff --git a/combinations_with_replacement.hpp b/combinations_with_replacement.hpp
index b7e20d7d..d501c6e1 100644
--- a/combinations_with_replacement.hpp
+++ b/combinations_with_replacement.hpp
@@ -60,6 +60,12 @@ class iter::impl::CombinatorWithReplacement {
                      ? 0
                      : COMPLETE} {}
 
+    static Iterator zero_length_end(ContainerT& container) {
+      Iterator it{container, 0};
+      it.steps_ = 0;
+      return it;
+    }
+
     CombIteratorDeref<ContainerT>& operator*() {
       return indices_;
     }
@@ -69,15 +75,19 @@ class iter::impl::CombinatorWithReplacement {
     }
 
     Iterator& operator++() {
+      if (indices_.get().empty()) {
+        // zero-length case.
+        ++steps_;
+        return *this;
+      }
       for (auto iter = indices_.get().rbegin(); iter != indices_.get().rend();
            ++iter) {
         ++(*iter);
         if (!(*iter != get_end(*container_p_))) {
           if ((iter + 1) != indices_.get().rend()) {
-            for (auto down = iter; ; --down) {
+            for (auto down = iter;; --down) {
               (*down) = dumb_next(*(iter + 1));
-              if (down == indices_.get().rbegin())
-                break;
+              if (down == indices_.get().rbegin()) break;
             }
           } else {
             steps_ = COMPLETE;
@@ -117,6 +127,9 @@ class iter::impl::CombinatorWithReplacement {
   }
 
   Iterator<Container> end() {
+    if (length_ == 0) {
+      return Iterator<Container>::zero_length_end(container_);
+    }
     return {container_, 0};
   }
 
@@ -125,6 +138,9 @@ class iter::impl::CombinatorWithReplacement {
   }
 
   Iterator<AsConst<Container>> end() const {
+    if (length_ == 0) {
+      return Iterator<AsConst<Container>>::zero_length_end(container_);
+    }
     return {std::as_const(container_), 0};
   }
 };
diff --git a/test/test_combinations_with_replacement.cpp b/test/test_combinations_with_replacement.cpp
index 61f30120..536780ac 100644
--- a/test/test_combinations_with_replacement.cpp
+++ b/test/test_combinations_with_replacement.cpp
@@ -1,5 +1,4 @@
 #include <combinations_with_replacement.hpp>
-
 #include <iterator>
 #include <set>
 #include <string>
@@ -96,8 +95,23 @@ TEST_CASE("combinations_with_replacement: big size is no problem",
 TEST_CASE("combinations_with_replacement: 0 size is empty",
     "[combinations_with_replacement]") {
   std::string s{"A"};
-  auto cwr = combinations_with_replacement(s, 0);
-  REQUIRE(std::begin(cwr) == std::end(cwr));
+  CharCombSet sc;
+  for (auto v : combinations_with_replacement(s, 0)) {
+    sc.emplace_back(std::begin(v), std::end(v));
+  }
+  CharCombSet ans = {{}};
+  REQUIRE(ans == sc);
+}
+
+TEST_CASE("combinations_with_replacement: 0 size is empty with empty container",
+    "[combinations_with_replacement]") {
+  std::string s{};
+  CharCombSet sc;
+  for (auto v : combinations_with_replacement(s, 0)) {
+    sc.emplace_back(std::begin(v), std::end(v));
+  }
+  CharCombSet ans = {{}};
+  REQUIRE(ans == sc);
 }
 
 TEST_CASE("combinations_with_replacement: operator->",

From d26742747b4ba4e1dff0b078382b00a36676dcba Mon Sep 17 00:00:00 2001
From: Sayan <reach2sayan@gmail.com>
Date: Tue, 16 Apr 2024 20:56:20 -0400
Subject: [PATCH 1828/1866] compare const and non-const chained iterators; all
 tests pass

---
 chain.hpp           | 55 +++++++++++++++++++++++++++++----------------
 test/test_chain.cpp |  9 +++-----
 2 files changed, 39 insertions(+), 25 deletions(-)

diff --git a/chain.hpp b/chain.hpp
index 23d1e054..55338c9d 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -1,10 +1,6 @@
 #ifndef ITER_CHAIN_HPP_
 #define ITER_CHAIN_HPP_
 
-#include "internal/iter_tuples.hpp"
-#include "internal/iterator_wrapper.hpp"
-#include "internal/iterbase.hpp"
-
 #include <array>
 #include <iterator>
 #include <optional>
@@ -12,6 +8,10 @@
 #include <type_traits>
 #include <utility>
 
+#include "internal/iter_tuples.hpp"
+#include "internal/iterator_wrapper.hpp"
+#include "internal/iterbase.hpp"
+
 namespace iter {
   namespace impl {
     template <typename TupType, std::size_t... Is>
@@ -43,6 +43,26 @@ class iter::impl::Chained {
  private:
   friend ChainMaker;
 
+  template <typename TupTypeTA, typename TupTypeTB>
+  class IteratorDataPair {
+    IteratorDataPair() = delete;
+
+   public:
+    using IterTupTypeA = iterator_tuple_type<TupTypeTA>;
+    using IterTupTypeB = iterator_tuple_type<TupTypeTB>;
+
+    template <std::size_t Idx>
+    static bool get_and_check_not_equal(
+        const IterTupTypeA& lhs, const IterTupTypeB& rhs) {
+      return std::get<Idx>(lhs) != std::get<Idx>(rhs);
+    }
+
+    using NeqFunc = bool (*)(const IterTupTypeA&, const IterTupTypeB&);
+
+    constexpr static std::array<NeqFunc, sizeof...(Is)> neq_comparers{
+        {get_and_check_not_equal<Is>...}};
+  };
+
   template <typename TupTypeT>
   class IteratorData {
     IteratorData() = delete;
@@ -76,16 +96,9 @@ class iter::impl::Chained {
       ++std::get<Idx>(iters);
     }
 
-    template <std::size_t Idx>
-    static bool get_and_check_not_equal(
-        const IterTupType& lhs, const IterTupType& rhs) {
-      return std::get<Idx>(lhs) != std::get<Idx>(rhs);
-    }
-
     using DerefFunc = DerefType (*)(IterTupType&);
     using ArrowFunc = ArrowType (*)(IterTupType&);
     using IncFunc = void (*)(IterTupType&);
-    using NeqFunc = bool (*)(const IterTupType&, const IterTupType&);
 
     constexpr static std::array<DerefFunc, sizeof...(Is)> derefers{
         {get_and_deref<Is>...}};
@@ -96,9 +109,6 @@ class iter::impl::Chained {
     constexpr static std::array<IncFunc, sizeof...(Is)> incrementers{
         {get_and_increment<Is>...}};
 
-    constexpr static std::array<NeqFunc, sizeof...(Is)> neq_comparers{
-        {get_and_check_not_equal<Is>...}};
-
     using TraitsValue =
         iterator_traits_deref<std::tuple_element_t<0, TupTypeT>>;
   };
@@ -119,12 +129,16 @@ class iter::impl::Chained {
 
     void check_for_end_and_adjust() {
       while (index_ < sizeof...(Is)
-             && !(IterData::neq_comparers[index_](iters_, ends_))) {
+             && !(IteratorDataPair<TupTypeT, TupTypeT>::neq_comparers[index_](
+                 iters_, ends_))) {
         ++index_;
       }
     }
 
    public:
+    template <typename>
+    friend class Iterator;
+
     using iterator_category = std::input_iterator_tag;
     using value_type = typename IteratorData<TupTypeT>::TraitsValue;
     using difference_type = std::ptrdiff_t;
@@ -141,7 +155,7 @@ class iter::impl::Chained {
       return IterData::derefers[index_](iters_);
     }
 
-    decltype(auto) operator-> () {
+    decltype(auto) operator->() {
       return IterData::arrowers[index_](iters_);
     }
 
@@ -158,13 +172,16 @@ class iter::impl::Chained {
     }
 
     // TODO make const and non-const iterators comparable
-    bool operator!=(const Iterator& other) const {
+    template <typename T>
+    bool operator!=(const Iterator<T>& other) const {
       return index_ != other.index_
              || (index_ != sizeof...(Is)
-                    && IterData::neq_comparers[index_](iters_, other.iters_));
+                 && IteratorDataPair<TupTypeT, T>::neq_comparers[index_](
+                     iters_, other.iters_));
     }
 
-    bool operator==(const Iterator& other) const {
+    template <typename T>
+    bool operator==(const Iterator<T>& other) const {
       return !(*this != other);
     }
   };
diff --git a/test/test_chain.cpp b/test/test_chain.cpp
index b4b77cf2..5ad9c361 100644
--- a/test/test_chain.cpp
+++ b/test/test_chain.cpp
@@ -1,6 +1,4 @@
 #include <chain.hpp>
-#include "helpers.hpp"
-
 #include <iterator>
 #include <list>
 #include <string>
@@ -8,6 +6,7 @@
 #include <vector>
 
 #include "catch.hpp"
+#include "helpers.hpp"
 
 using iter::chain;
 using itertest::BasicIterable;
@@ -37,14 +36,12 @@ TEST_CASE("chain: const iteration", "[chain][const]") {
   REQUIRE(v == vc);
 }
 
-// TODO make this work
-#if 0
-TEST_CASE("chain: const iterators can be compared to non-const itertors", "[chain][const]") {
+TEST_CASE("chain: const iterators can be compared to non-const itertors",
+    "[chain][const]") {
   auto ch = chain(std::string{}, std::string{});
   const auto& cch = ch;
   (void)(std::begin(ch) == std::end(cch));
 }
-#endif
 
 TEST_CASE("chain: with different container types", "[chain]") {
   std::string s1{"abc"};

From 7119a5d7b00228130a47b7554c515bd5b403774f Mon Sep 17 00:00:00 2001
From: maxmarsc <maxime.coutant@protonmail.com>
Date: Fri, 26 Apr 2024 13:15:11 +0200
Subject: [PATCH 1829/1866] Moved all headers into a cppitertools directory

Removed test build files from git tracking
---
 CMakeLists.txt                                         |  6 +++---
 accumulate.hpp => cppitertools/accumulate.hpp          |  0
 batched.hpp => cppitertools/batched.hpp                |  0
 chain.hpp => cppitertools/chain.hpp                    |  0
 chunked.hpp => cppitertools/chunked.hpp                |  0
 combinations.hpp => cppitertools/combinations.hpp      |  0
 .../combinations_with_replacement.hpp                  |  0
 compress.hpp => cppitertools/compress.hpp              |  0
 count.hpp => cppitertools/count.hpp                    |  0
 cycle.hpp => cppitertools/cycle.hpp                    |  0
 dropwhile.hpp => cppitertools/dropwhile.hpp            |  0
 enumerate.hpp => cppitertools/enumerate.hpp            |  0
 filter.hpp => cppitertools/filter.hpp                  |  0
 filterfalse.hpp => cppitertools/filterfalse.hpp        |  0
 groupby.hpp => cppitertools/groupby.hpp                |  0
 imap.hpp => cppitertools/imap.hpp                      |  0
 {internal => cppitertools/internal}/iter_tuples.hpp    |  0
 .../internal}/iterator_wrapper.hpp                     |  0
 .../internal}/iteratoriterator.hpp                     |  0
 {internal => cppitertools/internal}/iterbase.hpp       |  0
 itertools.hpp => cppitertools/itertools.hpp            |  0
 permutations.hpp => cppitertools/permutations.hpp      |  0
 powerset.hpp => cppitertools/powerset.hpp              |  0
 product.hpp => cppitertools/product.hpp                |  0
 range.hpp => cppitertools/range.hpp                    |  0
 repeat.hpp => cppitertools/repeat.hpp                  |  0
 reversed.hpp => cppitertools/reversed.hpp              |  0
 slice.hpp => cppitertools/slice.hpp                    |  0
 sliding_window.hpp => cppitertools/sliding_window.hpp  |  0
 sorted.hpp => cppitertools/sorted.hpp                  |  0
 starmap.hpp => cppitertools/starmap.hpp                |  0
 takewhile.hpp => cppitertools/takewhile.hpp            |  0
 .../unique_everseen.hpp                                |  0
 .../unique_justseen.hpp                                |  0
 zip.hpp => cppitertools/zip.hpp                        |  0
 zip_longest.hpp => cppitertools/zip_longest.hpp        |  0
 examples/accumulate_examples.cpp                       |  4 ++--
 examples/batched_examples.cpp                          |  2 +-
 examples/chain_examples.cpp                            |  2 +-
 examples/chunked_examples.cpp                          |  2 +-
 examples/combinatoric_examples.cpp                     | 10 +++++-----
 examples/compress_examples.cpp                         |  2 +-
 examples/count_examples.cpp                            |  2 +-
 examples/cycle_examples.cpp                            |  2 +-
 examples/dropwhile_examples.cpp                        |  2 +-
 examples/enumerate_examples.cpp                        |  2 +-
 examples/filter_examples.cpp                           |  2 +-
 examples/filterfalse_examples.cpp                      |  2 +-
 examples/groupby_examples.cpp                          |  2 +-
 examples/imap_examples.cpp                             |  2 +-
 examples/mixed_examples.cpp                            |  4 ++--
 examples/range_examples.cpp                            |  2 +-
 examples/repeat_examples.cpp                           |  2 +-
 examples/reversed_examples.cpp                         |  2 +-
 examples/slice_examples.cpp                            |  4 ++--
 examples/sliding_window_examples.cpp                   |  2 +-
 examples/sorted_examples.cpp                           |  2 +-
 examples/starmap_examples.cpp                          |  2 +-
 examples/takewhile_examples.cpp                        |  2 +-
 examples/unique_everseen_examples.cpp                  |  2 +-
 examples/unique_justseen_examples.cpp                  |  2 +-
 examples/zip_examples.cpp                              |  2 +-
 examples/zip_longest_examples.cpp                      |  2 +-
 test/helpers.hpp                                       |  2 +-
 test/test_accumulate.cpp                               |  2 +-
 test/test_batched.cpp                                  |  2 +-
 test/test_chain.cpp                                    |  2 +-
 test/test_chunked.cpp                                  |  2 +-
 test/test_combinations.cpp                             |  2 +-
 test/test_combinations_with_replacement.cpp            |  2 +-
 test/test_compress.cpp                                 |  2 +-
 test/test_count.cpp                                    |  2 +-
 test/test_cycle.cpp                                    |  2 +-
 test/test_dropwhile.cpp                                |  2 +-
 test/test_enumerate.cpp                                |  2 +-
 test/test_filter.cpp                                   |  2 +-
 test/test_filterfalse.cpp                              |  2 +-
 test/test_groupby.cpp                                  |  2 +-
 test/test_imap.cpp                                     |  2 +-
 test/test_iterator_wrapper.cpp                         |  2 +-
 test/test_iteratoriterator.cpp                         |  2 +-
 test/test_iterbase.cpp                                 |  4 ++--
 test/test_mixed.cpp                                    |  2 +-
 test/test_permutations.cpp                             |  2 +-
 test/test_powerset.cpp                                 |  2 +-
 test/test_product.cpp                                  |  2 +-
 test/test_range.cpp                                    |  2 +-
 test/test_repeat.cpp                                   |  2 +-
 test/test_reversed.cpp                                 |  2 +-
 test/test_slice.cpp                                    |  2 +-
 test/test_sliding_window.cpp                           |  2 +-
 test/test_sorted.cpp                                   |  4 ++--
 test/test_starmap.cpp                                  |  2 +-
 test/test_takewhile.cpp                                |  2 +-
 test/test_unique_everseen.cpp                          |  2 +-
 test/test_unique_justseen.cpp                          |  2 +-
 test/test_zip.cpp                                      |  2 +-
 test/test_zip_longest.cpp                              |  2 +-
 98 files changed, 74 insertions(+), 74 deletions(-)
 rename accumulate.hpp => cppitertools/accumulate.hpp (100%)
 rename batched.hpp => cppitertools/batched.hpp (100%)
 rename chain.hpp => cppitertools/chain.hpp (100%)
 rename chunked.hpp => cppitertools/chunked.hpp (100%)
 rename combinations.hpp => cppitertools/combinations.hpp (100%)
 rename combinations_with_replacement.hpp => cppitertools/combinations_with_replacement.hpp (100%)
 rename compress.hpp => cppitertools/compress.hpp (100%)
 rename count.hpp => cppitertools/count.hpp (100%)
 rename cycle.hpp => cppitertools/cycle.hpp (100%)
 rename dropwhile.hpp => cppitertools/dropwhile.hpp (100%)
 rename enumerate.hpp => cppitertools/enumerate.hpp (100%)
 rename filter.hpp => cppitertools/filter.hpp (100%)
 rename filterfalse.hpp => cppitertools/filterfalse.hpp (100%)
 rename groupby.hpp => cppitertools/groupby.hpp (100%)
 rename imap.hpp => cppitertools/imap.hpp (100%)
 rename {internal => cppitertools/internal}/iter_tuples.hpp (100%)
 rename {internal => cppitertools/internal}/iterator_wrapper.hpp (100%)
 rename {internal => cppitertools/internal}/iteratoriterator.hpp (100%)
 rename {internal => cppitertools/internal}/iterbase.hpp (100%)
 rename itertools.hpp => cppitertools/itertools.hpp (100%)
 rename permutations.hpp => cppitertools/permutations.hpp (100%)
 rename powerset.hpp => cppitertools/powerset.hpp (100%)
 rename product.hpp => cppitertools/product.hpp (100%)
 rename range.hpp => cppitertools/range.hpp (100%)
 rename repeat.hpp => cppitertools/repeat.hpp (100%)
 rename reversed.hpp => cppitertools/reversed.hpp (100%)
 rename slice.hpp => cppitertools/slice.hpp (100%)
 rename sliding_window.hpp => cppitertools/sliding_window.hpp (100%)
 rename sorted.hpp => cppitertools/sorted.hpp (100%)
 rename starmap.hpp => cppitertools/starmap.hpp (100%)
 rename takewhile.hpp => cppitertools/takewhile.hpp (100%)
 rename unique_everseen.hpp => cppitertools/unique_everseen.hpp (100%)
 rename unique_justseen.hpp => cppitertools/unique_justseen.hpp (100%)
 rename zip.hpp => cppitertools/zip.hpp (100%)
 rename zip_longest.hpp => cppitertools/zip_longest.hpp (100%)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 32d26fde..c7eb98ca 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -11,7 +11,7 @@ add_library(cppitertools::cppitertools ALIAS cppitertools)
 
 target_include_directories(cppitertools INTERFACE
   $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
-  $<INSTALL_INTERFACE:${cppitertools_INSTALL_INCLUDE_DIR}/cppitertools>)
+  $<INSTALL_INTERFACE:${cppitertools_INSTALL_INCLUDE_DIR}>)
 
 # require C++17
 target_compile_features(cppitertools INTERFACE cxx_std_17)
@@ -29,8 +29,8 @@ install(
   EXPORT cppitertools-targets)
 
 install(
-  DIRECTORY .
-  DESTINATION ${cppitertools_INSTALL_INCLUDE_DIR}/cppitertools)
+  DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/cppitertools
+  DESTINATION ${cppitertools_INSTALL_INCLUDE_DIR})
 
 install(
   EXPORT cppitertools-targets
diff --git a/accumulate.hpp b/cppitertools/accumulate.hpp
similarity index 100%
rename from accumulate.hpp
rename to cppitertools/accumulate.hpp
diff --git a/batched.hpp b/cppitertools/batched.hpp
similarity index 100%
rename from batched.hpp
rename to cppitertools/batched.hpp
diff --git a/chain.hpp b/cppitertools/chain.hpp
similarity index 100%
rename from chain.hpp
rename to cppitertools/chain.hpp
diff --git a/chunked.hpp b/cppitertools/chunked.hpp
similarity index 100%
rename from chunked.hpp
rename to cppitertools/chunked.hpp
diff --git a/combinations.hpp b/cppitertools/combinations.hpp
similarity index 100%
rename from combinations.hpp
rename to cppitertools/combinations.hpp
diff --git a/combinations_with_replacement.hpp b/cppitertools/combinations_with_replacement.hpp
similarity index 100%
rename from combinations_with_replacement.hpp
rename to cppitertools/combinations_with_replacement.hpp
diff --git a/compress.hpp b/cppitertools/compress.hpp
similarity index 100%
rename from compress.hpp
rename to cppitertools/compress.hpp
diff --git a/count.hpp b/cppitertools/count.hpp
similarity index 100%
rename from count.hpp
rename to cppitertools/count.hpp
diff --git a/cycle.hpp b/cppitertools/cycle.hpp
similarity index 100%
rename from cycle.hpp
rename to cppitertools/cycle.hpp
diff --git a/dropwhile.hpp b/cppitertools/dropwhile.hpp
similarity index 100%
rename from dropwhile.hpp
rename to cppitertools/dropwhile.hpp
diff --git a/enumerate.hpp b/cppitertools/enumerate.hpp
similarity index 100%
rename from enumerate.hpp
rename to cppitertools/enumerate.hpp
diff --git a/filter.hpp b/cppitertools/filter.hpp
similarity index 100%
rename from filter.hpp
rename to cppitertools/filter.hpp
diff --git a/filterfalse.hpp b/cppitertools/filterfalse.hpp
similarity index 100%
rename from filterfalse.hpp
rename to cppitertools/filterfalse.hpp
diff --git a/groupby.hpp b/cppitertools/groupby.hpp
similarity index 100%
rename from groupby.hpp
rename to cppitertools/groupby.hpp
diff --git a/imap.hpp b/cppitertools/imap.hpp
similarity index 100%
rename from imap.hpp
rename to cppitertools/imap.hpp
diff --git a/internal/iter_tuples.hpp b/cppitertools/internal/iter_tuples.hpp
similarity index 100%
rename from internal/iter_tuples.hpp
rename to cppitertools/internal/iter_tuples.hpp
diff --git a/internal/iterator_wrapper.hpp b/cppitertools/internal/iterator_wrapper.hpp
similarity index 100%
rename from internal/iterator_wrapper.hpp
rename to cppitertools/internal/iterator_wrapper.hpp
diff --git a/internal/iteratoriterator.hpp b/cppitertools/internal/iteratoriterator.hpp
similarity index 100%
rename from internal/iteratoriterator.hpp
rename to cppitertools/internal/iteratoriterator.hpp
diff --git a/internal/iterbase.hpp b/cppitertools/internal/iterbase.hpp
similarity index 100%
rename from internal/iterbase.hpp
rename to cppitertools/internal/iterbase.hpp
diff --git a/itertools.hpp b/cppitertools/itertools.hpp
similarity index 100%
rename from itertools.hpp
rename to cppitertools/itertools.hpp
diff --git a/permutations.hpp b/cppitertools/permutations.hpp
similarity index 100%
rename from permutations.hpp
rename to cppitertools/permutations.hpp
diff --git a/powerset.hpp b/cppitertools/powerset.hpp
similarity index 100%
rename from powerset.hpp
rename to cppitertools/powerset.hpp
diff --git a/product.hpp b/cppitertools/product.hpp
similarity index 100%
rename from product.hpp
rename to cppitertools/product.hpp
diff --git a/range.hpp b/cppitertools/range.hpp
similarity index 100%
rename from range.hpp
rename to cppitertools/range.hpp
diff --git a/repeat.hpp b/cppitertools/repeat.hpp
similarity index 100%
rename from repeat.hpp
rename to cppitertools/repeat.hpp
diff --git a/reversed.hpp b/cppitertools/reversed.hpp
similarity index 100%
rename from reversed.hpp
rename to cppitertools/reversed.hpp
diff --git a/slice.hpp b/cppitertools/slice.hpp
similarity index 100%
rename from slice.hpp
rename to cppitertools/slice.hpp
diff --git a/sliding_window.hpp b/cppitertools/sliding_window.hpp
similarity index 100%
rename from sliding_window.hpp
rename to cppitertools/sliding_window.hpp
diff --git a/sorted.hpp b/cppitertools/sorted.hpp
similarity index 100%
rename from sorted.hpp
rename to cppitertools/sorted.hpp
diff --git a/starmap.hpp b/cppitertools/starmap.hpp
similarity index 100%
rename from starmap.hpp
rename to cppitertools/starmap.hpp
diff --git a/takewhile.hpp b/cppitertools/takewhile.hpp
similarity index 100%
rename from takewhile.hpp
rename to cppitertools/takewhile.hpp
diff --git a/unique_everseen.hpp b/cppitertools/unique_everseen.hpp
similarity index 100%
rename from unique_everseen.hpp
rename to cppitertools/unique_everseen.hpp
diff --git a/unique_justseen.hpp b/cppitertools/unique_justseen.hpp
similarity index 100%
rename from unique_justseen.hpp
rename to cppitertools/unique_justseen.hpp
diff --git a/zip.hpp b/cppitertools/zip.hpp
similarity index 100%
rename from zip.hpp
rename to cppitertools/zip.hpp
diff --git a/zip_longest.hpp b/cppitertools/zip_longest.hpp
similarity index 100%
rename from zip_longest.hpp
rename to cppitertools/zip_longest.hpp
diff --git a/examples/accumulate_examples.cpp b/examples/accumulate_examples.cpp
index 9d9a2f67..4d8569d2 100644
--- a/examples/accumulate_examples.cpp
+++ b/examples/accumulate_examples.cpp
@@ -1,5 +1,5 @@
-#include <accumulate.hpp>
-#include <range.hpp>
+#include <cppitertools/accumulate.hpp>
+#include <cppitertools/range.hpp>
 
 #include <iostream>
 #include <vector>
diff --git a/examples/batched_examples.cpp b/examples/batched_examples.cpp
index c63c05b3..1dfa6abf 100644
--- a/examples/batched_examples.cpp
+++ b/examples/batched_examples.cpp
@@ -1,4 +1,4 @@
-#include <batched.hpp>
+#include <cppitertools/batched.hpp>
 
 #include <iostream>
 #include <vector>
diff --git a/examples/chain_examples.cpp b/examples/chain_examples.cpp
index 607fa040..cdcd7fed 100644
--- a/examples/chain_examples.cpp
+++ b/examples/chain_examples.cpp
@@ -1,4 +1,4 @@
-#include <chain.hpp>
+#include <cppitertools/chain.hpp>
 
 #include <vector>
 #include <string>
diff --git a/examples/chunked_examples.cpp b/examples/chunked_examples.cpp
index 9c3046f5..c3325df1 100644
--- a/examples/chunked_examples.cpp
+++ b/examples/chunked_examples.cpp
@@ -1,4 +1,4 @@
-#include <chunked.hpp>
+#include <cppitertools/chunked.hpp>
 
 #include <iostream>
 #include <vector>
diff --git a/examples/combinatoric_examples.cpp b/examples/combinatoric_examples.cpp
index 653d428c..0915f985 100644
--- a/examples/combinatoric_examples.cpp
+++ b/examples/combinatoric_examples.cpp
@@ -1,8 +1,8 @@
-#include <combinations.hpp>
-#include <combinations_with_replacement.hpp>
-#include <permutations.hpp>
-#include <product.hpp>
-#include <powerset.hpp>
+#include <cppitertools/combinations.hpp>
+#include <cppitertools/combinations_with_replacement.hpp>
+#include <cppitertools/permutations.hpp>
+#include <cppitertools/product.hpp>
+#include <cppitertools/powerset.hpp>
 
 #include <vector>
 #include <string>
diff --git a/examples/compress_examples.cpp b/examples/compress_examples.cpp
index b60197a9..dbabbbb9 100644
--- a/examples/compress_examples.cpp
+++ b/examples/compress_examples.cpp
@@ -1,4 +1,4 @@
-#include <compress.hpp>
+#include <cppitertools/compress.hpp>
 
 #include <vector>
 #include <iostream>
diff --git a/examples/count_examples.cpp b/examples/count_examples.cpp
index 10ac8a72..70b876cc 100644
--- a/examples/count_examples.cpp
+++ b/examples/count_examples.cpp
@@ -1,4 +1,4 @@
-#include <count.hpp>
+#include <cppitertools/count.hpp>
 
 #include <iostream>
 
diff --git a/examples/cycle_examples.cpp b/examples/cycle_examples.cpp
index 7f973d66..0598431a 100644
--- a/examples/cycle_examples.cpp
+++ b/examples/cycle_examples.cpp
@@ -1,4 +1,4 @@
-#include <cycle.hpp>
+#include <cppitertools/cycle.hpp>
 
 #include <vector>
 #include <string>
diff --git a/examples/dropwhile_examples.cpp b/examples/dropwhile_examples.cpp
index 8c628f1a..c8f993c0 100644
--- a/examples/dropwhile_examples.cpp
+++ b/examples/dropwhile_examples.cpp
@@ -1,4 +1,4 @@
-#include <dropwhile.hpp>
+#include <cppitertools/dropwhile.hpp>
 
 #include <vector>
 #include <iostream>
diff --git a/examples/enumerate_examples.cpp b/examples/enumerate_examples.cpp
index 899c3b39..822abbbf 100644
--- a/examples/enumerate_examples.cpp
+++ b/examples/enumerate_examples.cpp
@@ -1,4 +1,4 @@
-#include <enumerate.hpp>
+#include <cppitertools/enumerate.hpp>
 
 #include <string>
 #include <iostream>
diff --git a/examples/filter_examples.cpp b/examples/filter_examples.cpp
index d28c443a..5ce16af2 100644
--- a/examples/filter_examples.cpp
+++ b/examples/filter_examples.cpp
@@ -1,4 +1,4 @@
-#include <filter.hpp>
+#include <cppitertools/filter.hpp>
 
 #include <vector>
 #include <iostream>
diff --git a/examples/filterfalse_examples.cpp b/examples/filterfalse_examples.cpp
index dd937cee..0edc004a 100644
--- a/examples/filterfalse_examples.cpp
+++ b/examples/filterfalse_examples.cpp
@@ -1,4 +1,4 @@
-#include <filterfalse.hpp>
+#include <cppitertools/filterfalse.hpp>
 
 #include <vector>
 #include <string>
diff --git a/examples/groupby_examples.cpp b/examples/groupby_examples.cpp
index 8d4a9918..5525f9ff 100644
--- a/examples/groupby_examples.cpp
+++ b/examples/groupby_examples.cpp
@@ -1,4 +1,4 @@
-#include <groupby.hpp>
+#include <cppitertools/groupby.hpp>
 
 #include <vector>
 #include <iostream>
diff --git a/examples/imap_examples.cpp b/examples/imap_examples.cpp
index 812281b6..95fee802 100644
--- a/examples/imap_examples.cpp
+++ b/examples/imap_examples.cpp
@@ -1,4 +1,4 @@
-#include <imap.hpp>
+#include <cppitertools/imap.hpp>
 
 #include <vector>
 #include <iostream>
diff --git a/examples/mixed_examples.cpp b/examples/mixed_examples.cpp
index 08ff774b..9f1ba056 100644
--- a/examples/mixed_examples.cpp
+++ b/examples/mixed_examples.cpp
@@ -1,5 +1,5 @@
-#include <itertools.hpp>
-#include <zip_longest.hpp>
+#include <cppitertools/itertools.hpp>
+#include <cppitertools/zip_longest.hpp>
 
 #include <vector>
 #include <tuple>
diff --git a/examples/range_examples.cpp b/examples/range_examples.cpp
index 1dd03199..ff328ee7 100644
--- a/examples/range_examples.cpp
+++ b/examples/range_examples.cpp
@@ -1,4 +1,4 @@
-#include <range.hpp>
+#include <cppitertools/range.hpp>
 
 #include <iostream>
 
diff --git a/examples/repeat_examples.cpp b/examples/repeat_examples.cpp
index 24d37a8d..2dceaf98 100644
--- a/examples/repeat_examples.cpp
+++ b/examples/repeat_examples.cpp
@@ -1,4 +1,4 @@
-#include <repeat.hpp>
+#include <cppitertools/repeat.hpp>
 
 #include <iostream>
 
diff --git a/examples/reversed_examples.cpp b/examples/reversed_examples.cpp
index d4d804d9..1bb8dbed 100644
--- a/examples/reversed_examples.cpp
+++ b/examples/reversed_examples.cpp
@@ -1,4 +1,4 @@
-#include <reversed.hpp>
+#include <cppitertools/reversed.hpp>
 
 #include <iostream>
 #include <vector>
diff --git a/examples/slice_examples.cpp b/examples/slice_examples.cpp
index 42a16e33..d9f2501a 100644
--- a/examples/slice_examples.cpp
+++ b/examples/slice_examples.cpp
@@ -1,7 +1,7 @@
 #include <iostream>
 
-#include <slice.hpp>
-#include <range.hpp>
+#include <cppitertools/slice.hpp>
+#include <cppitertools/range.hpp>
 
 #include <vector>
 #include <array>
diff --git a/examples/sliding_window_examples.cpp b/examples/sliding_window_examples.cpp
index ff286202..7658182d 100644
--- a/examples/sliding_window_examples.cpp
+++ b/examples/sliding_window_examples.cpp
@@ -1,4 +1,4 @@
-#include "sliding_window.hpp"
+#include "cppitertools/sliding_window.hpp"
 
 #include <iostream>
 #include <vector>
diff --git a/examples/sorted_examples.cpp b/examples/sorted_examples.cpp
index 109d137d..4e6b5a22 100644
--- a/examples/sorted_examples.cpp
+++ b/examples/sorted_examples.cpp
@@ -1,4 +1,4 @@
-#include <sorted.hpp>
+#include <cppitertools/sorted.hpp>
 
 #include <iostream>
 #include <vector>
diff --git a/examples/starmap_examples.cpp b/examples/starmap_examples.cpp
index 9797756c..b375ef3e 100644
--- a/examples/starmap_examples.cpp
+++ b/examples/starmap_examples.cpp
@@ -1,4 +1,4 @@
-#include <starmap.hpp>
+#include <cppitertools/starmap.hpp>
 
 #include <array>
 #include <tuple>
diff --git a/examples/takewhile_examples.cpp b/examples/takewhile_examples.cpp
index 3062a141..d86d6442 100644
--- a/examples/takewhile_examples.cpp
+++ b/examples/takewhile_examples.cpp
@@ -1,4 +1,4 @@
-#include <takewhile.hpp>
+#include <cppitertools/takewhile.hpp>
 
 #include <vector>
 #include <iostream>
diff --git a/examples/unique_everseen_examples.cpp b/examples/unique_everseen_examples.cpp
index a670f0b1..52dc02fa 100644
--- a/examples/unique_everseen_examples.cpp
+++ b/examples/unique_everseen_examples.cpp
@@ -1,4 +1,4 @@
-#include <unique_everseen.hpp>
+#include <cppitertools/unique_everseen.hpp>
 
 #include <vector>
 #include <iostream>
diff --git a/examples/unique_justseen_examples.cpp b/examples/unique_justseen_examples.cpp
index 878cd4f8..7c8cd9aa 100644
--- a/examples/unique_justseen_examples.cpp
+++ b/examples/unique_justseen_examples.cpp
@@ -1,4 +1,4 @@
-#include <unique_justseen.hpp>
+#include <cppitertools/unique_justseen.hpp>
 
 #include <vector>
 #include <iostream>
diff --git a/examples/zip_examples.cpp b/examples/zip_examples.cpp
index d35dd0cf..51febf13 100644
--- a/examples/zip_examples.cpp
+++ b/examples/zip_examples.cpp
@@ -1,4 +1,4 @@
-#include <zip.hpp>
+#include <cppitertools/zip.hpp>
 
 #include <vector>
 #include <string>
diff --git a/examples/zip_longest_examples.cpp b/examples/zip_longest_examples.cpp
index 5f8dc9e7..d3c80173 100644
--- a/examples/zip_longest_examples.cpp
+++ b/examples/zip_longest_examples.cpp
@@ -1,4 +1,4 @@
-#include <zip_longest.hpp>
+#include <cppitertools/zip_longest.hpp>
 
 #include <vector>
 #include <string>
diff --git a/test/helpers.hpp b/test/helpers.hpp
index 93112519..80167980 100644
--- a/test/helpers.hpp
+++ b/test/helpers.hpp
@@ -1,7 +1,7 @@
 #ifndef TEST_HELPER_H_
 #define TEST_HELPER_H_
 
-#include <internal/iterbase.hpp>
+#include <cppitertools/internal/iterbase.hpp>
 #include <iostream>
 #include <sstream>
 #include <stdexcept>
diff --git a/test/test_accumulate.cpp b/test/test_accumulate.cpp
index f91f32b6..c868f0c5 100644
--- a/test/test_accumulate.cpp
+++ b/test/test_accumulate.cpp
@@ -1,4 +1,4 @@
-#include <accumulate.hpp>
+#include <cppitertools/accumulate.hpp>
 #include "helpers.hpp"
 
 #include <iterator>
diff --git a/test/test_batched.cpp b/test/test_batched.cpp
index bdd5e2a3..098acecc 100644
--- a/test/test_batched.cpp
+++ b/test/test_batched.cpp
@@ -1,4 +1,4 @@
-#include <batched.hpp>
+#include <cppitertools/batched.hpp>
 
 #include <array>
 #include <string>
diff --git a/test/test_chain.cpp b/test/test_chain.cpp
index b4b77cf2..9196ef72 100644
--- a/test/test_chain.cpp
+++ b/test/test_chain.cpp
@@ -1,4 +1,4 @@
-#include <chain.hpp>
+#include <cppitertools/chain.hpp>
 #include "helpers.hpp"
 
 #include <iterator>
diff --git a/test/test_chunked.cpp b/test/test_chunked.cpp
index 7e3165a0..3aaca797 100644
--- a/test/test_chunked.cpp
+++ b/test/test_chunked.cpp
@@ -1,4 +1,4 @@
-#include <chunked.hpp>
+#include <cppitertools/chunked.hpp>
 
 #include <array>
 #include <string>
diff --git a/test/test_combinations.cpp b/test/test_combinations.cpp
index 6d9718dc..14548240 100644
--- a/test/test_combinations.cpp
+++ b/test/test_combinations.cpp
@@ -4,7 +4,7 @@
 #undef CHAR_RANGE_DEFAULT_CONSTRUCTIBLE
 #undef DEFINE_DEFAULT_ITERATOR_CTOR
 
-#include <combinations.hpp>
+#include <cppitertools/combinations.hpp>
 #include <iterator>
 #include <set>
 #include <string>
diff --git a/test/test_combinations_with_replacement.cpp b/test/test_combinations_with_replacement.cpp
index 536780ac..2c3ee0f6 100644
--- a/test/test_combinations_with_replacement.cpp
+++ b/test/test_combinations_with_replacement.cpp
@@ -1,4 +1,4 @@
-#include <combinations_with_replacement.hpp>
+#include <cppitertools/combinations_with_replacement.hpp>
 #include <iterator>
 #include <set>
 #include <string>
diff --git a/test/test_compress.cpp b/test/test_compress.cpp
index 1330e9c2..70aa3f89 100644
--- a/test/test_compress.cpp
+++ b/test/test_compress.cpp
@@ -1,4 +1,4 @@
-#include <compress.hpp>
+#include <cppitertools/compress.hpp>
 #include "helpers.hpp"
 
 #include <iterator>
diff --git a/test/test_count.cpp b/test/test_count.cpp
index 8998f1eb..d5248ac2 100644
--- a/test/test_count.cpp
+++ b/test/test_count.cpp
@@ -1,4 +1,4 @@
-#include <count.hpp>
+#include <cppitertools/count.hpp>
 #include "helpers.hpp"
 
 #include <iterator>
diff --git a/test/test_cycle.cpp b/test/test_cycle.cpp
index 84981878..0974a87c 100644
--- a/test/test_cycle.cpp
+++ b/test/test_cycle.cpp
@@ -1,4 +1,4 @@
-#include <cycle.hpp>
+#include <cppitertools/cycle.hpp>
 
 #include "helpers.hpp"
 
diff --git a/test/test_dropwhile.cpp b/test/test_dropwhile.cpp
index 2b85c607..2a41a671 100644
--- a/test/test_dropwhile.cpp
+++ b/test/test_dropwhile.cpp
@@ -1,4 +1,4 @@
-#include <dropwhile.hpp>
+#include <cppitertools/dropwhile.hpp>
 
 #include "helpers.hpp"
 
diff --git a/test/test_enumerate.cpp b/test/test_enumerate.cpp
index d5fb4238..777146e6 100644
--- a/test/test_enumerate.cpp
+++ b/test/test_enumerate.cpp
@@ -1,4 +1,4 @@
-#include <enumerate.hpp>
+#include <cppitertools/enumerate.hpp>
 
 #include "helpers.hpp"
 
diff --git a/test/test_filter.cpp b/test/test_filter.cpp
index b10dd5be..f160785b 100644
--- a/test/test_filter.cpp
+++ b/test/test_filter.cpp
@@ -1,4 +1,4 @@
-#include <filter.hpp>
+#include <cppitertools/filter.hpp>
 
 #include "helpers.hpp"
 
diff --git a/test/test_filterfalse.cpp b/test/test_filterfalse.cpp
index 7a74a0df..93d50d6a 100644
--- a/test/test_filterfalse.cpp
+++ b/test/test_filterfalse.cpp
@@ -1,4 +1,4 @@
-#include <filterfalse.hpp>
+#include <cppitertools/filterfalse.hpp>
 
 #include "helpers.hpp"
 
diff --git a/test/test_groupby.cpp b/test/test_groupby.cpp
index 0069da14..6ce9d479 100644
--- a/test/test_groupby.cpp
+++ b/test/test_groupby.cpp
@@ -1,4 +1,4 @@
-#include <groupby.hpp>
+#include <cppitertools/groupby.hpp>
 
 #include "helpers.hpp"
 
diff --git a/test/test_imap.cpp b/test/test_imap.cpp
index b2be404d..40a9d3e3 100644
--- a/test/test_imap.cpp
+++ b/test/test_imap.cpp
@@ -1,4 +1,4 @@
-#include <imap.hpp>
+#include <cppitertools/imap.hpp>
 
 #include "helpers.hpp"
 
diff --git a/test/test_iterator_wrapper.cpp b/test/test_iterator_wrapper.cpp
index 6c79a278..e5b0238a 100644
--- a/test/test_iterator_wrapper.cpp
+++ b/test/test_iterator_wrapper.cpp
@@ -1,7 +1,7 @@
 // NOTE this header tests implementation details
 
 #include "catch.hpp"
-#include "internal/iterator_wrapper.hpp"
+#include "cppitertools/internal/iterator_wrapper.hpp"
 
 // I'm using a std::vector of 1 int instead of just an int in order to give
 // the iterator types non-trivial constructors, destructors, and assignment.
diff --git a/test/test_iteratoriterator.cpp b/test/test_iteratoriterator.cpp
index dd2c4987..11c1b16c 100644
--- a/test/test_iteratoriterator.cpp
+++ b/test/test_iteratoriterator.cpp
@@ -1,4 +1,4 @@
-#include <internal/iteratoriterator.hpp>
+#include <cppitertools/internal/iteratoriterator.hpp>
 
 #include <string>
 #include <vector>
diff --git a/test/test_iterbase.cpp b/test/test_iterbase.cpp
index c8783f32..c904b841 100644
--- a/test/test_iterbase.cpp
+++ b/test/test_iterbase.cpp
@@ -2,8 +2,8 @@
 // on any of this.  Users of the library must consider all of this undocumented
 //
 
-#include <enumerate.hpp>
-#include <internal/iterbase.hpp>
+#include <cppitertools/enumerate.hpp>
+#include <cppitertools/internal/iterbase.hpp>
 #include <iterator>
 #include <list>
 #include <string>
diff --git a/test/test_mixed.cpp b/test/test_mixed.cpp
index 9c4c3ed6..b190adf6 100644
--- a/test/test_mixed.cpp
+++ b/test/test_mixed.cpp
@@ -4,7 +4,7 @@
 #include <vector>
 
 #include "catch.hpp"
-#include "itertools.hpp"
+#include "cppitertools/itertools.hpp"
 
 class MyUnMovable {
   int val;
diff --git a/test/test_permutations.cpp b/test/test_permutations.cpp
index 5da85fc8..8d77d2f2 100644
--- a/test/test_permutations.cpp
+++ b/test/test_permutations.cpp
@@ -1,4 +1,4 @@
-#include <permutations.hpp>
+#include <cppitertools/permutations.hpp>
 
 #include "helpers.hpp"
 
diff --git a/test/test_powerset.cpp b/test/test_powerset.cpp
index c18dd1f7..44a7d8b5 100644
--- a/test/test_powerset.cpp
+++ b/test/test_powerset.cpp
@@ -1,4 +1,4 @@
-#include <powerset.hpp>
+#include <cppitertools/powerset.hpp>
 
 #define CHAR_RANGE_DEFAULT_CONSTRUCTIBLE
 #include "helpers.hpp"
diff --git a/test/test_product.cpp b/test/test_product.cpp
index 6a580bc9..a453da99 100644
--- a/test/test_product.cpp
+++ b/test/test_product.cpp
@@ -1,4 +1,4 @@
-#include <product.hpp>
+#include <cppitertools/product.hpp>
 
 #define DEFINE_BASIC_ITERABLE_COPY_CTOR
 #define DEFINE_BASIC_ITERABLE_CONST_BEGIN_AND_END
diff --git a/test/test_range.cpp b/test/test_range.cpp
index 4a25211a..b2b15f98 100644
--- a/test/test_range.cpp
+++ b/test/test_range.cpp
@@ -1,4 +1,4 @@
-#include "range.hpp"
+#include "cppitertools/range.hpp"
 
 #include <algorithm>
 #include <iterator>
diff --git a/test/test_repeat.cpp b/test/test_repeat.cpp
index ab92cbc1..5427909a 100644
--- a/test/test_repeat.cpp
+++ b/test/test_repeat.cpp
@@ -1,5 +1,5 @@
 #include <iterator>
-#include <repeat.hpp>
+#include <cppitertools/repeat.hpp>
 #include <string>
 #include <vector>
 
diff --git a/test/test_reversed.cpp b/test/test_reversed.cpp
index 530a17fc..10dfe4d9 100644
--- a/test/test_reversed.cpp
+++ b/test/test_reversed.cpp
@@ -1,4 +1,4 @@
-#include <reversed.hpp>
+#include <cppitertools/reversed.hpp>
 
 #include <array>
 #include <string>
diff --git a/test/test_slice.cpp b/test/test_slice.cpp
index 5fae78f4..fc5b42fe 100644
--- a/test/test_slice.cpp
+++ b/test/test_slice.cpp
@@ -1,4 +1,4 @@
-#include <slice.hpp>
+#include <cppitertools/slice.hpp>
 
 #include <string>
 #include <utility>
diff --git a/test/test_sliding_window.cpp b/test/test_sliding_window.cpp
index a302e1dc..e031ce75 100644
--- a/test/test_sliding_window.cpp
+++ b/test/test_sliding_window.cpp
@@ -1,4 +1,4 @@
-#include <sliding_window.hpp>
+#include <cppitertools/sliding_window.hpp>
 
 #include <array>
 #include <string>
diff --git a/test/test_sorted.cpp b/test/test_sorted.cpp
index ff151576..ea80decf 100644
--- a/test/test_sorted.cpp
+++ b/test/test_sorted.cpp
@@ -1,4 +1,4 @@
-#include <sorted.hpp>
+#include <cppitertools/sorted.hpp>
 
 #include <array>
 #include <set>
@@ -46,7 +46,7 @@ TEST_CASE("sorted: const iteration", "[sorted][const]") {
   REQUIRE(v == vc);
 }
 
-//FIXME: This test currently fails (STL assertion fails on MSVC with debug library, simple test failure on gcc).  The problem is 'sorted' will sort twice, once for non-const and once for const container; the resulting iterators are thus not on the same container (violating domain of == as specified in C++17 [forward.iterators]¶2).  Remove [!hide] tag when fixed.
+//FIXME: This test currently fails (STL assertion fails on MSVC with debug library, simple test failure on gcc).  The problem is 'sorted' will sort twice, once for non-const and once for const container; the resulting iterators are thus not on the same container (violating domain of == as specified in C++17 [forward.iterators]�2).  Remove [!hide] tag when fixed.
 TEST_CASE("sorted: const iterators can be compared to non-const iterators",
     "[sorted][const][!hide]") {
   auto s = sorted(Vec{1});
diff --git a/test/test_starmap.cpp b/test/test_starmap.cpp
index feae8da9..e3958c84 100644
--- a/test/test_starmap.cpp
+++ b/test/test_starmap.cpp
@@ -1,4 +1,4 @@
-#include <starmap.hpp>
+#include <cppitertools/starmap.hpp>
 #include "helpers.hpp"
 
 #include <iterator>
diff --git a/test/test_takewhile.cpp b/test/test_takewhile.cpp
index 903f6a9f..e3dade73 100644
--- a/test/test_takewhile.cpp
+++ b/test/test_takewhile.cpp
@@ -1,4 +1,4 @@
-#include <takewhile.hpp>
+#include <cppitertools/takewhile.hpp>
 
 #include <array>
 #include <string>
diff --git a/test/test_unique_everseen.cpp b/test/test_unique_everseen.cpp
index 68cb319a..c5fedad3 100644
--- a/test/test_unique_everseen.cpp
+++ b/test/test_unique_everseen.cpp
@@ -1,4 +1,4 @@
-#include <unique_everseen.hpp>
+#include <cppitertools/unique_everseen.hpp>
 
 #include "helpers.hpp"
 
diff --git a/test/test_unique_justseen.cpp b/test/test_unique_justseen.cpp
index 72af19b8..6147b477 100644
--- a/test/test_unique_justseen.cpp
+++ b/test/test_unique_justseen.cpp
@@ -1,4 +1,4 @@
-#include <unique_justseen.hpp>
+#include <cppitertools/unique_justseen.hpp>
 
 #include "helpers.hpp"
 
diff --git a/test/test_zip.cpp b/test/test_zip.cpp
index cb49981c..87c927f8 100644
--- a/test/test_zip.cpp
+++ b/test/test_zip.cpp
@@ -1,4 +1,4 @@
-#include <zip.hpp>
+#include <cppitertools/zip.hpp>
 
 #include "helpers.hpp"
 
diff --git a/test/test_zip_longest.cpp b/test/test_zip_longest.cpp
index 4759a412..cdf29269 100644
--- a/test/test_zip_longest.cpp
+++ b/test/test_zip_longest.cpp
@@ -1,4 +1,4 @@
-#include <zip_longest.hpp>
+#include <cppitertools/zip_longest.hpp>
 
 #include "helpers.hpp"
 

From 02f1457e23e277db646c6fe4cc519f5b1e9cc314 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining@google.com>
Date: Fri, 3 May 2024 17:02:49 -0700
Subject: [PATCH 1830/1866] Fixes BUILD for cppitertools/ prefix

users will need to prefix includes with "cppitertools/"

Issue #100
---
 BUILD | 70 +++++++++++++++++++++++++++++------------------------------
 1 file changed, 35 insertions(+), 35 deletions(-)

diff --git a/BUILD b/BUILD
index bab14566..f2fab7df 100644
--- a/BUILD
+++ b/BUILD
@@ -1,43 +1,43 @@
 cc_library(
     name = "cppitertools",
     hdrs = [
-        "accumulate.hpp",
-        "batched.hpp",
-        "chain.hpp",
-        "chunked.hpp",
-        "combinations.hpp",
-        "combinations_with_replacement.hpp",
-        "compress.hpp",
-        "count.hpp",
-        "cycle.hpp",
-        "dropwhile.hpp",
-        "enumerate.hpp",
-        "filter.hpp",
-        "filterfalse.hpp",
-        "groupby.hpp",
-        "imap.hpp",
-        "itertools.hpp",
-        "permutations.hpp",
-        "powerset.hpp",
-        "product.hpp",
-        "range.hpp",
-        "repeat.hpp",
-        "reversed.hpp",
-        "slice.hpp",
-        "sliding_window.hpp",
-        "sorted.hpp",
-        "starmap.hpp",
-        "takewhile.hpp",
-        "unique_everseen.hpp",
-        "unique_justseen.hpp",
-        "zip.hpp",
-        "zip_longest.hpp",
+        "cppitertools/accumulate.hpp",
+        "cppitertools/batched.hpp",
+        "cppitertools/chain.hpp",
+        "cppitertools/chunked.hpp",
+        "cppitertools/combinations.hpp",
+        "cppitertools/combinations_with_replacement.hpp",
+        "cppitertools/compress.hpp",
+        "cppitertools/count.hpp",
+        "cppitertools/cycle.hpp",
+        "cppitertools/dropwhile.hpp",
+        "cppitertools/enumerate.hpp",
+        "cppitertools/filter.hpp",
+        "cppitertools/filterfalse.hpp",
+        "cppitertools/groupby.hpp",
+        "cppitertools/imap.hpp",
+        "cppitertools/itertools.hpp",
+        "cppitertools/permutations.hpp",
+        "cppitertools/powerset.hpp",
+        "cppitertools/product.hpp",
+        "cppitertools/range.hpp",
+        "cppitertools/repeat.hpp",
+        "cppitertools/reversed.hpp",
+        "cppitertools/slice.hpp",
+        "cppitertools/sliding_window.hpp",
+        "cppitertools/sorted.hpp",
+        "cppitertools/starmap.hpp",
+        "cppitertools/takewhile.hpp",
+        "cppitertools/unique_everseen.hpp",
+        "cppitertools/unique_justseen.hpp",
+        "cppitertools/zip.hpp",
+        "cppitertools/zip_longest.hpp",
     ],
     srcs = [
-        "internal/iter_tuples.hpp",
-        "internal/iterator_wrapper.hpp",
-        "internal/iteratoriterator.hpp",
-        "internal/iterbase.hpp",
+        "cppitertools/internal/iter_tuples.hpp",
+        "cppitertools/internal/iterator_wrapper.hpp",
+        "cppitertools/internal/iteratoriterator.hpp",
+        "cppitertools/internal/iterbase.hpp",
     ],
     visibility = ["//visibility:public"],
 )

From f857d4ad101b5635842e6216e4d962c71da41cec Mon Sep 17 00:00:00 2001
From: Sayan <reach2sayan@gmail.com>
Date: Sun, 5 May 2024 09:28:10 -0400
Subject: [PATCH 1831/1866] remove stale comments; improve tests for const
 non-const comparisons [chain]

---
 chain.hpp           |  1 -
 test/test_chain.cpp | 54 ++++++++++++++++++++++++++++++++++++++++-----
 2 files changed, 49 insertions(+), 6 deletions(-)

diff --git a/chain.hpp b/chain.hpp
index 55338c9d..85dd6555 100644
--- a/chain.hpp
+++ b/chain.hpp
@@ -171,7 +171,6 @@ class iter::impl::Chained {
       return ret;
     }
 
-    // TODO make const and non-const iterators comparable
     template <typename T>
     bool operator!=(const Iterator<T>& other) const {
       return index_ != other.index_
diff --git a/test/test_chain.cpp b/test/test_chain.cpp
index 5ad9c361..47360d97 100644
--- a/test/test_chain.cpp
+++ b/test/test_chain.cpp
@@ -38,9 +38,31 @@ TEST_CASE("chain: const iteration", "[chain][const]") {
 
 TEST_CASE("chain: const iterators can be compared to non-const itertors",
     "[chain][const]") {
-  auto ch = chain(std::string{}, std::string{});
-  const auto& cch = ch;
-  (void)(std::begin(ch) == std::end(cch));
+  std::string s1{"abc"};
+  std::list<char> li{'m', 'n', 'o'};
+  auto ch = chain(s1, li);
+
+  const auto cch = chain(s1, li);
+  SECTION("begin and const begin compare equal") {
+    REQUIRE(std::begin(ch) == std::begin(cch));
+  }
+  SECTION("begin and const end compare not-equal") {
+    REQUIRE_FALSE(std::begin(ch) == std::end(cch));
+  }
+  SECTION("end and const end compare equal") {
+    REQUIRE(std::end(ch) == std::end(cch));
+  }
+  SECTION(
+      "const and non-const iterator compare equal/not-equal at appropriate "
+      "pos.") {
+    auto iter = ch.begin();
+    iter++;
+    auto citer = cch.begin();
+    citer++;
+    REQUIRE(iter == citer);
+    citer++;
+    REQUIRE_FALSE(iter == citer);
+  }
 }
 
 TEST_CASE("chain: with different container types", "[chain]") {
@@ -215,10 +237,32 @@ TEST_CASE(
     "chain.from_iterable: const iterators can be compared to non-const "
     "iterators",
     "[chain.from_iterable][const]") {
-  std::vector<std::vector<int>> v{};
+  std::vector<std::vector<int>> v{{1, 2}, {4, 6}};
   auto ch = chain.from_iterable(v);
   const auto& cch = ch;
-  (void)(std::begin(ch) == std::end(cch));
+
+  SECTION("begin and const end compare not-equal") {
+    REQUIRE_FALSE(std::begin(ch) == std::end(cch));
+  }
+  SECTION("begin and const begin compare equal") {
+    REQUIRE(std::begin(ch) == std::begin(cch));
+  }
+  SECTION("end and const end compare not-equal") {
+    REQUIRE(std::end(ch) == std::end(cch));
+  }
+  SECTION(
+      "const and non-const iterator compare equal/not-equal at appropriate "
+      "pos.") {
+    auto iter = ch.begin();
+    iter++;
+    auto citer = cch.begin();
+    citer++;
+    REQUIRE(iter == citer);
+    citer++;
+    REQUIRE_FALSE(iter == citer);
+    iter++;
+    REQUIRE(iter == citer);
+  }
 }
 
 TEST_CASE("chain.fromm_iterable: Works with different begin and end types",

From 7abcb2d8da270544df3b41bf623d50f3357f7d28 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Mon, 6 May 2024 12:49:22 -0700
Subject: [PATCH 1832/1866] Updates conanfile for cppitertools subdirectory/

And conan2 I think? I am not really sure what I'm doing here.

Issue #100
---
 conanfile.py | 61 ++++++++++++++++++++++++++++++----------------------
 1 file changed, 35 insertions(+), 26 deletions(-)

diff --git a/conanfile.py b/conanfile.py
index b47cbab4..114b620f 100644
--- a/conanfile.py
+++ b/conanfile.py
@@ -1,35 +1,44 @@
-from conans import ConanFile, CMake
-
-import os
+from conan import ConanFile
+from conan.tools.cmake import CMakeToolchain, CMake, cmake_layout, CMakeDeps
 
 
 class CppIterTools(ConanFile):
-    name = "cppitertools"
-    version = "2.0"
-    author = "Ryan Haining <haining.cpp@gmail.com>"
-    homepage = "https://github.com/ryanhaining/cppitertools"
+    name = 'cppitertools'
+    version = '3.0'
+    author = 'Ryan Haining <haining.cpp@gmail.com>'
+    homepage = 'https://github.com/ryanhaining/cppitertools'
     url = homepage
-    topics = ("conan", "itertools", "cppitertools")
-    license = 'BSD 2-Clause "Simplified" License'
-    description = "Range-based for loop add-ons inspired by the Python builtins and itertools library. " \
-                  "Like itertools and the Python3 builtins, this library uses lazy evaluation wherever possible."
-    settings = "build_type", "compiler", "os", "arch"
-    generators = "cmake", "cmake_find_package", "cmake_paths"
-    exports = "LICENSE.md"
-
-    exports_sources = list()
-    for file in os.listdir("."):
-        if file.endswith(".hpp"):
-            exports_sources.append(str(file))
-    print("found files: " + str(exports_sources))
-    exports_sources = tuple(exports_sources) + \
-                      ("internal/*", "CMakeLists.txt", "cmake/dummy-config.cmake.in")
-    no_copy_source = True
+    topics = ('itertools', 'cppitertools')
+    license = "BSD 2-Clause 'Simplified' License"
+    description = 'Range-based for loop add-ons inspired by the Python builtins and itertools library. ' \
+                  'Like itertools and the Python3 builtins, this library uses lazy evaluation wherever possible.'
+    settings = 'build_type', 'compiler', 'os', 'arch'
+    exports = 'LICENSE.md'
 
-    def package(self):
+    exports_sources = (
+            'cppitertools/*',
+            'cppitertools/internal/*',
+            'CMakeLists.txt',
+            'cmake/dummy-config.cmake.in')
+
+    def layout(self):
+        cmake_layout(self)
+
+    def generate(self):
+        deps = CMakeDeps(self)
+        deps.generate()
+        tc = CMakeToolchain(self)
+        tc.generate()
+
+    def build(self):
         cmake = CMake(self)
         cmake.configure()
+        cmake.build()
+
+    def package(self):
+        cmake = CMake(self)
         cmake.install()
 
-    def package_id(self):
-        self.info.header_only()
+    def package_info(self):
+        self.cpp_info.bindirs = []
+        self.cpp_info.libdirs = []

From 87ad8a0b3de4a10cf475c01e0ccdf517529b4142 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining@google.com>
Date: Fri, 21 Jun 2024 11:46:33 -0700
Subject: [PATCH 1833/1866] Adds bazel lockfiles to gitignore

---
 .gitignore | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.gitignore b/.gitignore
index ac51a054..553aa4a3 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1 +1,3 @@
 bazel-*
+MODULE.bazel
+MODULE.bazel.lock

From 69d3b3f510847bdb953894f81cf6f52b9b533b8f Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining@google.com>
Date: Fri, 21 Jun 2024 11:53:32 -0700
Subject: [PATCH 1834/1866] Removes anonymous namespace around chain definition

Fixes #104
---
 cppitertools/chain.hpp | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/cppitertools/chain.hpp b/cppitertools/chain.hpp
index 85dd6555..76759eeb 100644
--- a/cppitertools/chain.hpp
+++ b/cppitertools/chain.hpp
@@ -343,9 +343,7 @@ class iter::impl::ChainMaker {
 };
 
 namespace iter {
-  namespace {
-    constexpr auto chain = iter::impl::ChainMaker{};
-  }
+  inline constexpr auto chain = iter::impl::ChainMaker{};
 }
 
 #endif

From ab4999407f73ca09cc2e5efff2b8724ac40b071a Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining@google.com>
Date: Fri, 21 Jun 2024 11:54:29 -0700
Subject: [PATCH 1835/1866] Adds inline specifier to itertools callable objects
 in headers

Related to issue #104
---
 cppitertools/accumulate.hpp                    | 2 +-
 cppitertools/batched.hpp                       | 2 +-
 cppitertools/chunked.hpp                       | 2 +-
 cppitertools/combinations.hpp                  | 2 +-
 cppitertools/combinations_with_replacement.hpp | 2 +-
 cppitertools/cycle.hpp                         | 2 +-
 cppitertools/dropwhile.hpp                     | 2 +-
 cppitertools/enumerate.hpp                     | 2 +-
 cppitertools/filter.hpp                        | 2 +-
 cppitertools/filterfalse.hpp                   | 2 +-
 cppitertools/groupby.hpp                       | 2 +-
 cppitertools/imap.hpp                          | 2 +-
 cppitertools/permutations.hpp                  | 2 +-
 cppitertools/powerset.hpp                      | 2 +-
 cppitertools/reversed.hpp                      | 2 +-
 cppitertools/slice.hpp                         | 2 +-
 cppitertools/sliding_window.hpp                | 2 +-
 cppitertools/sorted.hpp                        | 2 +-
 cppitertools/starmap.hpp                       | 2 +-
 cppitertools/takewhile.hpp                     | 2 +-
 cppitertools/unique_everseen.hpp               | 2 +-
 cppitertools/unique_justseen.hpp               | 2 +-
 22 files changed, 22 insertions(+), 22 deletions(-)

diff --git a/cppitertools/accumulate.hpp b/cppitertools/accumulate.hpp
index 94c0c369..2c5bc54e 100644
--- a/cppitertools/accumulate.hpp
+++ b/cppitertools/accumulate.hpp
@@ -17,7 +17,7 @@ namespace iter {
 
     using AccumulateFn = IterToolFnOptionalBindSecond<Accumulator, std::plus<>>;
   }
-  constexpr impl::AccumulateFn accumulate{};
+  inline constexpr impl::AccumulateFn accumulate{};
 }
 
 template <typename Container, typename AccumulateFunc>
diff --git a/cppitertools/batched.hpp b/cppitertools/batched.hpp
index e5eadf13..f3d00ece 100644
--- a/cppitertools/batched.hpp
+++ b/cppitertools/batched.hpp
@@ -20,7 +20,7 @@ namespace iter {
 
     using BatchedFn = IterToolFnBindSizeTSecond<Batcher>;
   }
-  constexpr impl::BatchedFn batched{};
+  inline constexpr impl::BatchedFn batched{};
 }
 
 template <typename Container>
diff --git a/cppitertools/chunked.hpp b/cppitertools/chunked.hpp
index 1d03b6e1..13fa652f 100644
--- a/cppitertools/chunked.hpp
+++ b/cppitertools/chunked.hpp
@@ -20,7 +20,7 @@ namespace iter {
 
     using ChunkedFn = IterToolFnBindSizeTSecond<Chunker>;
   }
-  constexpr impl::ChunkedFn chunked{};
+  inline constexpr impl::ChunkedFn chunked{};
 }
 
 template <typename Container>
diff --git a/cppitertools/combinations.hpp b/cppitertools/combinations.hpp
index 7aca3115..cdee9cdd 100644
--- a/cppitertools/combinations.hpp
+++ b/cppitertools/combinations.hpp
@@ -15,7 +15,7 @@ namespace iter {
 
     using CombinationsFn = IterToolFnBindSizeTSecond<Combinator>;
   }
-  constexpr impl::CombinationsFn combinations{};
+  inline constexpr impl::CombinationsFn combinations{};
 }
 
 template <typename Container>
diff --git a/cppitertools/combinations_with_replacement.hpp b/cppitertools/combinations_with_replacement.hpp
index d501c6e1..39db37bd 100644
--- a/cppitertools/combinations_with_replacement.hpp
+++ b/cppitertools/combinations_with_replacement.hpp
@@ -15,7 +15,7 @@ namespace iter {
     using CombinationsWithReplacementFn =
         IterToolFnBindSizeTSecond<CombinatorWithReplacement>;
   }
-  constexpr impl::CombinationsWithReplacementFn combinations_with_replacement{};
+  inline constexpr impl::CombinationsWithReplacementFn combinations_with_replacement{};
 }
 
 template <typename Container>
diff --git a/cppitertools/cycle.hpp b/cppitertools/cycle.hpp
index 1d3ecaef..fb3ca9c7 100644
--- a/cppitertools/cycle.hpp
+++ b/cppitertools/cycle.hpp
@@ -15,7 +15,7 @@ namespace iter {
 
     using CycleFn = IterToolFn<Cycler>;
   }
-  constexpr impl::CycleFn cycle{};
+  inline constexpr impl::CycleFn cycle{};
 }
 
 template <typename Container>
diff --git a/cppitertools/dropwhile.hpp b/cppitertools/dropwhile.hpp
index dc1874b0..e751bfe3 100644
--- a/cppitertools/dropwhile.hpp
+++ b/cppitertools/dropwhile.hpp
@@ -16,7 +16,7 @@ namespace iter {
 
     using DropWhileFn = IterToolFnOptionalBindFirst<Dropper, BoolTester>;
   }
-  constexpr impl::DropWhileFn dropwhile{};
+  inline constexpr impl::DropWhileFn dropwhile{};
 }
 
 template <typename FilterFunc, typename Container>
diff --git a/cppitertools/enumerate.hpp b/cppitertools/enumerate.hpp
index e2dda12b..5d59feab 100644
--- a/cppitertools/enumerate.hpp
+++ b/cppitertools/enumerate.hpp
@@ -33,7 +33,7 @@ namespace iter {
 
     using EnumerateFn = IterToolFnOptionalBindSecond<Enumerable, std::size_t>;
   }
-  constexpr impl::EnumerateFn enumerate{};
+  inline constexpr impl::EnumerateFn enumerate{};
 }
 
 namespace std {
diff --git a/cppitertools/filter.hpp b/cppitertools/filter.hpp
index 2a632be2..1e069070 100644
--- a/cppitertools/filter.hpp
+++ b/cppitertools/filter.hpp
@@ -24,7 +24,7 @@ namespace iter {
     using FilterFn = IterToolFnOptionalBindFirst<Filtered, BoolTester>;
   }
 
-  constexpr impl::FilterFn filter{};
+  inline constexpr impl::FilterFn filter{};
 }
 
 template <typename FilterFunc, typename Container>
diff --git a/cppitertools/filterfalse.hpp b/cppitertools/filterfalse.hpp
index f0f22628..4056c402 100644
--- a/cppitertools/filterfalse.hpp
+++ b/cppitertools/filterfalse.hpp
@@ -38,7 +38,7 @@ namespace iter {
 
     using FilterFalseFn = IterToolFnOptionalBindFirst<FilterFalsed, BoolTester>;
   }
-  constexpr impl::FilterFalseFn filterfalse{};
+  inline constexpr impl::FilterFalseFn filterfalse{};
 }
 
 // Delegates to Filtered with PredicateFlipper<FilterFunc>
diff --git a/cppitertools/groupby.hpp b/cppitertools/groupby.hpp
index cac82426..6d7453f9 100644
--- a/cppitertools/groupby.hpp
+++ b/cppitertools/groupby.hpp
@@ -20,7 +20,7 @@ namespace iter {
 
     using GroupByFn = IterToolFnOptionalBindSecond<GroupProducer, Identity>;
   }
-  constexpr impl::GroupByFn groupby{};
+  inline constexpr impl::GroupByFn groupby{};
 }
 
 template <typename Container, typename KeyFunc>
diff --git a/cppitertools/imap.hpp b/cppitertools/imap.hpp
index 1e84faf0..80b8cc3d 100644
--- a/cppitertools/imap.hpp
+++ b/cppitertools/imap.hpp
@@ -21,7 +21,7 @@ namespace iter {
       using PipeableAndBindFirst<IMapFn>::operator();
     };
   }
-  constexpr impl::IMapFn imap{};
+  inline constexpr impl::IMapFn imap{};
 }
 
 #endif
diff --git a/cppitertools/permutations.hpp b/cppitertools/permutations.hpp
index e10872d4..f567bc68 100644
--- a/cppitertools/permutations.hpp
+++ b/cppitertools/permutations.hpp
@@ -17,7 +17,7 @@ namespace iter {
     class Permuter;
     using PermutationsFn = IterToolFn<Permuter>;
   }
-  constexpr impl::PermutationsFn permutations{};
+  inline constexpr impl::PermutationsFn permutations{};
 }
 
 template <typename Container>
diff --git a/cppitertools/powerset.hpp b/cppitertools/powerset.hpp
index 3439069d..d6131ca8 100644
--- a/cppitertools/powerset.hpp
+++ b/cppitertools/powerset.hpp
@@ -18,7 +18,7 @@ namespace iter {
 
     using PowersetFn = IterToolFn<Powersetter>;
   }
-  constexpr impl::PowersetFn powerset{};
+  inline constexpr impl::PowersetFn powerset{};
 }
 
 template <typename Container>
diff --git a/cppitertools/reversed.hpp b/cppitertools/reversed.hpp
index 3b914bb1..022088f6 100644
--- a/cppitertools/reversed.hpp
+++ b/cppitertools/reversed.hpp
@@ -45,7 +45,7 @@ namespace iter {
 
     using ReversedFn = IterToolFn<Reverser>;
   }
-  constexpr impl::ReversedFn reversed{};
+  inline constexpr impl::ReversedFn reversed{};
 }
 
 template <typename Container>
diff --git a/cppitertools/slice.hpp b/cppitertools/slice.hpp
index a926ecbb..38557016 100644
--- a/cppitertools/slice.hpp
+++ b/cppitertools/slice.hpp
@@ -172,7 +172,7 @@ struct iter::impl::SliceFn {
 };
 
 namespace iter {
-  constexpr impl::SliceFn slice{};
+  inline constexpr impl::SliceFn slice{};
 }
 
 #endif
diff --git a/cppitertools/sliding_window.hpp b/cppitertools/sliding_window.hpp
index d4ab6cbc..01c348ba 100644
--- a/cppitertools/sliding_window.hpp
+++ b/cppitertools/sliding_window.hpp
@@ -16,7 +16,7 @@ namespace iter {
     class WindowSlider;
     using SlidingWindowFn = IterToolFnBindSizeTSecond<WindowSlider>;
   }
-  constexpr impl::SlidingWindowFn sliding_window{};
+  inline constexpr impl::SlidingWindowFn sliding_window{};
 }
 
 template <typename Container>
diff --git a/cppitertools/sorted.hpp b/cppitertools/sorted.hpp
index 4e963228..a704af3f 100644
--- a/cppitertools/sorted.hpp
+++ b/cppitertools/sorted.hpp
@@ -15,7 +15,7 @@ namespace iter {
     class SortedView;
     using SortedFn = IterToolFnOptionalBindSecond<SortedView, std::less<>>;
   }
-  constexpr impl::SortedFn sorted{};
+  inline constexpr impl::SortedFn sorted{};
 }
 
 template <typename Container, typename CompareFunc>
diff --git a/cppitertools/starmap.hpp b/cppitertools/starmap.hpp
index fbeaad68..f9c2d260 100644
--- a/cppitertools/starmap.hpp
+++ b/cppitertools/starmap.hpp
@@ -252,7 +252,7 @@ struct iter::impl::StarMapFn : PipeableAndBindFirst<StarMapFn> {
 };
 
 namespace iter {
-  constexpr impl::StarMapFn starmap{};
+  inline constexpr impl::StarMapFn starmap{};
 }
 
 #endif
diff --git a/cppitertools/takewhile.hpp b/cppitertools/takewhile.hpp
index a04d86b2..338e43aa 100644
--- a/cppitertools/takewhile.hpp
+++ b/cppitertools/takewhile.hpp
@@ -16,7 +16,7 @@ namespace iter {
 
     using TakeWhileFn = IterToolFnOptionalBindFirst<Taker, BoolTester>;
   }
-  constexpr impl::TakeWhileFn takewhile{};
+  inline constexpr impl::TakeWhileFn takewhile{};
 }
 
 template <typename FilterFunc, typename Container>
diff --git a/cppitertools/unique_everseen.hpp b/cppitertools/unique_everseen.hpp
index 1e138d63..2195a4bd 100644
--- a/cppitertools/unique_everseen.hpp
+++ b/cppitertools/unique_everseen.hpp
@@ -45,7 +45,7 @@ namespace iter {
     };
   }
 
-  constexpr impl::UniqueEverseenFn unique_everseen{};
+  inline constexpr impl::UniqueEverseenFn unique_everseen{};
 }
 
 #endif
diff --git a/cppitertools/unique_justseen.hpp b/cppitertools/unique_justseen.hpp
index 5a566e78..c4ca47f5 100644
--- a/cppitertools/unique_justseen.hpp
+++ b/cppitertools/unique_justseen.hpp
@@ -23,7 +23,7 @@ namespace iter {
       }
     };
   }
-  constexpr impl::UniqueJustseenFn unique_justseen{};
+  inline constexpr impl::UniqueJustseenFn unique_justseen{};
 }
 
 #endif

From 78a4eaa8a3b3b45aeea1022fd8a9402321729358 Mon Sep 17 00:00:00 2001
From: Udaya Prakash <udayaprakash2899@gmail.com>
Date: Wed, 21 Aug 2024 16:33:29 +0000
Subject: [PATCH 1836/1866] Add bzlmod support to cppitertools

---
 .bazelrc      | 2 ++
 .bazelversion | 1 +
 .gitignore    | 1 -
 MODULE.bazel  | 3 +++
 4 files changed, 6 insertions(+), 1 deletion(-)
 create mode 100644 .bazelrc
 create mode 100644 .bazelversion
 create mode 100644 MODULE.bazel

diff --git a/.bazelrc b/.bazelrc
new file mode 100644
index 00000000..cbb8025a
--- /dev/null
+++ b/.bazelrc
@@ -0,0 +1,2 @@
+# workspace support is deprecated in Bazel 7
+common --enable_bzlmod
\ No newline at end of file
diff --git a/.bazelversion b/.bazelversion
new file mode 100644
index 00000000..34a8f745
--- /dev/null
+++ b/.bazelversion
@@ -0,0 +1 @@
+7.3.1
\ No newline at end of file
diff --git a/.gitignore b/.gitignore
index 553aa4a3..0d4fed27 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,2 @@
 bazel-*
-MODULE.bazel
 MODULE.bazel.lock
diff --git a/MODULE.bazel b/MODULE.bazel
new file mode 100644
index 00000000..d8dc8f72
--- /dev/null
+++ b/MODULE.bazel
@@ -0,0 +1,3 @@
+module(
+    name = "cppitertools"
+)
\ No newline at end of file

From 88de5d7cb3316231fce6e2a87e904cf3077a3def Mon Sep 17 00:00:00 2001
From: Udaya Prakash <udayaprakash2899@gmail.com>
Date: Wed, 21 Aug 2024 16:36:26 +0000
Subject: [PATCH 1837/1866] add new line

---
 .bazelversion | 2 +-
 MODULE.bazel  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.bazelversion b/.bazelversion
index 34a8f745..643916c0 100644
--- a/.bazelversion
+++ b/.bazelversion
@@ -1 +1 @@
-7.3.1
\ No newline at end of file
+7.3.1
diff --git a/MODULE.bazel b/MODULE.bazel
index d8dc8f72..b4a4568e 100644
--- a/MODULE.bazel
+++ b/MODULE.bazel
@@ -1,3 +1,3 @@
 module(
     name = "cppitertools"
-)
\ No newline at end of file
+)

From e06f15357cc9ca78029e4158bee67da9f110e34f Mon Sep 17 00:00:00 2001
From: Udaya Prakash <udayaprakash2899@gmail.com>
Date: Wed, 21 Aug 2024 16:37:36 +0000
Subject: [PATCH 1838/1866] remove bazelrc file

---
 .bazelrc | 2 --
 1 file changed, 2 deletions(-)
 delete mode 100644 .bazelrc

diff --git a/.bazelrc b/.bazelrc
deleted file mode 100644
index cbb8025a..00000000
--- a/.bazelrc
+++ /dev/null
@@ -1,2 +0,0 @@
-# workspace support is deprecated in Bazel 7
-common --enable_bzlmod
\ No newline at end of file

From 5a7f4aa357ed9b0ad59823e3d2acd57217d5beaf Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining.cpp@gmail.com>
Date: Fri, 18 Oct 2024 09:55:13 -0700
Subject: [PATCH 1839/1866] Escapes '<' and '>' in zip_longest description

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 64c1430f..7b43c218 100644
--- a/README.md
+++ b/README.md
@@ -579,7 +579,7 @@ Repeatedly yields a tuple of `boost::optional<T>`s where `T` is the type
 yielded by the sequences' respective iterators.  Because of its boost
 dependency, `zip_longest` is not in `itertools.hpp` and must be included
 separately.
-The following loop prints either "Just <item>" or "Nothing" for each
+The following loop prints either "Just \<item\>" or "Nothing" for each
 element in each tuple yielded.
 
 ```c++

From 516115a959c92f5b7f133e4f52bcd7e701c46069 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining@google.com>
Date: Wed, 5 Feb 2025 16:48:51 -0800
Subject: [PATCH 1840/1866] Updates .bazelversion to 8.0.1

---
 .bazelversion | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.bazelversion b/.bazelversion
index 643916c0..cd1d2e94 100644
--- a/.bazelversion
+++ b/.bazelversion
@@ -1 +1 @@
-7.3.1
+8.0.1

From 371888d0f9c1ee687c8c1241c8c86ebed26929d6 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining@google.com>
Date: Thu, 6 Feb 2025 16:41:33 -0800
Subject: [PATCH 1841/1866] Adds undefinide and address sanitizer to tests

---
 test/BUILD | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/test/BUILD b/test/BUILD
index 9ceefecd..cc9aefe6 100644
--- a/test/BUILD
+++ b/test/BUILD
@@ -37,10 +37,13 @@ progs = [
     "helpers",
 ]
 
+SANITIZE = "-fsanitize=address,undefined"
+
 cc_library(
   name = "test_main",
   srcs = ["test_main.cpp", "catch.hpp"],
-  copts = ["-std=c++17", "-g"]
+  copts = [SANITIZE, "-Wall", "-Wextra", "-std=c++17", "-g"],
+  linkopts = [SANITIZE],
 )
 
 itertools_tests(progs)

From d4c7340b44e141874b749a2c08489cb3ae180a71 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining@google.com>
Date: Thu, 6 Feb 2025 16:42:19 -0800
Subject: [PATCH 1842/1866] Suppresses bad dangling reference warning

Fixes #108
---
 cppitertools/internal/iterbase.hpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/cppitertools/internal/iterbase.hpp b/cppitertools/internal/iterbase.hpp
index 6f654828..9a8b33ba 100644
--- a/cppitertools/internal/iterbase.hpp
+++ b/cppitertools/internal/iterbase.hpp
@@ -353,6 +353,9 @@ namespace iter {
     template <typename ItTool>
     struct Pipeable {
       template <typename T>
+#if  defined(__GNUC__) && !defined(__clang__)
+        [[gnu::no_dangling]]
+#endif
       friend decltype(auto) operator|(T&& x, const Pipeable& p) {
         return static_cast<const ItTool&>(p)(std::forward<T>(x));
       }

From fa6ee1a8b93c374185abd69e374ce9f4fd054cb4 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining@google.com>
Date: Mon, 10 Feb 2025 12:44:31 -0800
Subject: [PATCH 1843/1866] Moves utility callables into helpers.hpp

Cleanup while doing #89
---
 test/helpers.hpp          | 16 +++++++++++++++
 test/test_dropwhile.cpp   | 24 +---------------------
 test/test_filter.cpp      | 22 +-------------------
 test/test_filterfalse.cpp | 22 +-------------------
 test/test_takewhile.cpp   | 43 +++++++++++++--------------------------
 5 files changed, 33 insertions(+), 94 deletions(-)

diff --git a/test/helpers.hpp b/test/helpers.hpp
index 80167980..57f8a372 100644
--- a/test/helpers.hpp
+++ b/test/helpers.hpp
@@ -414,4 +414,20 @@ class IntCharPairRange
       : DiffEndRange<std::pair<int, char>, IncIntCharPair>({0, 'a'}, stop) {}
 };
 
+inline bool less_than_five(int i) {
+  return i < 5;
+}
+
+class LessThanValue {
+ private:
+  int compare_val;
+
+ public:
+  LessThanValue(int v) : compare_val(v) {}
+
+  bool operator()(int i) {
+    return i < this->compare_val;
+  }
+};
+
 #endif
diff --git a/test/test_dropwhile.cpp b/test/test_dropwhile.cpp
index 2a41a671..97c947f4 100644
--- a/test/test_dropwhile.cpp
+++ b/test/test_dropwhile.cpp
@@ -1,31 +1,15 @@
 #include <cppitertools/dropwhile.hpp>
-
-#include "helpers.hpp"
-
 #include <iterator>
 #include <string>
 #include <vector>
 
 #include "catch.hpp"
+#include "helpers.hpp"
 
 using iter::dropwhile;
 
 using Vec = const std::vector<int>;
 
-namespace {
-  class LessThanValue {
-   private:
-    int compare_val;
-
-   public:
-    LessThanValue(int v) : compare_val(v) {}
-
-    bool operator()(int i) {
-      return i < this->compare_val;
-    }
-  };
-}
-
 TEST_CASE("dropwhile: skips initial elements", "[dropwhile]") {
   Vec ns{1, 2, 3, 4, 5, 6, 7, 8};
   std::vector<int> v;
@@ -147,12 +131,6 @@ TEST_CASE("dropwhile: operator->", "[dropwhile]") {
   REQUIRE(it->size() == 6);
 }
 
-namespace {
-  int less_than_five(int i) {
-    return i < 5;
-  }
-}
-
 TEST_CASE("dropwhile: works with function pointer", "[dropwhile]") {
   Vec ns{1, 2, 3, 4, 5, 6, 7, 8};
   auto d = dropwhile(less_than_five, ns);
diff --git a/test/test_filter.cpp b/test/test_filter.cpp
index f160785b..a990844a 100644
--- a/test/test_filter.cpp
+++ b/test/test_filter.cpp
@@ -1,35 +1,15 @@
 #include <cppitertools/filter.hpp>
-
-#include "helpers.hpp"
-
 #include <iterator>
 #include <string>
 #include <vector>
 
 #include "catch.hpp"
+#include "helpers.hpp"
 
 using iter::filter;
 
 using Vec = const std::vector<int>;
 
-namespace {
-  bool less_than_five(int i) {
-    return i < 5;
-  }
-
-  class LessThanValue {
-   private:
-    int compare_val;
-
-   public:
-    LessThanValue(int v) : compare_val(v) {}
-
-    bool operator()(int i) {
-      return i < this->compare_val;
-    }
-  };
-}
-
 TEST_CASE("filter: handles different callable types", "[filter]") {
   Vec ns = {1, 2, 5, 6, 3, 1, 7, -1, 5};
   Vec vc = {1, 2, 3, 1, -1};
diff --git a/test/test_filterfalse.cpp b/test/test_filterfalse.cpp
index 93d50d6a..9a1dd4bc 100644
--- a/test/test_filterfalse.cpp
+++ b/test/test_filterfalse.cpp
@@ -1,35 +1,15 @@
 #include <cppitertools/filterfalse.hpp>
-
-#include "helpers.hpp"
-
 #include <iterator>
 #include <string>
 #include <vector>
 
 #include "catch.hpp"
+#include "helpers.hpp"
 
 using iter::filterfalse;
 
 using Vec = const std::vector<int>;
 
-namespace {
-  bool less_than_five(int i) {
-    return i < 5;
-  }
-
-  class LessThanValue {
-   private:
-    int compare_val;
-
-   public:
-    LessThanValue(int v) : compare_val(v) {}
-
-    bool operator()(int i) {
-      return i < this->compare_val;
-    }
-  };
-}
-
 TEST_CASE("filterfalse: handles different callable types", "[filterfalse]") {
   Vec ns = {1, 2, 5, 6, 3, 1, 7, -1, 5};
   Vec vc = {5, 6, 7, 5};
diff --git a/test/test_takewhile.cpp b/test/test_takewhile.cpp
index e3dade73..0be43f84 100644
--- a/test/test_takewhile.cpp
+++ b/test/test_takewhile.cpp
@@ -1,6 +1,5 @@
-#include <cppitertools/takewhile.hpp>
-
 #include <array>
+#include <cppitertools/takewhile.hpp>
 #include <string>
 #include <utility>
 #include <vector>
@@ -11,48 +10,34 @@
 using iter::takewhile;
 using Vec = const std::vector<int>;
 
-namespace {
-  bool under_ten(int i) {
-    return i < 10;
-  }
-
-  struct UnderTen {
-    bool operator()(int i) {
-      return i < 10;
-    }
-  };
-}
-
 TEST_CASE("takewhile: works with lambda, callable, and function pointer",
     "[takewhile]") {
-  Vec ns = {1, 3, 5, 20, 2, 4, 6, 8};
+  Vec ns = {1, 3, 4, 20, 2, 4, 6, 8};
+  const Vec vc = {1, 3, 4};
   SECTION("function pointer") {
-    auto tw = takewhile(under_ten, ns);
+    auto tw = takewhile(less_than_five, ns);
     Vec v(std::begin(tw), std::end(tw));
-    Vec vc = {1, 3, 5};
     REQUIRE(v == vc);
   }
 
   SECTION("callable object") {
     std::vector<int> v;
     SECTION("Normal call") {
-      auto tw = takewhile(UnderTen{}, ns);
+      auto tw = takewhile(LessThanValue{10}, ns);
       v.assign(std::begin(tw), std::end(tw));
     }
 
     SECTION("Pipe") {
-      auto tw = ns | takewhile(UnderTen{});
+      auto tw = ns | takewhile(LessThanValue{10});
       v.assign(std::begin(tw), std::end(tw));
     }
 
-    Vec vc = {1, 3, 5};
     REQUIRE(v == vc);
   }
 
   SECTION("lambda") {
     auto tw = takewhile([](int i) { return i < 10; }, ns);
     Vec v(std::begin(tw), std::end(tw));
-    Vec vc = {1, 3, 5};
     REQUIRE(v == vc);
   }
 }
@@ -78,7 +63,7 @@ TEST_CASE("takewhile: handles pointer to member", "[takewhile]") {
 
 TEST_CASE("takewhile: supports const iteration", "[takewhile][const]") {
   Vec ns = {1, 3, 5, 20, 2, 4, 6, 8};
-  const auto tw = takewhile(UnderTen{}, ns);
+  const auto tw = takewhile(LessThanValue{10}, ns);
   Vec v(std::begin(tw), std::end(tw));
   Vec vc = {1, 3, 5};
   REQUIRE(v == vc);
@@ -86,7 +71,7 @@ TEST_CASE("takewhile: supports const iteration", "[takewhile][const]") {
 
 TEST_CASE("takewhile: const iterator and non-const iterator are comparable",
     "[takewhile][const]") {
-  auto tw = takewhile(UnderTen{}, Vec{});
+  auto tw = takewhile(LessThanValue{10}, Vec{});
   const auto& ctw = tw;
   (void)(std::begin(tw) == std::end(ctw));
 }
@@ -117,14 +102,14 @@ TEST_CASE("takewhile: identity", "[takewhile]") {
 
 TEST_CASE("takewhile: everything passes predicate", "[takewhile]") {
   Vec ns{1, 2, 3};
-  auto tw = takewhile(under_ten, ns);
+  auto tw = takewhile(less_than_five, ns);
   Vec v(std::begin(tw), std::end(tw));
   Vec vc = {1, 2, 3};
 }
 
 TEST_CASE("takewhile: empty iterable is empty", "[takewhile]") {
   Vec ns{};
-  auto tw = takewhile(under_ten, ns);
+  auto tw = takewhile(less_than_five, ns);
   SECTION("normal compare") {
     REQUIRE(std::begin(tw) == std::end(tw));
   }
@@ -138,7 +123,7 @@ TEST_CASE(
     "[takewhile]") {
   SECTION("First element is only element") {
     Vec ns = {20};
-    auto tw = takewhile(under_ten, ns);
+    auto tw = takewhile(less_than_five, ns);
     SECTION("normal compare") {
       REQUIRE(std::begin(tw) == std::end(tw));
     }
@@ -149,7 +134,7 @@ TEST_CASE(
 
   SECTION("First element followed by elements that pass") {
     Vec ns = {20, 1, 1};
-    auto tw = takewhile(under_ten, ns);
+    auto tw = takewhile(less_than_five, ns);
     SECTION("normal compare") {
       REQUIRE(std::begin(tw) == std::end(tw));
     }
@@ -161,10 +146,10 @@ TEST_CASE(
 
 TEST_CASE("takewhile: moves rvalues, binds to lvalues", "[takewhile]") {
   itertest::BasicIterable<int> bi{1, 2};
-  takewhile(under_ten, bi);
+  takewhile(less_than_five, bi);
   REQUIRE_FALSE(bi.was_moved_from());
 
-  takewhile(under_ten, std::move(bi));
+  takewhile(less_than_five, std::move(bi));
   REQUIRE(bi.was_moved_from());
 }
 

From f9ce3d8d4eff145061df406f14265a4cc8946d6f Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining@google.com>
Date: Mon, 10 Feb 2025 13:03:10 -0800
Subject: [PATCH 1844/1866] Adds MoveOnlyLessThanValue for testing

For #89
---
 test/helpers.hpp | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/test/helpers.hpp b/test/helpers.hpp
index 57f8a372..94fd08f1 100644
--- a/test/helpers.hpp
+++ b/test/helpers.hpp
@@ -430,4 +430,22 @@ class LessThanValue {
   }
 };
 
+class MoveOnlyLessThanValue {
+ private:
+  int compare_val;
+
+ public:
+  MoveOnlyLessThanValue(int v) : compare_val(v) {}
+
+  MoveOnlyLessThanValue(const MoveOnlyLessThanValue&) = delete;
+  MoveOnlyLessThanValue& operator=(const MoveOnlyLessThanValue&) = delete;
+
+  MoveOnlyLessThanValue(MoveOnlyLessThanValue&&) = default;
+  MoveOnlyLessThanValue& operator=(MoveOnlyLessThanValue&&) = default;
+
+  bool operator()(int i) {
+    return i < this->compare_val;
+  }
+};
+
 #endif

From 420583c1df803566942e1c70c61ef5986d85006e Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining@google.com>
Date: Mon, 10 Feb 2025 13:10:55 -0800
Subject: [PATCH 1845/1866] IncludeBlocks: Preserve in clang-format

---
 .clang-format | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.clang-format b/.clang-format
index 650739d3..d9d9622a 100644
--- a/.clang-format
+++ b/.clang-format
@@ -8,5 +8,6 @@ BreakBeforeBinaryOperators: NonAssignment
 DerivePointerAlignment: false
 NamespaceIndentation: All
 FixNamespaceComments: false
+IncludeBlocks: Preserve
 ...
 

From 1c828d06d73d6bdd1ee6649619ef61b459d0957a Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining@google.com>
Date: Mon, 10 Feb 2025 13:11:58 -0800
Subject: [PATCH 1846/1866] Adds move-only callable support to filter

Issue #89
---
 cppitertools/filter.hpp | 4 +++-
 test/test_filter.cpp    | 6 ++++++
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/cppitertools/filter.hpp b/cppitertools/filter.hpp
index 1e069070..53ed15cc 100644
--- a/cppitertools/filter.hpp
+++ b/cppitertools/filter.hpp
@@ -29,6 +29,8 @@ namespace iter {
 
 template <typename FilterFunc, typename Container>
 class iter::impl::Filtered {
+  static_assert(!std::is_reference_v<FilterFunc>);
+
  private:
   Container container_;
   mutable FilterFunc filter_func_;
@@ -39,7 +41,7 @@ class iter::impl::Filtered {
   // Value constructor for use only in the filter function
   Filtered(FilterFunc filter_func, Container&& container)
       : container_(std::forward<Container>(container)),
-        filter_func_(filter_func) {}
+        filter_func_(std::move(filter_func)) {}
 
  public:
   Filtered(Filtered&&) = default;
diff --git a/test/test_filter.cpp b/test/test_filter.cpp
index a990844a..a0f5db96 100644
--- a/test/test_filter.cpp
+++ b/test/test_filter.cpp
@@ -25,6 +25,12 @@ TEST_CASE("filter: handles different callable types", "[filter]") {
     REQUIRE(v == vc);
   }
 
+  SECTION("with move-only callable object") {
+    auto f = filter(MoveOnlyLessThanValue{5}, ns);
+    Vec v(std::begin(f), std::end(f));
+    REQUIRE(v == vc);
+  }
+
   SECTION("with lambda") {
     auto ltf = [](int i) { return i < 5; };
     auto f = filter(ltf, ns);

From d45c47b75f28c976ae06cb472fcd29905b1bc207 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining@google.com>
Date: Wed, 12 Feb 2025 16:30:40 -0800
Subject: [PATCH 1847/1866] Updates FnPartials to move stored_arg when rvalue

Overloads `operator|` for rvalue and lvalue `Pipeable`s and downcasts
accordingly.

Adds rvalue-reference qualified overloads to FnPartial `operator|`
that calls `std::move(stored_arg)` when creating the actual iterable
object.

This allows a move-only callable to get passed by value, but only moves,
all the way into the itertool.

```
// both should work
iter::some_itertool(sequence, MoveOnlyCallable{});
sequence | iter::some_itertool(MoveOnlyCallable{});
```

I did attempt passing a `std::reference_wrapper` from the `FnPartial`
but the iteration happens after the `FnPartial` is destroyed, So the
following is unsafe:
```
// unsafe, wrong
template <typename Container>
auto operator()(Container&& container) const {
  if constexpr (std::is_copy_constructible_v<T>) {
    return F{}(stored_arg, std::forward<Container>(container));
  } else {
    return F{}(std::ref(stored_arg), std::forward<Container>(container));
  }
}
```

Setting the stage to fix #89
---
 cppitertools/internal/iterbase.hpp | 38 +++++++++++++++++++++++-------
 1 file changed, 30 insertions(+), 8 deletions(-)

diff --git a/cppitertools/internal/iterbase.hpp b/cppitertools/internal/iterbase.hpp
index 9a8b33ba..9cb97442 100644
--- a/cppitertools/internal/iterbase.hpp
+++ b/cppitertools/internal/iterbase.hpp
@@ -353,9 +353,14 @@ namespace iter {
     template <typename ItTool>
     struct Pipeable {
       template <typename T>
-#if  defined(__GNUC__) && !defined(__clang__)
-        [[gnu::no_dangling]]
+#if defined(__GNUC__) && !defined(__clang__)
+      [[gnu::no_dangling]]
 #endif
+      friend decltype(auto) operator|(T&& x, Pipeable&& p) {
+        return static_cast<ItTool&&>(p)(std::forward<T>(x));
+      }
+
+      template <typename T>
       friend decltype(auto) operator|(T&& x, const Pipeable& p) {
         return static_cast<const ItTool&>(p)(std::forward<T>(x));
       }
@@ -378,11 +383,17 @@ namespace iter {
      protected:
       template <typename T>
       struct FnPartial : Pipeable<FnPartial<T>> {
+        static_assert(!std::is_reference_v<T>);
         mutable T stored_arg;
-        constexpr FnPartial(T in_t) : stored_arg(in_t) {}
+        constexpr FnPartial(T in_t) : stored_arg(std::move(in_t)) {}
 
         template <typename Container>
-        auto operator()(Container&& container) const {
+        auto operator()(Container&& container) && {
+          return F{}(std::move(stored_arg), std::forward<Container>(container));
+        }
+
+        template <typename Container>
+        auto operator()(Container&& container) const& {
           return F{}(stored_arg, std::forward<Container>(container));
         }
       };
@@ -403,10 +414,15 @@ namespace iter {
       template <typename T>
       struct FnPartial : Pipeable<FnPartial<T>> {
         mutable T stored_arg;
-        constexpr FnPartial(T in_t) : stored_arg(in_t) {}
+        constexpr FnPartial(T in_t) : stored_arg(std::move(in_t)) {}
 
         template <typename Container>
-        auto operator()(Container&& container) const {
+        auto operator()(Container&& container) && {
+          return F{}(std::forward<Container>(container), std::move(stored_arg));
+        }
+
+        template <typename Container>
+        auto operator()(Container&& container) const& {
           return F{}(std::forward<Container>(container), stored_arg);
         }
       };
@@ -469,10 +485,16 @@ namespace iter {
       template <typename T>
       struct FnPartial : Pipeable<FnPartial<T>> {
         mutable T stored_arg;
-        constexpr FnPartial(T in_t) : stored_arg(in_t) {}
+        constexpr FnPartial(T in_t) : stored_arg(std::move(in_t)) {}
 
         template <typename Container>
-        auto operator()(Container&& container) const {
+        auto operator()(Container&& container) && {
+          return IterToolFnOptionalBindSecond{}(
+              std::forward<Container>(container), std::move(stored_arg));
+        }
+
+        template <typename Container>
+        auto operator()(Container&& container) const& {
           return IterToolFnOptionalBindSecond{}(
               std::forward<Container>(container), stored_arg);
         }

From dcc59d65c5036693c114f5a03b611b900180c83e Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining@google.com>
Date: Wed, 12 Feb 2025 16:52:11 -0800
Subject: [PATCH 1848/1866] Uses unique_ptr in move-only callable for louder
 error

Issue #89
---
 test/helpers.hpp | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/test/helpers.hpp b/test/helpers.hpp
index 94fd08f1..f94250f3 100644
--- a/test/helpers.hpp
+++ b/test/helpers.hpp
@@ -3,6 +3,7 @@
 
 #include <cppitertools/internal/iterbase.hpp>
 #include <iostream>
+#include <memory>
 #include <sstream>
 #include <stdexcept>
 #include <type_traits>
@@ -432,10 +433,12 @@ class LessThanValue {
 
 class MoveOnlyLessThanValue {
  private:
-  int compare_val;
+  // unique_ptr is better for triggering asan than an int if there's a dangling
+  // reference to the callable
+  std::unique_ptr<int> compare_val;
 
  public:
-  MoveOnlyLessThanValue(int v) : compare_val(v) {}
+  MoveOnlyLessThanValue(int v) : compare_val{std::make_unique<int>(v)} {}
 
   MoveOnlyLessThanValue(const MoveOnlyLessThanValue&) = delete;
   MoveOnlyLessThanValue& operator=(const MoveOnlyLessThanValue&) = delete;
@@ -444,7 +447,7 @@ class MoveOnlyLessThanValue {
   MoveOnlyLessThanValue& operator=(MoveOnlyLessThanValue&&) = default;
 
   bool operator()(int i) {
-    return i < this->compare_val;
+    return i < *compare_val;
   }
 };
 

From 0fc1cf1a3d889da8a8d390faedf4e4dcfc68e437 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining@google.com>
Date: Wed, 12 Feb 2025 16:53:13 -0800
Subject: [PATCH 1849/1866] Adds filter tests with pipe and move-only

Issue #89
---
 test/test_filter.cpp | 34 +++++++++++++++++++++++++---------
 1 file changed, 25 insertions(+), 9 deletions(-)

diff --git a/test/test_filter.cpp b/test/test_filter.cpp
index a0f5db96..445476c8 100644
--- a/test/test_filter.cpp
+++ b/test/test_filter.cpp
@@ -13,30 +13,46 @@ using Vec = const std::vector<int>;
 TEST_CASE("filter: handles different callable types", "[filter]") {
   Vec ns = {1, 2, 5, 6, 3, 1, 7, -1, 5};
   Vec vc = {1, 2, 3, 1, -1};
+  std::vector<int> v;
   SECTION("with function pointer") {
     auto f = filter(less_than_five, ns);
-    Vec v(std::begin(f), std::end(f));
-    REQUIRE(v == vc);
+    v = Vec(std::begin(f), std::end(f));
   }
 
   SECTION("with callable object") {
     auto f = filter(LessThanValue{5}, ns);
-    Vec v(std::begin(f), std::end(f));
-    REQUIRE(v == vc);
+    v = Vec(std::begin(f), std::end(f));
+  }
+
+  SECTION("with lvalue callable object") {
+    auto lt = LessThanValue{5};
+    SECTION("normal call") {
+      auto f = filter(lt, ns);
+      v = Vec(std::begin(f), std::end(f));
+    }
+    SECTION("pipe") {
+      auto f = ns | filter(lt);
+      v = Vec(std::begin(f), std::end(f));
+    }
   }
 
   SECTION("with move-only callable object") {
-    auto f = filter(MoveOnlyLessThanValue{5}, ns);
-    Vec v(std::begin(f), std::end(f));
-    REQUIRE(v == vc);
+    SECTION("normal call") {
+      auto f = filter(MoveOnlyLessThanValue{5}, ns);
+      v = Vec(std::begin(f), std::end(f));
+    }
+    SECTION("pipe") {
+      auto f = ns | filter(MoveOnlyLessThanValue{5});
+      v = Vec(std::begin(f), std::end(f));
+    }
   }
 
   SECTION("with lambda") {
     auto ltf = [](int i) { return i < 5; };
     auto f = filter(ltf, ns);
-    Vec v(std::begin(f), std::end(f));
-    REQUIRE(v == vc);
+    v = Vec(std::begin(f), std::end(f));
   }
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("filter: handles pointer to member", "[filter]") {

From 020f99db7570a39f281fcde6e59da154de58995d Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining@google.com>
Date: Wed, 12 Feb 2025 17:04:21 -0800
Subject: [PATCH 1850/1866] Adds support for move-only callables in filterfalse

Issue #89
---
 cppitertools/filterfalse.hpp |  3 ++-
 test/test_filterfalse.cpp    | 39 +++++++++++++++++++++++++-----------
 2 files changed, 29 insertions(+), 13 deletions(-)

diff --git a/cppitertools/filterfalse.hpp b/cppitertools/filterfalse.hpp
index 4056c402..269724dd 100644
--- a/cppitertools/filterfalse.hpp
+++ b/cppitertools/filterfalse.hpp
@@ -48,7 +48,8 @@ class iter::impl::FilterFalsed
   friend FilterFalseFn;
   FilterFalsed(FilterFunc in_filter_func, Container&& in_container)
       : Filtered<PredicateFlipper<FilterFunc>, Container>(
-            {in_filter_func}, std::forward<Container>(in_container)) {}
+            {std::move(in_filter_func)},
+            std::forward<Container>(in_container)) {}
 };
 
 #endif
diff --git a/test/test_filterfalse.cpp b/test/test_filterfalse.cpp
index 9a1dd4bc..ad79646a 100644
--- a/test/test_filterfalse.cpp
+++ b/test/test_filterfalse.cpp
@@ -13,31 +13,46 @@ using Vec = const std::vector<int>;
 TEST_CASE("filterfalse: handles different callable types", "[filterfalse]") {
   Vec ns = {1, 2, 5, 6, 3, 1, 7, -1, 5};
   Vec vc = {5, 6, 7, 5};
+  std::vector<int> v;
   SECTION("with function pointer") {
     auto f = filterfalse(less_than_five, ns);
-    Vec v(std::begin(f), std::end(f));
-    REQUIRE(v == vc);
+    v = Vec(std::begin(f), std::end(f));
   }
 
   SECTION("with callable object") {
-    std::vector<int> v;
-    SECTION("Normal call") {
-      auto f = filterfalse(LessThanValue{5}, ns);
-      v.assign(std::begin(f), std::end(f));
+    auto f = filterfalse(LessThanValue{5}, ns);
+    v = Vec(std::begin(f), std::end(f));
+  }
+
+  SECTION("with lvalue callable object") {
+    auto lt = LessThanValue{5};
+    SECTION("normal call") {
+      auto f = filterfalse(lt, ns);
+      v = Vec(std::begin(f), std::end(f));
+    }
+    SECTION("pipe") {
+      auto f = ns | filterfalse(lt);
+      v = Vec(std::begin(f), std::end(f));
     }
-    SECTION("Pipe") {
-      auto f = ns | filterfalse(LessThanValue{5});
-      v.assign(std::begin(f), std::end(f));
+  }
+
+  SECTION("with move-only callable object") {
+    SECTION("normal call") {
+      auto f = filterfalse(MoveOnlyLessThanValue{5}, ns);
+      v = Vec(std::begin(f), std::end(f));
+    }
+    SECTION("pipe") {
+      auto f = ns | filterfalse(MoveOnlyLessThanValue{5});
+      v = Vec(std::begin(f), std::end(f));
     }
-    REQUIRE(v == vc);
   }
 
   SECTION("with lambda") {
     auto ltf = [](int i) { return i < 5; };
     auto f = filterfalse(ltf, ns);
-    Vec v(std::begin(f), std::end(f));
-    REQUIRE(v == vc);
+    v = Vec(std::begin(f), std::end(f));
   }
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("filterfalse: handles pointer to member", "[filterfalse]") {

From f9f7de419c7360c97281cc35db02c3d689aa005b Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining@google.com>
Date: Wed, 12 Feb 2025 17:04:52 -0800
Subject: [PATCH 1851/1866] Adds support for move-only callables in dropwhile

Issue #89
---
 cppitertools/dropwhile.hpp |  2 +-
 test/test_dropwhile.cpp    | 45 ++++++++++++++++++++++++++++++++++++++
 2 files changed, 46 insertions(+), 1 deletion(-)

diff --git a/cppitertools/dropwhile.hpp b/cppitertools/dropwhile.hpp
index e751bfe3..86942826 100644
--- a/cppitertools/dropwhile.hpp
+++ b/cppitertools/dropwhile.hpp
@@ -29,7 +29,7 @@ class iter::impl::Dropper {
 
   Dropper(FilterFunc filter_func, Container&& container)
       : container_(std::forward<Container>(container)),
-        filter_func_(filter_func) {}
+        filter_func_(std::move(filter_func)) {}
 
  public:
   Dropper(Dropper&&) = default;
diff --git a/test/test_dropwhile.cpp b/test/test_dropwhile.cpp
index 97c947f4..077bfd73 100644
--- a/test/test_dropwhile.cpp
+++ b/test/test_dropwhile.cpp
@@ -10,6 +10,51 @@ using iter::dropwhile;
 
 using Vec = const std::vector<int>;
 
+TEST_CASE("dropwhile: handles different callable types", "[dropwhile]") {
+  Vec ns = {1, 3, 4, 20, 2, 4, 6, 8};
+  Vec vc = {20, 2, 4, 6, 8};
+  std::vector<int> v;
+  SECTION("with function pointer") {
+    auto d = dropwhile(less_than_five, ns);
+    v = Vec(std::begin(d), std::end(d));
+  }
+
+  SECTION("with callable object") {
+    auto d = dropwhile(LessThanValue{5}, ns);
+    v = Vec(std::begin(d), std::end(d));
+  }
+
+  SECTION("with lvalue callable object") {
+    auto lt = LessThanValue{5};
+    SECTION("normal call") {
+      auto d = dropwhile(lt, ns);
+      v = Vec(std::begin(d), std::end(d));
+    }
+    SECTION("pipe") {
+      auto d = ns | dropwhile(lt);
+      v = Vec(std::begin(d), std::end(d));
+    }
+  }
+
+  SECTION("with move-only callable object") {
+    SECTION("normal call") {
+      auto d = dropwhile(MoveOnlyLessThanValue{5}, ns);
+      v = Vec(std::begin(d), std::end(d));
+    }
+    SECTION("pipe") {
+      auto d = ns | dropwhile(MoveOnlyLessThanValue{5});
+      v = Vec(std::begin(d), std::end(d));
+    }
+  }
+
+  SECTION("with lambda") {
+    auto ltf = [](int i) { return i < 5; };
+    auto d = dropwhile(ltf, ns);
+    v = Vec(std::begin(d), std::end(d));
+  }
+  REQUIRE(v == vc);
+}
+
 TEST_CASE("dropwhile: skips initial elements", "[dropwhile]") {
   Vec ns{1, 2, 3, 4, 5, 6, 7, 8};
   std::vector<int> v;

From 35fdf0c9fba07476d4d07f608396640d6d6d2c47 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining@google.com>
Date: Wed, 12 Feb 2025 17:05:23 -0800
Subject: [PATCH 1852/1866] Adds support for move-only callables to groupby

Issue #89
---
 cppitertools/groupby.hpp |  3 +-
 test/test_groupby.cpp    | 74 +++++++++++++++++++++++++++++++++++-----
 2 files changed, 67 insertions(+), 10 deletions(-)

diff --git a/cppitertools/groupby.hpp b/cppitertools/groupby.hpp
index 6d7453f9..313f088a 100644
--- a/cppitertools/groupby.hpp
+++ b/cppitertools/groupby.hpp
@@ -35,7 +35,8 @@ class iter::impl::GroupProducer {
   using key_func_ret = std::invoke_result_t<KeyFunc, iterator_deref<T>>;
 
   GroupProducer(Container&& container, KeyFunc key_func)
-      : container_(std::forward<Container>(container)), key_func_(key_func) {}
+      : container_(std::forward<Container>(container)),
+        key_func_(std::move(key_func)) {}
 
  public:
   GroupProducer(GroupProducer&&) = default;
diff --git a/test/test_groupby.cpp b/test/test_groupby.cpp
index 6ce9d479..5904c78d 100644
--- a/test/test_groupby.cpp
+++ b/test/test_groupby.cpp
@@ -3,6 +3,7 @@
 #include "helpers.hpp"
 
 #include <iterator>
+#include <memory>
 #include <string>
 #include <vector>
 
@@ -21,22 +22,38 @@ namespace {
     }
   };
 
+  struct MoveOnlySizer {
+    // here to trigger asan if a dangling reference gets used
+    std::unique_ptr<int> counter_ = std::make_unique<int>();
+
+    MoveOnlySizer(const MoveOnlySizer&) = delete;
+    MoveOnlySizer& operator=(const MoveOnlySizer&) = delete;
+
+    MoveOnlySizer(MoveOnlySizer&&) = default;
+    MoveOnlySizer& operator=(MoveOnlySizer&&) = default;
+
+    int operator()(const std::string& s) {
+      ++*counter_;
+      return s.size();
+    }
+  };
+
   const std::vector<std::string> vec = {
       "hi", "ab", "ho", "abc", "def", "abcde", "efghi"};
 }
 
-TEST_CASE("groupby: works with lambda, callable, and function pointer") {
+TEST_CASE("groupby: handles different callable types", "[groupby]") {
   std::vector<int> keys;
   std::vector<std::vector<std::string>> groups;
 
-  SECTION("Function pointer") {
-    SECTION("Normal call") {
+  SECTION("with function pointer") {
+    SECTION("normal call") {
       for (auto&& gb : groupby(vec, length)) {
         keys.push_back(gb.first);
         groups.emplace_back(std::begin(gb.second), std::end(gb.second));
       }
     }
-    SECTION("Pipe") {
+    SECTION("pipe") {
       for (auto&& gb : vec | groupby(length)) {
         keys.push_back(gb.first);
         groups.emplace_back(std::begin(gb.second), std::end(gb.second));
@@ -44,14 +61,53 @@ TEST_CASE("groupby: works with lambda, callable, and function pointer") {
     }
   }
 
-  SECTION("Callable object") {
-    for (auto&& gb : groupby(vec, Sizer{})) {
-      keys.push_back(gb.first);
-      groups.emplace_back(std::begin(gb.second), std::end(gb.second));
+  SECTION("with callable object") {
+    SECTION("normal call") {
+      for (auto&& gb : groupby(vec, Sizer{})) {
+        keys.push_back(gb.first);
+        groups.emplace_back(std::begin(gb.second), std::end(gb.second));
+      }
+    }
+    SECTION("pipe") {
+      for (auto&& gb : vec | groupby(Sizer{})) {
+        keys.push_back(gb.first);
+        groups.emplace_back(std::begin(gb.second), std::end(gb.second));
+      }
     }
   }
 
-  SECTION("lambda function") {
+  SECTION("with lvalue callable object") {
+    auto sizer = Sizer{};
+    SECTION("normal call") {
+      for (auto&& gb : groupby(vec, sizer)) {
+        keys.push_back(gb.first);
+        groups.emplace_back(std::begin(gb.second), std::end(gb.second));
+      }
+    }
+    SECTION("pipe") {
+      for (auto&& gb : vec | groupby(sizer)) {
+        keys.push_back(gb.first);
+        groups.emplace_back(std::begin(gb.second), std::end(gb.second));
+      }
+    }
+  }
+
+  SECTION("with move-only callable object") {
+    SECTION("normal call") {
+      for (auto&& gb : groupby(vec, MoveOnlySizer{})) {
+        keys.push_back(gb.first);
+        groups.emplace_back(std::begin(gb.second), std::end(gb.second));
+      }
+    }
+    SECTION("pipe") {
+      for (auto&& gb : vec | groupby(MoveOnlySizer{})) {
+        keys.push_back(gb.first);
+        groups.emplace_back(std::begin(gb.second), std::end(gb.second));
+      }
+    }
+  }
+
+  SECTION("with lambda") {
     for (auto&& gb :
         groupby(vec, [](const std::string& s) { return s.size(); })) {
       keys.push_back(gb.first);

From 417b1ebe067a381585def401c2f94a8c1ae20476 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining@google.com>
Date: Wed, 12 Feb 2025 17:06:29 -0800
Subject: [PATCH 1853/1866] Adds support for move-only callables to imap

Issue #89
---
 cppitertools/imap.hpp |  3 +-
 test/test_imap.cpp    | 72 ++++++++++++++++++++++++++++++++-----------
 2 files changed, 56 insertions(+), 19 deletions(-)

diff --git a/cppitertools/imap.hpp b/cppitertools/imap.hpp
index 80b8cc3d..21ca2e81 100644
--- a/cppitertools/imap.hpp
+++ b/cppitertools/imap.hpp
@@ -16,7 +16,8 @@ namespace iter {
           // See #66
           -> StarMapper<MapFunc,
               decltype(zip(std::forward<Containers>(containers)...))> {
-        return starmap(map_func, zip(std::forward<Containers>(containers)...));
+        return starmap(
+            std::move(map_func), zip(std::forward<Containers>(containers)...));
       }
       using PipeableAndBindFirst<IMapFn>::operator();
     };
diff --git a/test/test_imap.cpp b/test/test_imap.cpp
index 40a9d3e3..cfda992b 100644
--- a/test/test_imap.cpp
+++ b/test/test_imap.cpp
@@ -17,10 +17,29 @@ namespace {
     return i + 1;
   }
 
-  class PlusOner {
+  struct PlusOner {
+    int operator()(int i) const {
+      return i + 1;
+    }
+  };
+
+  class MoveOnlyAdder {
+   private:
+    // unique_ptr is better for triggering asan than an int if there's a
+    // dangling reference to the callable
+    std::unique_ptr<int> add_amount_;
+
    public:
+    MoveOnlyAdder(int v) : add_amount_{std::make_unique<int>(v)} {}
+
+    MoveOnlyAdder(const MoveOnlyAdder&) = delete;
+    MoveOnlyAdder& operator=(const MoveOnlyAdder&) = delete;
+
+    MoveOnlyAdder(MoveOnlyAdder&&) = default;
+    MoveOnlyAdder& operator=(MoveOnlyAdder&&) = default;
+
     int operator()(int i) {
-      return i + 1;
+      return i + *add_amount_;
     }
   };
 
@@ -33,31 +52,48 @@ namespace {
   }
 }
 
-TEST_CASE("imap: works with lambda, callable, and function", "[imap]") {
-  Vec ns = {10, 20, 30};
+TEST_CASE("imap: handles different callable types", "[imap]") {
+  Vec ns = {10, 15, 300};
+  Vec vc = {11, 16, 301};
   std::vector<int> v;
-  SECTION("with lambda") {
-    auto im = imap([](int i) { return i + 1; }, ns);
-    v.assign(std::begin(im), std::end(im));
+  SECTION("with function pointer") {
+    auto m = imap(plusone, ns);
+    v = Vec(std::begin(m), std::end(m));
   }
 
-  SECTION("with callable") {
-    SECTION("Normal call") {
-      auto im = imap(PlusOner{}, ns);
-      v.assign(std::begin(im), std::end(im));
+  SECTION("with callable object") {
+    auto m = imap(PlusOner{}, ns);
+    v = Vec(std::begin(m), std::end(m));
+  }
+
+  SECTION("with lvalue callable object") {
+    auto lt = PlusOner{};
+    SECTION("normal call") {
+      auto m = imap(lt, ns);
+      v = Vec(std::begin(m), std::end(m));
     }
-    SECTION("Pipe") {
-      auto im = ns | imap(PlusOner{});
-      v.assign(std::begin(im), std::end(im));
+    SECTION("pipe") {
+      auto m = ns | imap(lt);
+      v = Vec(std::begin(m), std::end(m));
     }
   }
 
-  SECTION("with function") {
-    auto im = imap(PlusOner{}, ns);
-    v.assign(std::begin(im), std::end(im));
+  SECTION("with move-only callable object") {
+    SECTION("normal call") {
+      auto m = imap(MoveOnlyAdder{1}, ns);
+      v = Vec(std::begin(m), std::end(m));
+    }
+    SECTION("pipe") {
+      auto m = ns | imap(MoveOnlyAdder{1});
+      v = Vec(std::begin(m), std::end(m));
+    }
   }
 
-  Vec vc = {11, 21, 31};
+  SECTION("with lambda") {
+    auto ltf = [](int i) { return i + 1; };
+    auto m = imap(ltf, ns);
+    v = Vec(std::begin(m), std::end(m));
+  }
   REQUIRE(v == vc);
 }
 

From 6a23fdae0ac40524a53ffa3d6a72689fb60aa990 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining@google.com>
Date: Wed, 12 Feb 2025 17:07:08 -0800
Subject: [PATCH 1854/1866] Adds tests for move-only callables to starmap

Issue #89
---
 test/test_starmap.cpp | 81 +++++++++++++++++++++++++++++++++++++++----
 1 file changed, 74 insertions(+), 7 deletions(-)

diff --git a/test/test_starmap.cpp b/test/test_starmap.cpp
index e3958c84..c8758669 100644
--- a/test/test_starmap.cpp
+++ b/test/test_starmap.cpp
@@ -47,16 +47,42 @@ namespace {
       return a;
     }
   };
+
+  struct Adder {
+    long operator()(long a, int b) {
+      return a + b;
+    }
+  };
+
+  struct MoveOnlyAddAndPlus {
+   private:
+    // unique_ptr is better for triggering asan than an int if there's a
+    // dangling reference to the callable
+    std::unique_ptr<int> add_amount_;
+
+   public:
+    MoveOnlyAddAndPlus(int v) : add_amount_{std::make_unique<int>(v)} {}
+
+    MoveOnlyAddAndPlus(const MoveOnlyAddAndPlus&) = delete;
+    MoveOnlyAddAndPlus& operator=(const MoveOnlyAddAndPlus&) = delete;
+
+    MoveOnlyAddAndPlus(MoveOnlyAddAndPlus&&) = default;
+    MoveOnlyAddAndPlus& operator=(MoveOnlyAddAndPlus&&) = default;
+
+    int operator()(long a, int b) {
+      return a + b + *add_amount_;
+    }
+  };
 }
 
 TEST_CASE("starmap: works with function pointer and lambda", "[starmap]") {
-  using Vec = const std::vector<int>;
   const std::vector<std::pair<long, int>> v1 = {{1l, 2}, {3l, 11}, {6l, 7}};
-  Vec vc = {2l, 33l, 42l};
+  const std::vector<int> greater_vc = {2l, 33l, 42l};
+  const std::vector<long> added_vc = {3l, 14l, 13l};
 
-  std::vector<int> v;
-  SECTION("with function") {
-    SECTION("Normal call") {
+  SECTION("with function pointer") {
+    std::vector<int> v;
+    SECTION("normal call") {
       auto sm = starmap(f, v1);
       v.assign(std::begin(sm), std::end(sm));
     }
@@ -64,13 +90,54 @@ TEST_CASE("starmap: works with function pointer and lambda", "[starmap]") {
       auto sm = v1 | starmap(f);
       v.assign(std::begin(sm), std::end(sm));
     }
+    REQUIRE(v == greater_vc);
+  }
+
+  SECTION("with callable object") {
+    std::vector<long> v;
+    SECTION("normal call") {
+      auto sm = starmap(Adder{}, v1);
+      v.assign(std::begin(sm), std::end(sm));
+    }
+    SECTION("pipe") {
+      auto sm = v1 | starmap(Adder{});
+      v.assign(std::begin(sm), std::end(sm));
+    }
+    REQUIRE(v == added_vc);
+  }
+
+  SECTION("with lvalue callable object") {
+    std::vector<long> v;
+    auto adder = Adder{};
+    SECTION("normal call") {
+      auto sm = starmap(adder, v1);
+      v.assign(std::begin(sm), std::end(sm));
+    }
+    SECTION("pipe") {
+      auto sm = v1 | starmap(adder);
+      v.assign(std::begin(sm), std::end(sm));
+    }
+    REQUIRE(v == std::vector{3l, 14l, 13l});
+  }
+
+  SECTION("with move-only callable object") {
+    const std::vector<long> sum_plus_one_vc = {4l, 14l, 13l};
+    std::vector<long> v;
+    SECTION("normal call") {
+      auto m = starmap(MoveOnlyAddAndPlus{1}, v1);
+      v.assign(std::begin(m), std::end(m));
+    }
+    SECTION("pipe") {
+      auto m = v1 | starmap(MoveOnlyAddAndPlus{1});
+      v.assign(std::begin(m), std::end(m));
+    }
   }
 
   SECTION("with lambda") {
     auto sm = starmap([](long a, int b) { return a * b; }, v1);
-    v.assign(std::begin(sm), std::end(sm));
+    std::vector<int> v(std::begin(sm), std::end(sm));
+    REQUIRE(v == greater_vc);
   }
-  REQUIRE(v == vc);
 }
 
 TEST_CASE("starmap: works with pointer to member function", "[starmap]") {

From 7242a9aadbbd70026a5e3b4059df9075fe465a7f Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining@google.com>
Date: Wed, 12 Feb 2025 17:07:54 -0800
Subject: [PATCH 1855/1866] Adds support for move-only callables to takewhile

Issue #89
---
 cppitertools/takewhile.hpp |  2 +-
 test/test_takewhile.cpp    | 53 ++++++++++++++++++++++++--------------
 2 files changed, 34 insertions(+), 21 deletions(-)

diff --git a/cppitertools/takewhile.hpp b/cppitertools/takewhile.hpp
index 338e43aa..3a351d0c 100644
--- a/cppitertools/takewhile.hpp
+++ b/cppitertools/takewhile.hpp
@@ -29,7 +29,7 @@ class iter::impl::Taker {
 
   Taker(FilterFunc filter_func, Container&& container)
       : container_(std::forward<Container>(container)),
-        filter_func_(filter_func) {}
+        filter_func_(std::move(filter_func)) {}
 
  public:
   Taker(Taker&&) = default;
diff --git a/test/test_takewhile.cpp b/test/test_takewhile.cpp
index 0be43f84..f562b438 100644
--- a/test/test_takewhile.cpp
+++ b/test/test_takewhile.cpp
@@ -10,36 +10,49 @@
 using iter::takewhile;
 using Vec = const std::vector<int>;
 
-TEST_CASE("takewhile: works with lambda, callable, and function pointer",
-    "[takewhile]") {
+TEST_CASE("takewhile: handles different callable types", "[takewhile]") {
   Vec ns = {1, 3, 4, 20, 2, 4, 6, 8};
-  const Vec vc = {1, 3, 4};
-  SECTION("function pointer") {
+  Vec vc = {1, 3, 4};
+  std::vector<int> v;
+  SECTION("with function pointer") {
     auto tw = takewhile(less_than_five, ns);
-    Vec v(std::begin(tw), std::end(tw));
-    REQUIRE(v == vc);
+    v = Vec(std::begin(tw), std::end(tw));
   }
 
-  SECTION("callable object") {
-    std::vector<int> v;
-    SECTION("Normal call") {
-      auto tw = takewhile(LessThanValue{10}, ns);
-      v.assign(std::begin(tw), std::end(tw));
-    }
+  SECTION("with callable object") {
+    auto tw = takewhile(LessThanValue{5}, ns);
+    v = Vec(std::begin(tw), std::end(tw));
+  }
 
-    SECTION("Pipe") {
-      auto tw = ns | takewhile(LessThanValue{10});
-      v.assign(std::begin(tw), std::end(tw));
+  SECTION("with lvalue callable object") {
+    auto lt = LessThanValue{5};
+    SECTION("normal call") {
+      auto tw = takewhile(lt, ns);
+      v = Vec(std::begin(tw), std::end(tw));
+    }
+    SECTION("pipe") {
+      auto tw = ns | takewhile(lt);
+      v = Vec(std::begin(tw), std::end(tw));
     }
+  }
 
-    REQUIRE(v == vc);
+  SECTION("with move-only callable object") {
+    SECTION("normal call") {
+      auto tw = takewhile(MoveOnlyLessThanValue{5}, ns);
+      v = Vec(std::begin(tw), std::end(tw));
+    }
+    SECTION("pipe") {
+      auto tw = ns | takewhile(MoveOnlyLessThanValue{5});
+      v = Vec(std::begin(tw), std::end(tw));
+    }
   }
 
-  SECTION("lambda") {
-    auto tw = takewhile([](int i) { return i < 10; }, ns);
-    Vec v(std::begin(tw), std::end(tw));
-    REQUIRE(v == vc);
+  SECTION("with lambda") {
+    auto ltf = [](int i) { return i < 5; };
+    auto tw = takewhile(ltf, ns);
+    v = Vec(std::begin(tw), std::end(tw));
   }
+  REQUIRE(v == vc);
 }
 
 TEST_CASE("takewhile: handles pointer to member", "[takewhile]") {

From 051d8f9830c401697213dc538477d41c5709b213 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining@google.com>
Date: Wed, 12 Feb 2025 17:08:09 -0800
Subject: [PATCH 1856/1866] Adds support for move-only callables to
 unique_justseen

Issue #89
---
 cppitertools/unique_justseen.hpp |  8 ++++---
 test/test_unique_justseen.cpp    | 40 +++++++++++++++++++++++++-------
 2 files changed, 37 insertions(+), 11 deletions(-)

diff --git a/cppitertools/unique_justseen.hpp b/cppitertools/unique_justseen.hpp
index c4ca47f5..e86d20ba 100644
--- a/cppitertools/unique_justseen.hpp
+++ b/cppitertools/unique_justseen.hpp
@@ -9,9 +9,11 @@
 
 namespace iter {
   namespace impl {
-    struct UniqueJustseenFn : PipeableAndBindOptionalSecond<UniqueJustseenFn, Identity> {
+    struct UniqueJustseenFn
+        : PipeableAndBindOptionalSecond<UniqueJustseenFn, Identity> {
      public:
-      using PipeableAndBindOptionalSecond<UniqueJustseenFn, Identity>::operator();
+      using PipeableAndBindOptionalSecond<UniqueJustseenFn, Identity>::
+      operator();
       template <typename Container, typename KeyFunc>
       auto operator()(Container&& container, KeyFunc key_fn) const {
         // decltype(auto) return type in lambda so reference types are preserved
@@ -19,7 +21,7 @@ namespace iter {
             [](auto&& group) -> decltype(auto) {
               return *get_begin(group.second);
             },
-            groupby(std::forward<Container>(container), key_fn));
+            groupby(std::forward<Container>(container), std::move(key_fn)));
       }
     };
   }
diff --git a/test/test_unique_justseen.cpp b/test/test_unique_justseen.cpp
index 6147b477..530ab869 100644
--- a/test/test_unique_justseen.cpp
+++ b/test/test_unique_justseen.cpp
@@ -102,21 +102,45 @@ struct IntWrapperKey {
   }
 };
 
-TEST_CASE("unique_justseen: works with key function",
-    "[unique_justseen]") {
+struct MoveOnlyIntWrapperKey {
+  MoveOnlyIntWrapperKey(const MoveOnlyIntWrapperKey&) = delete;
+  MoveOnlyIntWrapperKey& operator=(const MoveOnlyIntWrapperKey&) = delete;
+
+  MoveOnlyIntWrapperKey(MoveOnlyIntWrapperKey&&) = default;
+  MoveOnlyIntWrapperKey& operator=(MoveOnlyIntWrapperKey&&) = default;
+  int operator()(const IntWrapper& iw) const {
+    return iw.n;
+  }
+};
+
+TEST_CASE("unique_justseen: works with key function", "[unique_justseen]") {
   std::vector<IntWrapper> iwv = {
       {2}, {3}, {4}, {2}, {10}, {2}, {2}, {12}, {10}};
   Vec vc{2, 3, 4, 2, 10, 2, 12, 10};
 
   std::vector<int> v;
-  SECTION("Normal call") {
-    for (auto&& iw : unique_justseen(iwv, IntWrapperKey{})) {
-      v.push_back(iw.n);
+  SECTION("with callable") {
+    SECTION("Normal call") {
+      for (auto&& iw : unique_justseen(iwv, IntWrapperKey{})) {
+        v.push_back(iw.n);
+      }
+    }
+    SECTION("Pipe") {
+      for (auto&& iw : iwv | unique_justseen(IntWrapperKey{})) {
+        v.push_back(iw.n);
+      }
     }
   }
-  SECTION("Pipe") {
-    for (auto&& iw : iwv | unique_justseen(IntWrapperKey{})) {
-      v.push_back(iw.n);
+  SECTION("with move-only callable") {
+    SECTION("Normal call") {
+      for (auto&& iw : unique_justseen(iwv, MoveOnlyIntWrapperKey{})) {
+        v.push_back(iw.n);
+      }
+    }
+    SECTION("Pipe") {
+      for (auto&& iw : iwv | unique_justseen(MoveOnlyIntWrapperKey{})) {
+        v.push_back(iw.n);
+      }
     }
   }
 

From 7ce67a6e4602651130bab0b71bb31d877c5a66f4 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining@google.com>
Date: Wed, 12 Feb 2025 17:48:27 -0800
Subject: [PATCH 1857/1866] Replaces true/false tag dispatches with if
 constexpr

---
 cppitertools/internal/iterbase.hpp | 48 ++++++++++--------------------
 1 file changed, 16 insertions(+), 32 deletions(-)

diff --git a/cppitertools/internal/iterbase.hpp b/cppitertools/internal/iterbase.hpp
index 9cb97442..34abd934 100644
--- a/cppitertools/internal/iterbase.hpp
+++ b/cppitertools/internal/iterbase.hpp
@@ -214,28 +214,20 @@ namespace iter {
       }
     }
 
-    template <typename Iter, typename EndIter, typename Distance>
-    void dumb_advance_impl(
-        Iter& iter, const EndIter& end, Distance distance, std::false_type) {
-      for (Distance i(0); i < distance && iter != end; ++i) {
-        ++iter;
-      }
-    }
-
-    template <typename Iter, typename EndIter, typename Distance>
-    void dumb_advance_impl(
-        Iter& iter, const EndIter& end, Distance distance, std::true_type) {
-      if (static_cast<Distance>(end - iter) < distance) {
-        iter = end;
-      } else {
-        iter += distance;
-      }
-    }
-
     // iter will not be incremented past end
     template <typename Iter, typename EndIter, typename Distance = std::size_t>
     void dumb_advance(Iter& iter, const EndIter& end, Distance distance) {
-      dumb_advance_impl(iter, end, distance, is_random_access_iter<Iter>{});
+      if constexpr (is_random_access_iter<Iter>{}) {
+        if (static_cast<Distance>(end - iter) < distance) {
+          iter = end;
+        } else {
+          iter += distance;
+        }
+      } else {
+        for (Distance i(0); i < distance && iter != end; ++i) {
+          ++iter;
+        }
+      }
     }
 
     template <typename ForwardIt, typename Distance = std::size_t>
@@ -452,22 +444,14 @@ namespace iter {
       using Base =
           PipeableAndBindFirst<IterToolFnOptionalBindFirst<ItImpl, DefaultT>>;
 
-     protected:
-      template <typename Container>
-      auto operator()(Container&& container, std::false_type) const {
-        return static_cast<const Base&>(*this)(
-            std::forward<Container>(container));
-      }
-
-      template <typename Container>
-      auto operator()(Container&& container, std::true_type) const {
-        return (*this)(DefaultT{}, std::forward<Container>(container));
-      }
-
      public:
       template <typename T>
       auto operator()(T&& t) const {
-        return (*this)(std::forward<T>(t), IsIterable<T>{});
+        if constexpr (IsIterable<T>{}) {
+          return (*this)(DefaultT{}, std::forward<T>(t));
+        } else {
+          return static_cast<const Base&>(*this)(std::forward<T>(t));
+        }
       }
 
       template <typename T, typename Container,

From ed8b84291f8c66af4e043ddaa9d6e96ecd8d5321 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining@google.com>
Date: Thu, 13 Feb 2025 16:36:06 -0800
Subject: [PATCH 1858/1866] Sets bazelversion to 8.*

---
 .bazelversion | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.bazelversion b/.bazelversion
index cd1d2e94..f4abeaad 100644
--- a/.bazelversion
+++ b/.bazelversion
@@ -1 +1 @@
-8.0.1
+8.*

From da33b531264fe1604871c8a2765f2ef3dcd98d99 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining@google.com>
Date: Fri, 14 Feb 2025 14:39:17 -0800
Subject: [PATCH 1859/1866] Forwards key to `Group`

If we knew the key type was not a reference, we could just call
std::move, but there might be an lvalue reference hiding in there.
---
 cppitertools/groupby.hpp |  8 ++++++--
 test/test_groupby.cpp    | 37 +++++++++++++++++++++++++++++++++++++
 2 files changed, 43 insertions(+), 2 deletions(-)

diff --git a/cppitertools/groupby.hpp b/cppitertools/groupby.hpp
index 313f088a..1c73f9f6 100644
--- a/cppitertools/groupby.hpp
+++ b/cppitertools/groupby.hpp
@@ -178,6 +178,8 @@ class iter::impl::GroupProducer {
     friend class Iterator;
     friend class GroupIterator;
     Iterator<ContainerT>& owner_;
+    // The key function may return a reference, so we need to call forward, not
+    // move, when going for efficiency.
     key_func_ret<ContainerT> key_;
 
     // completed is set if a Group is iterated through
@@ -192,7 +194,7 @@ class iter::impl::GroupProducer {
     bool completed = false;
 
     Group(Iterator<ContainerT>& owner, key_func_ret<ContainerT> key)
-        : owner_(owner), key_(key) {}
+        : owner_(owner), key_(std::forward<key_func_ret<ContainerT>>(key)) {}
 
    public:
     ~Group() {
@@ -204,7 +206,9 @@ class iter::impl::GroupProducer {
 
     // move-constructible, non-copy-constructible, non-assignable
     Group(Group&& other) noexcept
-        : owner_(other.owner_), key_{other.key_}, completed{other.completed} {
+        : owner_(other.owner_),
+          key_{std::forward<key_func_ret<ContainerT>>(other.key_)},
+          completed{other.completed} {
       other.completed = true;
     }
 
diff --git a/test/test_groupby.cpp b/test/test_groupby.cpp
index 5904c78d..02798f39 100644
--- a/test/test_groupby.cpp
+++ b/test/test_groupby.cpp
@@ -40,6 +40,43 @@ namespace {
 
   const std::vector<std::string> vec = {
       "hi", "ab", "ho", "abc", "def", "abcde", "efghi"};
+
+  struct Person {
+    std::string name;
+    int id;
+    bool operator==(const Person& other) const {
+      return id == other.id;
+    }
+  };
+
+  std::string& get_name(Person& p) {
+    return p.name;
+  }
+
+  template <typename G>
+  std::vector<Person> extract_person_group(G g) {
+    return {std::begin(g), std::end(g)};
+  }
+}
+
+TEST_CASE("groupby: handle key function that returns reference", "[groupby]") {
+  std::vector<Person> people = {{"first", 1}, {"first", 2}, {"first", 3}};
+  std::vector<std::string> keys;
+  std::vector<std::vector<Person>> groups;
+
+  for (auto&& gb : groupby(people, get_name)) {
+    groups.push_back(extract_person_group(std::move(gb.second)));
+    keys.push_back(gb.first);
+  }
+
+  const std::vector<std::string> kc = {"first"};
+  const std::vector<std::vector<Person>> gc = {
+      {{"first", 1}, {"first", 2}, {"first", 3}}};
+
+  REQUIRE(people[0].name == "first");
+  REQUIRE(gc[0][0].name == "first");
+  REQUIRE(keys == kc);
+  REQUIRE(groups == gc);
 }
 
 TEST_CASE("groupby: handles different callable types", "[groupby]") {

From cf16b06cee79c7216233448cd25e4cb925efd7d2 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining@google.com>
Date: Fri, 14 Feb 2025 14:47:19 -0800
Subject: [PATCH 1860/1866] Only uses gnu::nodangling when it's available in
 gcc

---
 cppitertools/internal/iterbase.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cppitertools/internal/iterbase.hpp b/cppitertools/internal/iterbase.hpp
index 34abd934..a21489dc 100644
--- a/cppitertools/internal/iterbase.hpp
+++ b/cppitertools/internal/iterbase.hpp
@@ -345,7 +345,7 @@ namespace iter {
     template <typename ItTool>
     struct Pipeable {
       template <typename T>
-#if defined(__GNUC__) && !defined(__clang__)
+#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ >= 14
       [[gnu::no_dangling]]
 #endif
       friend decltype(auto) operator|(T&& x, Pipeable&& p) {

From 5bc867a1ee8fbcee322f072d700171e1901214dc Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining@google.com>
Date: Tue, 18 Feb 2025 14:02:50 -0800
Subject: [PATCH 1861/1866] Removes cv qualifiers from value_type

---
 cppitertools/internal/iterbase.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cppitertools/internal/iterbase.hpp b/cppitertools/internal/iterbase.hpp
index a21489dc..f4d8792e 100644
--- a/cppitertools/internal/iterbase.hpp
+++ b/cppitertools/internal/iterbase.hpp
@@ -117,7 +117,7 @@ namespace iter {
 
     template <typename Container>
     using iterator_traits_deref =
-        std::remove_reference_t<iterator_deref<Container>>;
+        std::remove_cv_t<std::remove_reference_t<iterator_deref<Container>>>;
 
     template <typename T, typename = void>
     struct IsIterable : std::false_type {};

From 392734a2991980f25fe18c91d8bee05c99477d0f Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining@google.com>
Date: Tue, 18 Feb 2025 17:03:48 -0800
Subject: [PATCH 1862/1866] Removes cv qualifiers from iterator iterator
 value_type

---
 cppitertools/internal/iteratoriterator.hpp | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/cppitertools/internal/iteratoriterator.hpp b/cppitertools/internal/iteratoriterator.hpp
index 3993a4d0..0ab23bad 100644
--- a/cppitertools/internal/iteratoriterator.hpp
+++ b/cppitertools/internal/iteratoriterator.hpp
@@ -24,7 +24,8 @@ namespace iter {
 
     template <typename TopIter>
     class IteratorIterator {
-      template <typename> friend class IteratorIterator;
+      template <typename>
+      friend class IteratorIterator;
       using Diff = std::ptrdiff_t;
       static_assert(
           std::is_same<
@@ -37,10 +38,14 @@ namespace iter {
 
      public:
       using iterator_category = std::random_access_iterator_tag;
-      using value_type = std::remove_reference_t<decltype(**std::declval<TopIter>())>;
+      using value_type = std::remove_cv_t<
+          std::remove_reference_t<decltype(**std::declval<TopIter>())>>;
       using difference_type = std::ptrdiff_t;
-      using pointer = value_type*;
-      using reference = value_type&;
+      using pointer =
+          std::remove_reference_t<decltype(**std::declval<TopIter>())>*;
+      using reference = std::add_lvalue_reference_t<
+          std::remove_reference_t<decltype(**std::declval<TopIter>())>>;
+
       IteratorIterator() = default;
       IteratorIterator(const TopIter& it) : sub_iter{it} {}
 
@@ -84,7 +89,7 @@ namespace iter {
         return **this->sub_iter;
       }
 
-      auto operator-> () const -> decltype(*sub_iter) {
+      auto operator->() const -> decltype(*sub_iter) {
         return *this->sub_iter;
       }
 

From 1bbe5a437f5039d242b0fb6983faa2a3f005edc5 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining@google.com>
Date: Tue, 18 Feb 2025 17:10:03 -0800
Subject: [PATCH 1863/1866] Removes cv qualifiers from DerefHolder when storing
 value

---
 cppitertools/internal/iterbase.hpp | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/cppitertools/internal/iterbase.hpp b/cppitertools/internal/iterbase.hpp
index f4d8792e..e9627079 100644
--- a/cppitertools/internal/iterbase.hpp
+++ b/cppitertools/internal/iterbase.hpp
@@ -262,9 +262,8 @@ namespace iter {
               std::is_same<T, U>::value && are_same<T, Ts...>::value> {};
 
     // DerefHolder holds the value gotten from an iterator dereference
-    // if the iterate dereferences to an lvalue references, a pointer to the
-    //     element is stored
-    // if it does not, a value is stored instead
+    // if the iterator dereferences to an lvalue references, a pointer to the
+    // element is stored.  if it does not, a value is stored instead
     // get() returns a reference to the held item
     // get_ptr() returns a pointer to the held item
     // reset() replaces the currently held item
@@ -274,7 +273,7 @@ namespace iter {
       static_assert(!std::is_lvalue_reference<T>::value,
           "Non-lvalue-ref specialization used for lvalue ref type");
       // it could still be an rvalue reference
-      using TPlain = std::remove_reference_t<T>;
+      using TPlain = std::remove_cv_t<std::remove_reference_t<T>>;
 
       std::optional<TPlain> item_p_;
 

From 674e8b9a6d2f2319ea38312b6ada073937843e70 Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining@google.com>
Date: Tue, 18 Feb 2025 17:10:52 -0800
Subject: [PATCH 1864/1866] Specifies pointer and reference to match operators
 exactly

---
 cppitertools/filter.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/cppitertools/filter.hpp b/cppitertools/filter.hpp
index 53ed15cc..d743d8b1 100644
--- a/cppitertools/filter.hpp
+++ b/cppitertools/filter.hpp
@@ -86,8 +86,8 @@ class iter::impl::Filtered {
     using iterator_category = std::input_iterator_tag;
     using value_type = iterator_traits_deref<ContainerT>;
     using difference_type = std::ptrdiff_t;
-    using pointer = value_type*;
-    using reference = value_type&;
+    using pointer = typename Holder::pointer;
+    using reference = typename Holder::reference;
 
     Iterator(IteratorWrapper<ContainerT>&& sub_iter,
         IteratorWrapper<ContainerT>&& sub_end, FilterFunc& filter_func)

From 13947eb68f464cb014343de7a155016290655d1a Mon Sep 17 00:00:00 2001
From: Ryan Haining <haining@google.com>
Date: Tue, 18 Feb 2025 17:13:09 -0800
Subject: [PATCH 1865/1866] Specifies chain pointer and reference to match
 calls exactly

---
 cppitertools/chain.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/cppitertools/chain.hpp b/cppitertools/chain.hpp
index 76759eeb..05557387 100644
--- a/cppitertools/chain.hpp
+++ b/cppitertools/chain.hpp
@@ -142,8 +142,8 @@ class iter::impl::Chained {
     using iterator_category = std::input_iterator_tag;
     using value_type = typename IteratorData<TupTypeT>::TraitsValue;
     using difference_type = std::ptrdiff_t;
-    using pointer = value_type*;
-    using reference = value_type&;
+    using pointer = typename IteratorData<TupTypeT>::ArrowType;
+    using reference = typename IteratorData<TupTypeT>::DerefType;
 
     Iterator(std::size_t i, typename IterData::IterTupType&& iters,
         typename IterData::IterTupType&& ends)

From bb59879a7dbea29cc70d204b8c4889e35bb1110e Mon Sep 17 00:00:00 2001
From: Cristi Popa <cpopa@google.com>
Date: Sat, 6 Dec 2025 15:55:05 +0100
Subject: [PATCH 1866/1866] Update readme to use google style markdown
 rendering

---
 README.md | 382 +++++++++++++++++++++++++++++-------------------------
 1 file changed, 206 insertions(+), 176 deletions(-)

diff --git a/README.md b/README.md
index 7b43c218..740dacbd 100644
--- a/README.md
+++ b/README.md
@@ -1,9 +1,7 @@
-
-
 CPPItertools
 ============
 Range-based for loop add-ons inspired by the Python builtins and itertools
-library.  Like itertools and the Python3 builtins, this library uses lazy
+library. Like itertools and the Python3 builtins, this library uses lazy
 evaluation wherever possible.
 
 *Note*: Everything is inside the `iter` namespace.
@@ -44,7 +42,7 @@ Status | Compilers
 [chunked](#chunked)<br />
 [batched](#batched)<br />
 
-##### Combinatoric fuctions
+##### Combinatorial functions
 [product](#product)<br />
 [combinations](#combinations)<br />
 [combinations\_with\_replacement](#combinations_with_replacement)<br />
@@ -55,11 +53,10 @@ Status | Compilers
 This library is **header-only** and relies only on the C++ standard
 library. The only exception is `zip_longest` which uses `boost::optional`.
 `#include <cppitertools/itertools.hpp>` will include all of the provided
-tools except for `zip_longest` which must be included separately.  You may
+tools except for `zip_longest` which must be included separately. You may
 also include individual pieces with the relevant header
 (`#include <cppitertools/enumerate.hpp>` for example).
 
-
 ### Running tests
 You may use either `scons` or `bazel` to build the tests. `scons` seems
 to work better with viewing the test output, but the same `bazel` command
@@ -86,7 +83,7 @@ $ bazel test //test:test_enumerate # runs a specific test
 
 #### Requirements of passed objects
 Most itertools will work with iterables using InputIterators and not copy
-or move any underlying elements.  The itertools that need ForwardIterators or
+or move any underlying elements. The itertools that need ForwardIterators or
 have additional requirements are noted in this document. However, the cases
 should be fairly obvious: any time an element needs to appear multiple times
 (as in `combinations` or `cycle`) or be looked at more than once (specifically,
@@ -110,7 +107,7 @@ appropriate as a GitHub issue (or you just don't want to open one),
 you can email me directly with whatever code you have that describes the
 problem; I've been pretty responsive in the past. If I believe you are
 "misusing" the library, I'll try to put the blame on myself for being unclear
-in this document and take the steps to clarify it.  So please, contact me with
+in this document and take the steps to clarify it. So please, contact me with
 any concerns, I'm open to feedback.
 
 #### How (not) to use this library
@@ -125,41 +122,42 @@ know.
 
 #### Handling of rvalues vs lvalues
 The rules are pretty simple, and the library can be largely used without
-knowledge of them.
-Let's take an example
+knowledge of them. Let's take an example
+
 ```c++
 std::vector<int> vec{2,4,6,8};
 for (auto&& p : enumerate(vec)) { /* ... */ }
 ```
+
 In this case, `enumerate` will return an object that has bound a reference to
 `vec`. No copies are produced here, neither of `vec` nor of the elements it
 holds.
 
 If an rvalue was passed to enumerate, binding a reference would be unsafe.
 Consider:
+
 ```c++
 for (auto&& p : enumerate(std::vector<int>{2,4,6,8})) { /* ... */ }
 ```
+
 Instead, `enumerate` will return an object that has the temporary *moved* into
-it.  That is, the returned object will contain a `std::vector<int>` rather than
+it. That is, the returned object will contain a `std::vector<int>` rather than
 just a reference to one. This may seem like a contrived example, but it matters
 when `enumerate` is passed the result of a function call like `enumerate(f())`,
-or, more obviously, something like `enumerate(zip(a, b))`.  The object returned
+or, more obviously, something like `enumerate(zip(a, b))`. The object returned
 from `zip` must be moved into the `enumerate` object. As a more specific
 result, itertools can be mixed and nested.
 
-
-
 #### Pipe syntax
 Wherever it makes sense, I've implemented the "pipe" operator that has become
 common in similar libraries. When the syntax is available, it is done by pulling
 out the iterable from the call and placing it before the tool. For example:
 
 ```c++
-filter(pred, seq);  // regular call
-seq | filter(pred);  // pipe-style
-enumerate(seq);  // regular call
-seq | enumerate;  // pipe-style.
+filter(pred, seq); // regular call
+seq | filter(pred); // pipe-style
+enumerate(seq); // regular call
+seq | enumerate; // pipe-style.
 ```
 
 The following tools support pipe. The remaining I left out because although
@@ -193,46 +191,50 @@ would expect them to behave:
 I don't personally care for the piping style, but it seemed to be desired by
 the users.
 
-
 range
 -----
 
 Uses an underlying iterator to achieve the same effect of the python range
-function.  `range` can be used in three different ways:
+function. `range` can be used in three different ways:
+
+Only the stopping point is provided. Prints `0 1 2 3 4 5 6 7 8 9`
 
-Only the stopping point is provided.  Prints `0 1 2 3 4 5 6 7 8 9`
 ```c++
 for (auto i : range(10)) {
-    cout << i << '\n';
+  cout << i << '\n';
 }
 ```
 
-The start and stop are both provided.  Prints `10 11 12 13 14`
+The start and stop are both provided. Prints `10 11 12 13 14`
+
 ```c++
 for (auto i : range(10, 15)) {
-    cout << i << '\n';
+  cout << i << '\n';
 }
 ```
 
-The start, stop, and step are all provided.  Prints `20 22 24 26 28`
+The start, stop, and step are all provided. Prints `20 22 24 26 28`
+
 ```c++
 for (auto i : range(20, 30, 2)) {
-    cout << i << '\n';
+  cout << i << '\n';
 }
 ```
 
-Negative values are allowed as well.  Prints `2 1 0 -1 -2`
+Negative values are allowed as well. Prints `2 1 0 -1 -2`
+
 ```c++
 for (auto i : range(2, -3, -1)) {
-    cout << i << '\n';
+  cout << i << '\n';
 }
 ```
 
 A step size of 0 results in an empty range (Python's raises an exception).
 The following prints nothing
+
 ```c++
 for (auto i : range(0, 10, 0)) {
-    cout << i << '\n';
+  cout << i << '\n';
 }
 ```
 
@@ -240,9 +242,10 @@ In addition to normal integer range operations, doubles and
 other numeric types are supported through the template
 
 Prints: `5.0 5.5 6.0` ... `9.5`
+
 ```c++
 for(auto i : range(5.0, 10.0, 0.5)) {
-    cout << i << '\n';
+  cout << i << '\n';
 }
 ```
 
@@ -253,46 +256,45 @@ recomputed at each step to avoid accumulating floating point inaccuracies
 slower but more accurate.
 
 `range` also supports the following operations:
-  - `.size()` to get the number of elements in the range (not enabled for
-  floating point ranges).
-  - Accessors for `.start()`, `.stop()`, and `.step()`.
-  - Indexing. Given a range `r`, `r[n]` is the `n`th element in the range.
+ - `.size()` to get the number of elements in the range (not enabled for
+ floating point ranges).
+ - Accessors for `.start()`, `.stop()`, and `.step()`.
+ - Indexing. Given a range `r`, `r[n]` is the `n`th element in the range.
 
 enumerate
 ---------
-
-Continually "yields" containers similar to pairs.  They are structs with
-the index in `.first`, and the element in `.second`, and also work with structured 
-binding declarations.
-Usage appears as:
+Continually "yields" containers similar to pairs. They are structs with the
+index in `.first`, and the element in `.second`, and also work with structured
+binding declarations. Usage appears as:
 
 ```c++
 vector<int> vec{2, 4, 6, 8};
 for (auto&& [i, e] : enumerate(vec)) {
-    cout << i << ": " << e << '\n';
+  cout << i << ": " << e << '\n';
 }
 ```
 
 filter
 ------
-Called as `filter(predicate, iterable)`.  The predicate can be any callable.
+Called as `filter(predicate, iterable)`. The predicate can be any callable.
 `filter` will only yield values that are true under the predicate.
 
-Prints values greater than 4:  `5 6 7 8`
+Prints values greater than 4: `5 6 7 8`
+
 ```c++
 vector<int> vec{1, 5, 4, 0, 6, 7, 3, 0, 2, 8, 3, 2, 1};
 for (auto&& i : filter([] (int i) { return i > 4; }, vec)) {
-    cout << i <<'\n';
+  cout << i <<'\n';
 }
-
 ```
 
 If no predicate is passed, the elements themselves are tested for truth
 
 Prints only non-zero values.
+
 ```c++
 for(auto&& i : filter(vec)) {
-    cout << i << '\n';
+  cout << i << '\n';
 }
 ```
 
@@ -300,36 +302,38 @@ filterfalse
 -----------
 Similar to filter, but only prints values that are false under the predicate.
 
-Prints values not greater than 4: `1 4 3 2 3 2 1 `
+Prints values not greater than 4: `1 4 3 2 3 2 1`
+
 ```c++
 vector<int> vec{1, 5, 4, 0, 6, 7, 3, 0, 2, 8, 3, 2, 1};
 for (auto&& i : filterfalse([] (int i) { return i > 4; }, vec)) {
-    cout << i <<'\n';
+  cout << i <<'\n';
 }
-
 ```
 
 If no predicate is passed, the elements themselves are tested for truth.
 
 Prints only zero values.
+
 ```c++
 for(auto&& i : filterfalse(vec)) {
-    cout << i << '\n';
+  cout << i << '\n';
 }
-
 ```
+
 unique\_everseen
----------------
+----------------
 *Additional Requirements*: Underlying values must be copy-constructible.
 
 This is a filter adaptor that only generates values that have never been seen
 before.
 
 Prints `1 2 3 4 5 6 7 8 9`
+
 ```c++
 vector<int> v {1,2,3,4,3,2,1,5,6,7,7,8,9,8,9,6};
 for (auto&& i : unique_everseen(v)) {
-    cout << i << ' ';
+  cout << i << ' ';
 }
 ```
 
@@ -341,29 +345,30 @@ This **does not** work with the pipe syntax.
 ```c++
 vector<Widget> v { /* ... */ };
 for (auto&& w : unique_everseen(v, WidgetHash{}, WidgetEq{})) {
-  cout << w.name() << ' ';
+ cout << w.name() << ' ';
 }
 ```
 
 unique\_justseen
---------------
+----------------
 Another filter adaptor that only omits consecutive duplicates.
 
 Prints `1 2 3 4 3 2 1`
-Example Usage:
+
 ```c++
 vector<int> v {1,1,1,2,2,3,3,3,4,3,2,1,1,1};
 for (auto&& i : unique_justseen(v)) {
-    cout << i << ' ';
+  cout << i << ' ';
 }
 ```
 
 If elements cannot be directly compared with equality, you can pass in a key
 callable.
+
 ```c++
 vector<Person> v { /* ... */ };
-for (auto&& p : unique_justseen(v, [] (const Person& p) { return p.name; }))
-  cout << p.name() << ' ' << p.age() << '\n';
+for (auto&& p : unique_justseen(v, [] (const Person& p) { return p.name; })) {
+ cout << p.name() << ' ' << p.age() << '\n';
 }
 ```
 
@@ -372,11 +377,12 @@ takewhile
 Yields elements from an iterable until the first element that is false under
 the predicate is encountered.
 
-Prints `1 2 3 4`.  (5 is false under the predicate)
+Prints `1 2 3 4`. (5 is false under the predicate)
+
 ```c++
 vector<int> ivec{1, 2, 3, 4, 5, 6, 7, 6, 5, 4, 3, 2, 1};
 for (auto&& i : takewhile([] (int i) {return i < 5;}, ivec)) {
-    cout << i << '\n';
+  cout << i << '\n';
 }
 ```
 
@@ -386,10 +392,11 @@ Yields all elements after and including the first element that is true under
 the predicate.
 
 Prints `5 6 7 1 2`
+
 ```c++
 vector<int> ivec{1, 2, 3, 4, 5, 6, 7, 1, 2};
 for (auto&& i : dropwhile([] (int i) {return i < 5;}, ivec)) {
-    cout << i << '\n';
+  cout << i << '\n';
 }
 ```
 
@@ -397,18 +404,18 @@ cycle
 -----
 *Additional Requirements*: Input must have a ForwardIterator
 
-
-Repeatedly produces all values of an iterable.  The loop will be infinite, so a
+Repeatedly produces all values of an iterable. The loop will be infinite, so a
 `break` or other control flow structure is necessary to exit.
 
 Prints `1 2 3` repeatedly until `some_condition` is true
+
 ```c++
 vector<int> vec{1, 2, 3};
 for (auto&& i : cycle(vec)) {
-    cout << i << '\n';
-    if (some_condition) {
-        break;
-    }
+  cout << i << '\n';
+  if (some_condition) {
+    break;
+  }
 }
 ```
 
@@ -416,19 +423,21 @@ repeat
 ------
 Repeatedly produces a single argument forever, or a given number of times.
 `repeat` will bind a reference when passed an lvalue and move when given
-an rvalue.  It will then yield a reference to the same item until completion.
+an rvalue. It will then yield a reference to the same item until completion.
 
 The below prints `1` five times.
+
 ```c++
 for (auto&& e : repeat(1, 5)) {
-    cout << e << '\n';
+  cout << e << '\n';
 }
 ```
 
 The below prints `2` forever
+
 ```c++
 for (auto&& e : repeat(2)) {
-    cout << e << '\n';
+  cout << e << '\n';
 }
 ```
 
@@ -448,9 +457,10 @@ being the `std::numeric_limits<T>::max()` for the integral type (`long`
 by default)
 
 The below will print `0 1 2` ... etc
+
 ```c++
 for (auto&& i : count()) {
-    cout << i << '\n';
+  cout << i << '\n';
 }
 ```
 
@@ -460,31 +470,32 @@ groupby
 a reference, the reference must remain valid after the iterator is incremented.
 Roughly equivalent to requiring the Input have a ForwardIterator.
 
-Separate an iterable into groups sharing a common key.  The following example
+Separate an iterable into groups sharing a common key. The following example
 creates a new group whenever a string of a different length is encountered.
+
 ```c++
 vector<string> vec = {
-    "hi", "ab", "ho",
-    "abc", "def",
-    "abcde", "efghi"
+  "hi", "ab", "ho",
+  "abc", "def",
+  "abcde", "efghi"
 };
 
 for (auto&& gb : groupby(vec, [] (const string &s) {return s.length(); })) {
-    cout << "key: " << gb.first << '\n';
-    cout << "content: ";
-    for (auto&& s : gb.second) {
-        cout << s << "  ";
-    }
-    cout << '\n';
+  cout << "key: " << gb.first << '\n';
+  cout << "content: ";
+  for (auto&& s : gb.second) {
+    cout << s << " ";
+  }
+  cout << '\n';
 }
 ```
+
 *Note*: Just like Python's `itertools.groupby`, this doesn't do any sorting.
 It just iterates through, making a new group each time there is a key change.
 Thus, if the group is unsorted, the same key may appear multiple times.
 
 starmap
 -------
-
 Takes a sequence of tuple-like objects (anything that works with `std::get`)
 and unpacks each object into individual arguments for each function call.
 The below example takes a `vector` of `pairs` of ints, and passes them
@@ -494,21 +505,21 @@ the first and second arguments to the function.
 ```c++
 vector<pair<int, int>> v = {{2, 3}, {5, 2}, {3, 4}}; // {base, exponent}
 for (auto&& i : starmap([](int b, int e){return pow(b, e);}, v)) {
-    // ...
+  // ...
 }
 ```
 
 `starmap` can also work over a tuple-like object of tuple-like objects even
 when the contained objects are different as long as the functor works with
-multiple types of calls.  For example, a `Callable` struct with overloads
+multiple types of calls. For example, a `Callable` struct with overloads
 for its `operator()` will work as long as all overloads have the same
 return type
 
 ```c++
 struct Callable {
-    int operator()(int i) const;
-    int operator()(int i, char c) const;
-    int operator()(double d, int i, char c) const;
+  int operator()(int i) const;
+  int operator()(int i, char c) const;
+  int operator()(double d, int i, char c) const;
 };
 ```
 
@@ -516,36 +527,40 @@ This will work with a tuple of mixed types
 
 ```c++
 auto t = make_tuple(
-        make_tuple(5), // first form
-        make_pair(3, 'c'), // second
-        make_tuple(1.0, 1, '1')); // third
+    make_tuple(5), // first form
+    make_pair(3, 'c'), // second
+    make_tuple(1.0, 1, '1')); // third
 for (auto&& i : starmap(Callable{}, t)) {
-    // ...
+  // ...
 }
 ```
 
 accumulate
--------
+----------
 *Additional Requirements*: Type return from functor (with reference removed)
 must be assignable.
 
 Differs from `std::accumulate` (which in my humble opinion should be named
-`std::reduce` or `std::foldl`).  It is similar to a functional reduce where one
-can see all of the intermediate results.  By default, it keeps a running sum.
+`std::reduce` or `std::foldl`). It is similar to a functional reduce where one
+can see all of the intermediate results. By default, it keeps a running sum.
+
 Prints: `1 3 6 10 15`
+
 ```c++
 for (auto&& i : accumulate(range(1, 6))) {
-    cout << i << '\n';
+  cout << i << '\n';
 }
 ```
+
 A second, optional argument may provide an alternative binary function
-to compute results.  The following example multiplies the numbers, rather
+to compute results. The following example multiplies the numbers, rather
 than adding them.
+
 Prints: `1 2 6 24 120`
 
 ```c++
 for (auto&& i : accumulate(range(1, 6), std::multiplies<int>{})) {
-    cout << i << '\n';
+  cout << i << '\n';
 }
 ```
 
@@ -556,10 +571,11 @@ zip
 ---
 Takes an arbitrary number of ranges of different types and efficiently iterates
 over them in parallel (so an iterator to each container is incremented
-simultaneously).  When you dereference an iterator to "zipped" range you get a
+simultaneously). When you dereference an iterator to "zipped" range you get a
 tuple of the elements the iterators were holding.
 
 Example usage:
+
 ```c++
 array<int,4> iseq{{1,2,3,4}};
 vector<float> fseq{1.2,1.4,12.3,4.5,9.9};
@@ -567,16 +583,16 @@ vector<string> sseq{"i","like","apples","a lot","dude"};
 array<double,5> dseq{{1.2,1.2,1.2,1.2,1.2}};
 
 for (auto&& [i, f, s, d] : zip(iseq, fseq, sseq, dseq)) {
-    cout << i << ' ' << f << ' ' << s << ' ' << d << '\n';
-    f = 2.2f; // modifies the underlying 'fseq' sequence
+  cout << i << ' ' << f << ' ' << s << ' ' << d << '\n';
+  f = 2.2f; // modifies the underlying 'fseq' sequence
 }
 ```
 
 zip\_longest
------------
+------------
 Terminates on the longest sequence instead of the shortest.
 Repeatedly yields a tuple of `boost::optional<T>`s where `T` is the type
-yielded by the sequences' respective iterators.  Because of its boost
+yielded by the sequences' respective iterators. Because of its boost
 dependency, `zip_longest` is not in `itertools.hpp` and must be included
 separately.
 The following loop prints either "Just \<item\>" or "Nothing" for each
@@ -586,23 +602,24 @@ element in each tuple yielded.
 vector<int> v1 = {0, 1, 2, 3};
 vector<int> v2 = {10, 11};
 for (auto&& [x, y] : zip_longest(v1, v2)) {
-    cout << '{';
-    if (x) {
-        cout << "Just " << *x;
-    } else {
-        cout << "Nothing";
-    }
-    cout << ", ";
-    if (y) {
-        cout << "Just " << *y;
-    } else {
-        cout << "Nothing";
-    }
-    cout << "}\n";
+  cout << '{';
+  if (x) {
+    cout << "Just " << *x;
+  } else {
+    cout << "Nothing";
+  }
+  cout << ", ";
+  if (y) {
+    cout << "Just " << *y;
+  } else {
+    cout << "Nothing";
+  }
+  cout << "}\n";
 }
 ```
 
 The output is:
+
 ```
 {Just 0, Just 10}
 {Just 1, Just 11}
@@ -612,27 +629,27 @@ The output is:
 
 imap
 ----
-
-Takes a function and one or more iterables.  The number of iterables must
-match the number of arguments to the function.  Applies the function to
-each element (or elements) in the iterable(s).  Terminates on the shortest
+Takes a function and one or more iterables. The number of iterables must
+match the number of arguments to the function. Applies the function to
+each element (or elements) in the iterable(s). Terminates on the shortest
 sequence.
 
 Prints the squares of the numbers in vec: `1 4 9 16 25`
 ```c++
 vector<int> vec{1, 2, 3, 4, 5};
 for (auto&& i : imap([] (int x) {return x * x;}, vec)) {
-    cout << i << '\n';
+  cout << i << '\n';
 }
 ```
 
 With more than one sequence, the below adds corresponding elements from
 each vector together, printing `11 23 35 47 59 71`
+
 ```c++
 vector<int> vec1{1, 3, 5, 7, 9, 11};
 vector<int> vec2{10, 20, 30, 40, 50, 60};
 for (auto&& i : imap([] (int x, int y) { return x + y; }, vec1, vec2)) {
-    cout << i << '\n';
+  cout << i << '\n';
 }
 ```
 
@@ -640,10 +657,8 @@ for (auto&& i : imap([] (int x, int y) { return x + y; }, vec1, vec2)) {
 `std::map`, and because it is more related to `itertools.imap` than
 the python builtin `map`.
 
-
 compress
 --------
-
 Yields only the values corresponding to true in the selectors iterable.
 Terminates on the shortest sequence.
 
@@ -652,7 +667,7 @@ Prints `2 6`
 vector<int> ivec{1, 2, 3, 4, 5, 6};
 vector<bool> bvec{false, true, false, false, false, true};
 for (auto&& i : compress(ivec, bvec) {
-    cout << i << '\n';
+  cout << i << '\n';
 }
 ```
 
@@ -662,10 +677,10 @@ sorted
 
 Allows iteration over a sequence in sorted order. `sorted` does
 **not** produce a new sequence, copy elements, or modify the original
-sequence.  It only provides a way to iterate over existing elements.
+sequence. It only provides a way to iterate over existing elements.
 `sorted` also takes an optional second
 [comparator](http://en.cppreference.com/w/cpp/concept/Compare)
-argument.  If not provided, defaults to `std::less`. <br />
+argument. If not provided, defaults to `std::less`. <br />
 Iterables passed to sorted are required to have an iterator with
 an `operator*() const` member.
 
@@ -674,7 +689,7 @@ The below outputs `0 1 2 3 4`.
 ```c++
 unordered_set<int> nums{4, 0, 2, 1, 3};
 for (auto&& i : sorted(nums)) {
-    cout << i << '\n';
+  cout << i << '\n';
 }
 ```
 
@@ -692,31 +707,31 @@ vector<int> vec1{1,2,3,4,5,6};
 array<int,4> arr1{{7,8,9,10}};
 
 for (auto&& i : chain(empty,vec1,arr1)) {
-    cout << i << '\n';
+  cout << i << '\n';
 }
 ```
 
 chain.from\_iterable
--------------------
-
+--------------------
 Similar to chain, but rather than taking a variadic number of iterables,
 it takes an iterable of iterables and chains the contained iterables together.
 A simple example is shown below using a vector of vectors to represent
 a 2d ragged array, and prints it in row-major order.
+
 ```c++
 vector<vector<int>> matrix = {
-    {1, 2, 3},
-    {4, 5},
-    {6, 8, 9, 10, 11, 12}
+  {1, 2, 3},
+  {4, 5},
+  {6, 8, 9, 10, 11, 12}
 };
 
 for (auto&& i : chain.from_iterable(matrix)) {
-    cout << i << '\n';
+  cout << i << '\n';
 }
 ```
 
 reversed
--------
+--------
 *Additional Requirements*: Input must be compatible with `std::rbegin()` and
 `std::rend()`
 
@@ -724,7 +739,7 @@ Iterates over elements of a sequence in reverse order.
 
 ```c++
 for (auto&& i : reversed(a)) {
-    cout << i << '\n';
+  cout << i << '\n';
 }
 ```
 
@@ -735,18 +750,19 @@ Returns selected elements from a range, parameters are start, stop and step.
 the range returned is [start,stop) where you only take every step element
 
 This outputs `0 3 6 9 12`
+
 ```c++
 vector<int> a{0,1,2,3,4,5,6,7,8,9,10,11,12,13};
 for (auto&& i : slice(a,0,15,3)) {
-    cout << i << '\n';
+  cout << i << '\n';
 }
 ```
 
 sliding\_window
--------------
+---------------
 *Additional Requirements*: Input must have a ForwardIterator
 
-Takes a section from a range and increments the whole section.  If the
+Takes a section from a range and increments the whole section. If the
 window size is larger than the length of the input, the `sliding_window` will
 yield nothing (begin == end).
 
@@ -764,60 +780,65 @@ take a section of size 4, output is:
 ```
 
 Example Usage:
+
 ```c++
 vector<int> v = {1,2,3,4,5,6,7,8,9};
 for (auto&& sec : sliding_window(v,4)) {
-    for (auto&& i : sec) {
-        cout << i << ' ';
-        i.get() = 90;
-    }
-    cout << '\n';
+  for (auto&& i : sec) {
+    cout << i << ' ';
+    i.get() = 90;
+  }
+  cout << '\n';
 }
 ```
-chunked
-------
 
+chunked
+-------
 chunked will yield subsequent chunks of an iterable in blocks of a specified
 size. The final chunk may be shorter than the rest if the chunk size given
 does not evenly divide the length of the iterable.
 
 Example usage:
+
 ```c++
 vector<int> v {1,2,3,4,5,6,7,8,9};
 for (auto&& sec : chunked(v,4)) {
-    for (auto&& i : sec) {
-        cout << i << ' ';
-    }
-    cout << '\n';
+  for (auto&& i : sec) {
+    cout << i << ' ';
+  }
+  cout << '\n';
 }
 ```
 
 The above prints:
+
 ```
 1 2 3 4
 5 6 7 8
 9
 ```
+
 batched
 -------
-
 batched will yield a given number N of batches containing subsequent elements from an iterable,
 assuming the iterable contains at least N elements.
 The size of each batch is immaterial, but the implementation guarantees that no two batches will
 differ in size by more than 1.
 
 Example usage:
+
 ```c++
 vector<int> v {1,2,3,4,5,6,7,8,9};
 for (auto&& sec : batched(v,4)) {
-    for (auto&& i : sec) {
-        cout << i << ' ';
-    }
-    cout << '\n';
+  for (auto&& i : sec) {
+    cout << i << ' ';
+  }
+  cout << '\n';
 }
 ```
 
 The above prints:
+
 ```
 1 2 3
 4 5
@@ -826,54 +847,60 @@ The above prints:
 ```
 
 product
-------
+-------
 *Additional Requirements*: Input must have a ForwardIterator
 
 Generates the cartesian product of the given ranges put together.
 
 Example usage:
+
 ```c++
 vector<int> v1{1,2,3};
 vector<int> v2{7,8};
 vector<string> v3{"the","cat"};
 vector<string> v4{"hi","what's","up","dude"};
 for (auto&& [a, b, c, d] : product(v1,v2,v3,v4)) {
-    cout << a << ", " << b << ", " << c << ", " << d << '\n';
+  cout << a << ", " << b << ", " << c << ", " << d << '\n';
 }
 ```
 
-Product also accepts a "repeat" as a template argument. Currently this is the only way to do repeats. **If you are reading this and need `product(seq, 3)` instead of `product<3>(seq)` please open an issue**.
+Product also accepts a "repeat" as a template argument. Currently this is the
+only way to do repeats. **If you are reading this and need `product(seq, 3)`
+instead of `product<3>(seq)` please open an issue**.
 
 Example usage:
+
 ```c++
 std::string s = "abc";
 // equivalent of product(s, s, s);
 for (auto&& t : product<3>(s)) {
-   // ...
+  // ...
 }
 ```
 
 combinations
------------
+------------
 *Additional Requirements*: Input must have a ForwardIterator
 
 Generates n length unique sequences of the input range.
 
 Example usage:
+
 ```c++
 vector<int> v = {1,2,3,4,5};
 for (auto&& i : combinations(v,3)) {
-    for (auto&& j : i ) cout << j << " ";
-    cout << '\n';
+  for (auto&& j : i ) cout << j << " ";
+  cout << '\n';
 }
 ```
 
 combinations\_with\_replacement
------------------------------
+-------------------------------
 *Additional Requirements*: Input must have a ForwardIterator
 
-Like combinations, but with replacement of each element.  The
+Like combinations, but with replacement of each element. The
 below is printed by the loop that follows:
+
 ```
 {A, A}
 {A, B}
@@ -882,43 +909,46 @@ below is printed by the loop that follows:
 {B, C}
 {C, C}
 ```
+
 ```c++
 for (auto&& v : combinations_with_replacement(s, 2)) {
-    cout << '{' << v[0] << ", " << v[1] << "}\n";
+  cout << '{' << v[0] << ", " << v[1] << "}\n";
 }
 ```
 
 permutations
------------
-*Additional Requirements*: Input must have a ForwardIterator.  Iterator must
+------------
+*Additional Requirements*: Input must have a ForwardIterator. Iterator must
 have an `operator*() const`.
 
 Generates all the permutations of a range using `std::next_permutation`.
 
 Example usage:
+
 ```c++
 vector<int> v = {1,2,3,4,5};
 for (auto&& vec : permutations(v)) {
-    for (auto&& i : vec) {
-        cout << i << ' ';
-    }
-    cout << '\n';
+  for (auto&& i : vec) {
+    cout << i << ' ';
+  }
+  cout << '\n';
 }
 ```
 
 powerset
--------
+--------
 *Additional Requirements*: Input must have a ForwardIterator
 
 Generates every possible subset of a set, runs in O(2^n).
 
 Example usage:
+
 ```c++
 vector<int> vec {1,2,3,4,5,6,7,8,9};
 for (auto&& v : powerset(vec)) {
-    for (auto&& i : v) {
-        cout << i << " ";
-    }
-    cout << '\n';
+  for (auto&& i : v) {
+    cout << i << " ";
+  }
+  cout << '\n';
 }
 ```