diff --git a/make_single_header.py b/make_single_header.py
new file mode 100644
index 00000000..ac7c9eea
--- /dev/null
+++ b/make_single_header.py
@@ -0,0 +1,44 @@
+import os
+
+def add_header(header_name, index, included_headers, target_file):
+    lines = [line for line in open(header_name)]
+
+    for line in lines:
+        line = line.rstrip()
+        is_line_to_be_skipped = line.startswith('#include "')
+        if line.startswith('#include <'):
+            if line in included_headers:
+                is_line_to_be_skipped = True
+            else:
+                included_headers.append(line)
+
+        if not is_line_to_be_skipped:
+            target_file.write(line + '\n')        
+
+
+def add_internal_headers(included_headers, target_file): 
+    internal_headers = ['iterbase', 'iterator_wrapper', 'iter_tuples', 'iteratoriterator']
+    for internal_header in internal_headers:
+        add_header('internal/' + internal_header + '.hpp', 0, included_headers, target_file)
+
+
+def add_headers(included_headers, target_file):
+    add_header('./filter.hpp', 7, included_headers, target_file)
+    add_header('./starmap.hpp', 8, included_headers, target_file)
+    add_header('./zip.hpp', 9, included_headers, target_file)
+    directory = os.fsencode('./')
+    for index, file in enumerate(sorted(os.listdir(directory))):
+        filename = os.fsdecode(file)
+        if filename.endswith('.hpp') and not filename in ['single_header.hpp', 'filter.hpp', 'starmap.hpp', 'zip.hpp', 'zip_longest.hpp']:
+            add_header(filename, 10 + index, included_headers, target_file)
+
+
+def run():
+    with open('single_header.hpp', 'w') as target_file:
+        included_headers = []
+        add_internal_headers(included_headers, target_file)
+        add_headers(included_headers, target_file)
+
+
+if __name__ == '__main__':
+    run()
diff --git a/single_header.hpp b/single_header.hpp
new file mode 100644
index 00000000..85afec55
--- /dev/null
+++ b/single_header.hpp
@@ -0,0 +1,5007 @@
+#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.  No user code should include
+// this file directly.
+
+#include <cassert>
+#include <cstddef>
+#include <functional>
+#include <iterator>
+#include <optional>
+#include <tuple>
+#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 {
+      // 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(get_begin_impl(std::declval<T&>(), 42)) {
+        return get_begin_impl(t, 42);
+      }
+
+      // 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(get_end_impl(std::declval<T&>(), 42)) {
+        return get_end_impl(t, 42);
+      }
+    }
+    using get_iters::get_begin;
+    using get_iters::get_end;
+
+    template <typename T>
+    struct type_is {
+      using type = T;
+    };
+
+    template <typename T>
+    using AsConst = decltype(std::as_const(std::declval<T&>()));
+
+    // iterator_type<C> is the type of C's iterator
+    // 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>
+    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>
+    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>&>());
+
+    // 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>>;
+
+    template <typename T, typename = void>
+    struct IsIterable : std::false_type {};
+
+    // Assuming that if a type works with begin, it is an iterable.
+    template <typename T>
+    struct IsIterable<T, std::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 {
+        using type = void;
+        void operator()(T&) const noexcept {}
+      };
+
+      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,
+          std::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>>;
+
+    // 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;
+      }
+    };
+
+    template <typename, typename = void>
+    struct is_random_access_iter : std::false_type {};
+
+    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 {};
+
+    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_unsafe(InputIt& iter, Distance distance) {
+      for (Distance i(0); i < distance; ++i) {
+        ++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>{});
+    }
+
+    template <typename ForwardIt, typename Distance = std::size_t>
+    ForwardIt dumb_next(ForwardIt it, Distance distance = 1) {
+      dumb_advance_unsafe(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};
+      auto end_it = get_end(container);
+      for (auto it = get_begin(container); it != end_it; ++it) {
+        ++d;
+      }
+      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>
+    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 = std::remove_reference_t<T>;
+
+      std::optional<TPlain> item_p_;
+
+     public:
+      using reference = TPlain&;
+      using pointer = TPlain*;
+
+      static constexpr bool stores_value = true;
+
+      DerefHolder() = default;
+
+      reference get() {
+        assert(item_p_.has_value());
+        return *item_p_;
+      }
+
+      pointer get_ptr() {
+        assert(item_p_.has_value());
+        return &item_p_.value();
+      }
+
+      void reset(T&& item) {
+        item_p_.emplace(std::move(item));
+      }
+
+      explicit operator bool() const {
+        return static_cast<bool>(item_p_);
+      }
+    };
+
+    // Specialization for when T is an lvalue ref
+    template <typename T>
+    class DerefHolder<T&> {
+     public:
+      using reference = T&;
+      using pointer = T*;
+
+     private:
+      pointer item_p_{};
+
+     public:
+      static constexpr bool stores_value = false;
+
+      DerefHolder() = default;
+
+      reference get() {
+        assert(item_p_);
+        return *item_p_;
+      }
+
+      pointer get_ptr() {
+        assert(item_p_);
+        return item_p_;
+      }
+
+      void reset(reference item) {
+        item_p_ = &item;
+      }
+
+      explicit operator bool() const {
+        return 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 ItTool>
+    struct Pipeable {
+      template <typename T>
+      friend decltype(auto) operator|(T&& x, const Pipeable& p) {
+        return static_cast<const ItTool&>(p)(std::forward<T>(x));
+      }
+    };
+
+    // 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)...};
+      }
+    };
+
+    // 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;
+        constexpr FnPartial(T in_t) : stored_arg(in_t) {}
+
+        template <typename Container>
+        auto operator()(Container&& container) const {
+          return F{}(stored_arg, std::forward<Container>(container));
+        }
+      };
+
+     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)};
+      }
+    };
+
+    // 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
+    //  (3) with just a callable, to have the iterable passed later via pipe
+    template <template <typename, typename> class ItImpl, typename DefaultT>
+    struct IterToolFnOptionalBindFirst
+        : 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>
+      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>{});
+      }
+
+      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>
+    struct IterToolFnOptionalBindSecond
+        : Pipeable<IterToolFnOptionalBindSecond<ItImpl, DefaultT>> {
+     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 T>
+      ItImpl<Container, T> operator()(Container&& container, T func) const {
+        return {std::forward<Container>(container), 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), 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};
+      }
+    };
+  }
+}
+
+#endif
+#ifndef ITERTOOLS_ITERATOR_WRAPPER_HPP_
+#define ITERTOOLS_ITERATOR_WRAPPER_HPP_
+
+#include <variant>
+
+namespace iter {
+  namespace impl {
+    // iterator_end_type<C> is the type of C's end iterator
+    template <typename Container>
+    using iterator_end_type = decltype(get_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_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_v<SubIter, SubEnd>);
+  SubIter& sub_iter() {
+    auto* sub = std::get_if<SubIter>(&sub_iter_or_end_);
+    assert(sub);
+    return *sub;
+  }
+
+  const SubIter& sub_iter() const {
+    auto* sub = std::get_if<SubIter>(&sub_iter_or_end_);
+    assert(sub);
+    return *sub;
+  }
+
+  std::variant<SubIter, SubEnd> sub_iter_or_end_;
+
+ public:
+  IteratorWrapperImpl() : IteratorWrapperImpl(SubIter{}) {}
+
+  IteratorWrapperImpl(SubIter&& it) : sub_iter_or_end_{std::move(it)} {}
+
+  IteratorWrapperImpl(SubEnd&& it) : sub_iter_or_end_(std::move(it)) {}
+
+  IteratorWrapperImpl& operator++() {
+    ++sub_iter();
+    return *this;
+  }
+
+  decltype(auto) operator*() {
+    return *sub_iter();
+  }
+
+  decltype(auto) operator*() const {
+    return *sub_iter();
+  }
+
+  decltype(auto) operator-> () {
+    return apply_arrow(sub_iter());
+  }
+
+  decltype(auto) operator-> () const {
+    return apply_arrow(sub_iter());
+  }
+
+  bool operator!=(const IteratorWrapperImpl& other) const {
+    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;
+      }
+      using std::not_equal_to<void>::operator();
+    } 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
+#ifndef ITERTOOLS_ITER_TUPLES_HPP_
+#define ITERTOOLS_ITER_TUPLES_HPP_
+
+
+
+namespace iter {
+  namespace impl {
+    namespace detail {
+      template <typename... Ts>
+      std::tuple<iterator_deref<Ts>...> iterator_tuple_deref_helper(
+          const std::tuple<Ts...>&);
+
+      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.
+    template <typename TupleType>
+    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
+    template <typename TupleType>
+    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
+    template <typename... Ts>
+    void absorb(Ts&&...) {}
+  }
+}
+
+#endif
+#ifndef ITERATOR_ITERATOR_HPP_
+#define ITERATOR_ITERATOR_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
+// 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 {
+  namespace impl {
+    template <typename T, typename = void>
+    struct HasConstDeref : std::false_type {};
+
+    template <typename T>
+    struct HasConstDeref<T, std::void_t<decltype(*std::declval<const T&>())>>
+        : std::true_type {};
+
+    template <typename TopIter>
+    class IteratorIterator {
+      template <typename> friend class IteratorIterator;
+      using Diff = std::ptrdiff_t;
+      static_assert(
+          std::is_same<
+              typename std::iterator_traits<TopIter>::iterator_category,
+              std::random_access_iterator_tag>::value,
+          "IteratorIterator only works with random access iterators");
+
+     private:
+      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} {}
+
+      const TopIter& get() const {
+        return sub_iter;
+      }
+
+      template <typename T>
+      bool operator==(const IteratorIterator<T>& other) const {
+        return !(*this != other);
+      }
+
+      template <typename T>
+      bool operator!=(const IteratorIterator<T>& 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*() const -> decltype(**sub_iter) {
+        return **this->sub_iter;
+      }
+
+      auto operator-> () const -> 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;
+      }
+
+      Diff operator-(const IteratorIterator& rhs) const {
+        return this->sub_iter - rhs.sub_iter;
+      }
+
+      auto operator[](Diff idx) const -> 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,
+          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;
+
+      template <typename U = Container, typename = void>
+      struct ConstIndexTypeOrVoid : type_is<void> {};
+
+      template <typename U>
+      struct ConstIndexTypeOrVoid<U,
+          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;
+
+     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
+#ifndef ITER_FILTER_H_
+#define ITER_FILTER_H_
+
+
+#include <initializer_list>
+
+namespace iter {
+  namespace impl {
+    template <typename FilterFunc, typename Container>
+    class Filtered;
+
+    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>
+class iter::impl::Filtered {
+ private:
+  Container container_;
+  mutable FilterFunc filter_func_;
+
+  friend FilterFn;
+
+ protected:
+  // Value constructor for use only in the filter function
+  Filtered(FilterFunc filter_func, Container&& container)
+      : container_(std::forward<Container>(container)),
+        filter_func_(filter_func) {}
+
+ public:
+  Filtered(Filtered&&) = default;
+
+  template <typename ContainerT>
+  class Iterator {
+   private:
+    template <typename>
+    friend class Iterator;
+    using Holder = DerefHolder<iterator_deref<ContainerT>>;
+    mutable IteratorWrapper<ContainerT> sub_iter_;
+    IteratorWrapper<ContainerT> sub_end_;
+    mutable Holder item_;
+    FilterFunc* filter_func_;
+
+    // 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_);
+      }
+    }
+
+    // increment until the iterator points to is true on the
+    // predicate.  Called by constructor and operator++
+    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>;
+    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)},
+          sub_end_{std::move(sub_end)},
+          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;
+    }
+
+    Iterator operator++(int) {
+      auto ret = *this;
+      ++*this;
+      return ret;
+    }
+
+    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_;
+    }
+
+    template <typename T>
+    bool operator==(const Iterator<T>& other) const {
+      return !(*this != other);
+    }
+  };
+
+  Iterator<Container> begin() {
+    return {get_begin(container_), get_end(container_), filter_func_};
+  }
+
+  Iterator<Container> end() {
+    return {get_end(container_), get_end(container_), filter_func_};
+  }
+
+  Iterator<AsConst<Container>> begin() const {
+    return {get_begin(std::as_const(container_)),
+        get_end(std::as_const(container_)), filter_func_};
+  }
+
+  Iterator<AsConst<Container>> end() const {
+    return {get_end(std::as_const(container_)),
+        get_end(std::as_const(container_)), filter_func_};
+  }
+};
+
+#endif
+#ifndef ITER_STARMAP_H_
+#define ITER_STARMAP_H_
+
+
+#include <array>
+#include <memory>
+
+namespace iter {
+  namespace impl {
+    template <typename Func, typename Container>
+    class StarMapper;
+
+    template <typename Func, typename TupType, std::size_t... Is>
+    class TupleStarMapper;
+
+    struct StarMapFn;
+  }
+}
+
+// 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
+template <typename Func, typename Container>
+class iter::impl::StarMapper {
+ private:
+  mutable Func func_;
+  Container container_;
+
+  using StarIterDeref = std::remove_reference_t<decltype(
+      std::apply(func_, std::declval<iterator_deref<Container>>()))>;
+
+  StarMapper(Func f, Container&& c)
+      : func_(std::move(f)), container_(std::forward<Container>(c)) {}
+
+  friend StarMapFn;
+
+ public:
+  template <typename ContainerT>
+  class Iterator {
+   private:
+    template <typename>
+    friend class Iterator;
+    Func* func_;
+    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)) {}
+
+    template <typename T>
+    bool operator!=(const Iterator<T>& other) const {
+      return sub_iter_ != other.sub_iter_;
+    }
+
+    template <typename T>
+    bool operator==(const Iterator<T>& other) const {
+      return !(*this != other);
+    }
+
+    Iterator& operator++() {
+      ++sub_iter_;
+      return *this;
+    }
+
+    Iterator operator++(int) {
+      auto ret = *this;
+      ++*this;
+      return ret;
+    }
+
+    decltype(auto) operator*() {
+      return std::apply(*func_, *sub_iter_);
+    }
+
+    auto operator-> () -> ArrowProxy<decltype(**this)> {
+      return {**this};
+    }
+  };
+
+  Iterator<Container> begin() {
+    return {func_, get_begin(container_)};
+  }
+
+  Iterator<Container> end() {
+    return {func_, get_end(container_)};
+  }
+
+  Iterator<AsConst<Container>> begin() const {
+    return {func_, get_begin(std::as_const(container_))};
+  }
+
+  Iterator<AsConst<Container>> end() const {
+    return {func_, get_end(std::as_const(container_))};
+  }
+};
+
+// starmap for a tuple or pair of tuples or pairs
+template <typename Func, typename TupType, std::size_t... Is>
+class iter::impl::TupleStarMapper {
+ private:
+  mutable Func func_;
+  TupType tup_;
+
+ private:
+  static_assert(sizeof...(Is) == std::tuple_size<std::decay_t<TupType>>::value,
+      "tuple size doesn't match size of Is");
+
+  friend StarMapFn;
+
+  TupleStarMapper(Func f, TupType t)
+      : func_(std::move(f)), tup_(std::forward<TupType>(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 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));
+    }
+
+    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>...}};
+
+    using TraitsValue = std::remove_reference_t<ResultType>;
+
+    IteratorData() = delete;
+  };
+
+ public:
+  template <typename TupTypeT>
+  class Iterator {
+   private:
+    template <typename>
+    friend class Iterator;
+    Func* func_;
+    std::remove_reference_t<TupTypeT>* tup_;
+    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} {}
+
+    decltype(auto) operator*() {
+      return IteratorData<TupTypeT>::callers[index_](*func_, *tup_);
+    }
+
+    auto operator-> () {
+      return ArrowProxy<decltype(**this)>{**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<TupType> end() {
+    return {func_, tup_, sizeof...(Is)};
+  }
+
+  Iterator<AsConst<TupType>> begin() const {
+    return {func_, std::as_const(tup_), 0};
+  }
+
+  Iterator<AsConst<TupType>> end() const {
+    return {func_, std::as_const(tup_), sizeof...(Is)};
+  }
+};
+
+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)};
+  }
+
+  template <typename T, typename = void>
+  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)>>
+      : std::true_type {};
+
+ 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 {
+      return StarMapper<Func, Seq>{
+          std::move(func), std::forward<Seq>(sequence)};
+    }
+  }
+
+  using PipeableAndBindFirst<StarMapFn>::operator();
+};
+
+namespace iter {
+  constexpr impl::StarMapFn starmap{};
+}
+
+#endif
+#ifndef ITER_ZIP_HPP_
+#define ITER_ZIP_HPP_
+
+
+#include <algorithm>
+
+namespace iter {
+  namespace impl {
+    template <typename TupleType, std::size_t... Is>
+    class Zipped;
+
+    template <typename TupleType, std::size_t... Is>
+    Zipped<TupleType, Is...> zip_impl(TupleType&&, std::index_sequence<Is...>);
+  }
+
+  template <typename... Containers>
+  auto zip(Containers&&... containers);
+}
+
+template <typename TupleType, std::size_t... Is>
+class iter::impl::Zipped {
+ private:
+  TupleType containers_;
+  friend Zipped iter::impl::zip_impl<TupleType, Is...>(
+      TupleType&&, std::index_sequence<Is...>);
+
+  Zipped(TupleType&& containers) : containers_(std::move(containers)) {}
+
+ public:
+  Zipped(Zipped&&) = default;
+
+  // 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 {
+    // 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:
+    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++() {
+      absorb(++std::get<Is>(iters_)...);
+      return *this;
+    }
+
+    Iterator operator++(int) {
+      auto ret = *this;
+      ++*this;
+      return ret;
+    }
+
+    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;
+      } else {
+        return (... && (std::get<Is>(iters_) != std::get<Is>(other.iters_)));
+      }
+    }
+
+    template <typename T, template <typename> class IT,
+        template <typename> class TD>
+    bool operator==(const Iterator<T, IT, TD>& other) const {
+      return !(*this != other);
+    }
+
+    TupleDeref<TupleTypeT> operator*() {
+      return {(*std::get<Is>(iters_))...};
+    }
+
+    auto operator-> () -> ArrowProxy<decltype(**this)> {
+      return {**this};
+    }
+  };
+
+  Iterator<TupleType, iterator_tuple_type, iterator_deref_tuple> begin() {
+    return {{get_begin(std::get<Is>(containers_))...}};
+  }
+
+  Iterator<TupleType, iterator_tuple_type, iterator_deref_tuple> end() {
+    return {{get_end(std::get<Is>(containers_))...}};
+  }
+
+  Iterator<AsConst<TupleType>, const_iterator_tuple_type,
+      const_iterator_deref_tuple>
+  begin() const {
+    return {{get_begin(std::as_const(std::get<Is>(containers_)))...}};
+  }
+
+  Iterator<AsConst<TupleType>, const_iterator_tuple_type,
+      const_iterator_deref_tuple>
+  end() const {
+    return {{get_end(std::as_const(std::get<Is>(containers_)))...}};
+  }
+};
+
+template <typename TupleType, std::size_t... Is>
+iter::impl::Zipped<TupleType, Is...> iter::impl::zip_impl(
+    TupleType&& containers, std::index_sequence<Is...>) {
+  return {std::move(containers)};
+}
+
+template <typename... Containers>
+auto iter::zip(Containers&&... containers) {
+  return impl::zip_impl(
+      std::tuple<Containers...>{std::forward<Containers>(containers)...},
+      std::index_sequence_for<Containers...>{});
+}
+
+#endif
+#ifndef ITER_ACCUMULATE_H_
+#define ITER_ACCUMULATE_H_
+
+
+
+namespace iter {
+  namespace impl {
+    template <typename Container, typename AccumulateFunc>
+    class Accumulator;
+
+    using AccumulateFn = IterToolFnOptionalBindSecond<Accumulator, std::plus<>>;
+  }
+  constexpr impl::AccumulateFn accumulate{};
+}
+
+template <typename Container, typename AccumulateFunc>
+class iter::impl::Accumulator {
+ private:
+  Container container_;
+  mutable AccumulateFunc accumulate_func_;
+
+  friend AccumulateFn;
+
+  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)),
+        accumulate_func_(accumulate_func) {}
+
+ public:
+  Accumulator(Accumulator&&) = default;
+
+  template <typename ContainerT>
+  class Iterator {
+   private:
+    template <typename>
+    friend class Iterator;
+    IteratorWrapper<ContainerT> sub_iter_;
+    IteratorWrapper<ContainerT> sub_end_;
+    AccumulateFunc* accumulate_func_;
+    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)},
+          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_)
+                       ? std::nullopt
+                       : std::make_optional<AccumVal>(*sub_iter_)} {}
+
+    const AccumVal& operator*() const {
+      return *acc_val_;
+    }
+
+    const AccumVal* operator->() const {
+      return &*acc_val_;
+    }
+
+    Iterator& operator++() {
+      ++sub_iter_;
+      if (sub_iter_ != sub_end_) {
+        *acc_val_ = std::invoke(*accumulate_func_, *acc_val_, *sub_iter_);
+      }
+      return *this;
+    }
+
+    Iterator operator++(int) {
+      auto ret = *this;
+      ++*this;
+      return ret;
+    }
+
+    template <typename T>
+    bool operator!=(const Iterator<T>& other) const {
+      return sub_iter_ != other.sub_iter_;
+    }
+
+    template <typename T>
+    bool operator==(const Iterator<T>& other) const {
+      return !(*this != other);
+    }
+  };
+
+  Iterator<Container> begin() {
+    return {get_begin(container_), get_end(container_), accumulate_func_};
+  }
+
+  Iterator<Container> end() {
+    return {get_end(container_), get_end(container_), accumulate_func_};
+  }
+  Iterator<AsConst<Container>> begin() const {
+    return {get_begin(std::as_const(container_)),
+        get_end(std::as_const(container_)), accumulate_func_};
+  }
+
+  Iterator<AsConst<Container>> end() const {
+    return {get_end(std::as_const(container_)),
+        get_end(std::as_const(container_)), accumulate_func_};
+  }
+};
+
+#endif
+#ifndef ITER_BATCHED_HPP_
+#define ITER_BATCHED_HPP_
+
+
+#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&;
+
+    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>(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
+#ifndef ITER_CHAIN_HPP_
+#define ITER_CHAIN_HPP_
+
+
+
+namespace iter {
+  namespace impl {
+    template <typename TupType, std::size_t... Is>
+    class Chained;
+
+    template <typename Container>
+    class ChainedFromIterable;
+
+    using ChainFromIterableFn = IterToolFn<ChainedFromIterable>;
+
+    // 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;
+  }
+}
+
+template <typename TupType, std::size_t... Is>
+class iter::impl::Chained {
+ private:
+  friend ChainMaker;
+
+  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.");
+
+   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 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);
+    }
+
+    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>...}};
+
+    constexpr static std::array<ArrowFunc, sizeof...(Is)> arrowers{
+        {get_and_arrow<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>...}};
+
+    using TraitsValue =
+        iterator_traits_deref<std::tuple_element_t<0, TupTypeT>>;
+  };
+
+  Chained(TupType&& t) : tup_(std::move(t)) {}
+  TupType tup_;
+
+ public:
+  Chained(Chained&&) = default;
+
+  template <typename TupTypeT>
+  class Iterator {
+   private:
+    using IterData = IteratorData<TupTypeT>;
+    std::size_t index_;
+    typename IterData::IterTupType iters_;
+    typename IterData::IterTupType ends_;
+
+    void check_for_end_and_adjust() {
+      while (index_ < sizeof...(Is)
+             && !(IterData::neq_comparers[index_](iters_, ends_))) {
+        ++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(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 IterData::derefers[index_](iters_);
+    }
+
+    decltype(auto) operator-> () {
+      return IterData::arrowers[index_](iters_);
+    }
+
+    Iterator& operator++() {
+      IterData::incrementers[index_](iters_);
+      check_for_end_and_adjust();
+      return *this;
+    }
+
+    Iterator operator++(int) {
+      auto ret = *this;
+      ++*this;
+      return ret;
+    }
+
+    // TODO make const and non-const iterators comparable
+    bool operator!=(const Iterator& other) const {
+      return index_ != other.index_
+             || (index_ != sizeof...(Is)
+                    && IterData::neq_comparers[index_](iters_, other.iters_));
+    }
+
+    bool operator==(const Iterator& other) const {
+      return !(*this != other);
+    }
+  };
+
+  Iterator<TupType> begin() {
+    return {0, {get_begin(std::get<Is>(tup_))...},
+        {get_end(std::get<Is>(tup_))...}};
+  }
+
+  Iterator<TupType> end() {
+    return {sizeof...(Is), {get_end(std::get<Is>(tup_))...},
+        {get_end(std::get<Is>(tup_))...}};
+  }
+
+  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<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_)))...}};
+  }
+};
+
+template <typename Container>
+class iter::impl::ChainedFromIterable {
+ private:
+  friend ChainFromIterableFn;
+  Container container_;
+  ChainedFromIterable(Container&& container)
+      : container_(std::forward<Container>(container)) {}
+
+ public:
+  ChainedFromIterable(ChainedFromIterable&&) = default;
+  template <typename ContainerT>
+  class Iterator {
+   private:
+    template <typename>
+    friend class Iterator;
+    using SubContainer = iterator_deref<ContainerT>;
+    using SubIter = IteratorWrapper<SubContainer>;
+
+    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 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_ =
+            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();
+      }
+    }
+
+    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>>;
+    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)},
+          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_;
+        next_sub_iterable();
+      }
+      return *this;
+    }
+
+    Iterator operator++(int) {
+      auto ret = *this;
+      ++*this;
+      return ret;
+    }
+
+    template <typename T>
+    bool operator!=(const Iterator<T>& other) const {
+      return top_level_iter_ != other.top_level_iter_
+             || sub_iter_p_ != other.sub_iter_p_;
+    }
+
+    template <typename T>
+    bool operator==(const Iterator<T>& other) const {
+      return !(*this != other);
+    }
+
+    iterator_deref<iterator_deref<ContainerT>> operator*() {
+      return **sub_iter_p_;
+    }
+
+    iterator_arrow<iterator_deref<ContainerT>> operator->() {
+      return apply_arrow(*sub_iter_p_);
+    }
+  };
+
+  Iterator<Container> begin() {
+    return {get_begin(container_), get_end(container_)};
+  }
+
+  Iterator<Container> end() {
+    return {get_end(container_), get_end(container_)};
+  }
+
+  Iterator<AsConst<Container>> begin() const {
+    return {get_begin(std::as_const(container_)),
+        get_end(std::as_const(container_))};
+  }
+
+  Iterator<AsConst<Container>> end() const {
+    return {
+        get_end(std::as_const(container_)), get_end(std::as_const(container_))};
+  }
+};
+
+class iter::impl::ChainMaker {
+ private:
+  template <typename TupleType, std::size_t... Is>
+  Chained<TupleType, Is...> chain_impl(
+      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 chain_impl(
+        std::tuple<Containers...>{std::forward<Containers>(cs)...},
+        std::index_sequence_for<Containers...>{});
+  }
+
+  ChainFromIterableFn from_iterable;
+};
+
+namespace iter {
+  namespace {
+    constexpr auto chain = iter::impl::ChainMaker{};
+  }
+}
+
+#endif
+#ifndef ITER_CHUNKED_HPP_
+#define ITER_CHUNKED_HPP_
+
+
+
+namespace iter {
+  namespace impl {
+    template <typename Container>
+    class Chunker;
+
+    using ChunkedFn = IterToolFnBindSizeTSecond<Chunker>;
+  }
+  constexpr impl::ChunkedFn chunked{};
+}
+
+template <typename Container>
+class iter::impl::Chunker {
+ private:
+  Container container_;
+  std::size_t chunk_size_;
+
+  Chunker(Container&& container, std::size_t sz)
+      : container_(std::forward<Container>(container)), chunk_size_{sz} {}
+
+  friend ChunkedFn;
+
+  template <typename T>
+  using IndexVector = std::vector<IteratorWrapper<T>>;
+  template <typename T>
+  using DerefVec = IterIterWrapper<IndexVector<T>>;
+
+ public:
+  Chunker(Chunker&&) = default;
+  template <typename ContainerT>
+  class Iterator {
+   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_;
+    std::size_t chunk_size_ = 0;
+
+    bool done() const {
+      return chunk_->empty();
+    }
+
+    void refill_chunk() {
+      chunk_->get().clear();
+      std::size_t i{0};
+      while (i < chunk_size_ && sub_iter_ != sub_end_) {
+        chunk_->get().push_back(sub_iter_);
+        ++sub_iter_;
+        ++i;
+      }
+    }
+
+   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)},
+          sub_end_{std::move(sub_end)},
+          chunk_size_{s} {
+      chunk_->get().reserve(chunk_size_);
+      refill_chunk();
+    }
+
+    Iterator& operator++() {
+      refill_chunk();
+      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 *chunk_;
+    }
+
+    DerefVec<ContainerT>* operator->() {
+      return chunk_.get();
+    }
+  };
+
+  Iterator<Container> begin() {
+    return {get_begin(container_), get_end(container_), chunk_size_};
+  }
+
+  Iterator<Container> end() {
+    return {get_end(container_), get_end(container_), chunk_size_};
+  }
+
+  Iterator<AsConst<Container>> begin() const {
+    return {get_begin(std::as_const(container_)),
+        get_end(std::as_const(container_)), chunk_size_};
+  }
+
+  Iterator<AsConst<Container>> end() const {
+    return {get_end(std::as_const(container_)),
+        get_end(std::as_const(container_)), chunk_size_};
+  }
+};
+
+#endif
+#ifndef ITER_COMBINATIONS_HPP_
+#define ITER_COMBINATIONS_HPP_
+
+
+
+namespace iter {
+  namespace impl {
+    template <typename Container>
+    class Combinator;
+
+    using CombinationsFn = IterToolFnBindSizeTSecond<Combinator>;
+  }
+  constexpr impl::CombinationsFn combinations{};
+}
+
+template <typename Container>
+class iter::impl::Combinator {
+ private:
+  Container container_;
+  std::size_t length_;
+
+  friend CombinationsFn;
+
+  Combinator(Container&& container, std::size_t length)
+      : container_(std::forward<Container>(container)), length_{length} {}
+
+  template <typename T>
+  using IndexVector = std::vector<iterator_type<T>>;
+  template <typename T>
+  using CombIteratorDeref = IterIterWrapper<IndexVector<T>>;
+
+ public:
+  Combinator(Combinator&&) = default;
+  template <typename ContainerT>
+  class Iterator {
+   private:
+    template <typename>
+    friend class Iterator;
+    constexpr static const int COMPLETE = -1;
+    std::remove_reference_t<ContainerT>* container_p_;
+    CombIteratorDeref<ContainerT> indices_;
+    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) {
+        steps_ = COMPLETE;
+        return;
+      }
+      size_t inc = 0;
+      for (auto& iter : indices_.get()) {
+        auto it = get_begin(*container_p_);
+        dumb_advance(it, get_end(*container_p_), inc);
+        if (it != get_end(*container_p_)) {
+          iter = it;
+          ++inc;
+        } else {
+          steps_ = COMPLETE;
+          break;
+        }
+      }
+    }
+
+    CombIteratorDeref<ContainerT>& operator*() {
+      return indices_;
+    }
+
+    CombIteratorDeref<ContainerT>* operator->() {
+      return &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(indices_.get().rbegin(), iter);
+
+        if (!(dumb_next(*iter, dist) != get_end(*container_p_))) {
+          if ((iter + 1) != indices_.get().rend()) {
+            size_t inc = 1;
+            for (auto down = iter; ; --down) {
+              (*down) = dumb_next(*(iter + 1), 1 + inc);
+              ++inc;
+              if (down == indices_.get().rbegin())
+                break;
+            }
+          } else {
+            steps_ = COMPLETE;
+            break;
+          }
+        } else {
+          break;
+        }
+        // we break because none of the rest of the items need
+        // to be incremented
+      }
+      if (steps_ != COMPLETE) {
+        ++steps_;
+      }
+      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 steps_ == other.steps_;
+    }
+  };
+
+  Iterator<Container> begin() {
+    return {container_, length_};
+  }
+
+  Iterator<Container> end() {
+    return {container_, 0};
+  }
+
+  Iterator<AsConst<Container>> begin() const {
+    return {std::as_const(container_), length_};
+  }
+
+  Iterator<AsConst<Container>> end() const {
+    return {std::as_const(container_), 0};
+  }
+};
+
+#endif
+#ifndef ITER_COMBINATIONS_WITH_REPLACEMENT_HPP_
+#define ITER_COMBINATIONS_WITH_REPLACEMENT_HPP_
+
+
+
+namespace iter {
+  namespace impl {
+    template <typename Container>
+    class CombinatorWithReplacement;
+    using CombinationsWithReplacementFn =
+        IterToolFnBindSizeTSecond<CombinatorWithReplacement>;
+  }
+  constexpr impl::CombinationsWithReplacementFn combinations_with_replacement{};
+}
+
+template <typename Container>
+class iter::impl::CombinatorWithReplacement {
+ private:
+  Container container_;
+  std::size_t length_;
+
+  friend CombinationsWithReplacementFn;
+
+  CombinatorWithReplacement(Container&& container, std::size_t n)
+      : container_(std::forward<Container>(container)), length_{n} {}
+
+  template <typename T>
+  using IndexVector = std::vector<iterator_type<T>>;
+  template <typename T>
+  using CombIteratorDeref = IterIterWrapper<IndexVector<T>>;
+
+ public:
+  CombinatorWithReplacement(CombinatorWithReplacement&&) = default;
+  template <typename ContainerT>
+  class Iterator {
+   private:
+    template <typename>
+    friend class Iterator;
+    constexpr static const int COMPLETE = -1;
+    std::remove_reference_t<ContainerT>* container_p_;
+    CombIteratorDeref<ContainerT> indices_;
+    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)),
+          steps_{(get_begin(in_container) != get_end(in_container) && n)
+                     ? 0
+                     : COMPLETE} {}
+
+    CombIteratorDeref<ContainerT>& operator*() {
+      return indices_;
+    }
+
+    CombIteratorDeref<ContainerT>* operator->() {
+      return &indices_;
+    }
+
+    Iterator& operator++() {
+      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) {
+              (*down) = dumb_next(*(iter + 1));
+              if (down == indices_.get().rbegin())
+                break;
+            }
+          } else {
+            steps_ = COMPLETE;
+            break;
+          }
+        } else {
+          // we break because none of the rest of the items
+          // need to be incremented
+          break;
+        }
+      }
+      if (steps_ != COMPLETE) {
+        ++steps_;
+      }
+      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 steps_ == other.steps_;
+    }
+  };
+
+  Iterator<Container> begin() {
+    return {container_, length_};
+  }
+
+  Iterator<Container> end() {
+    return {container_, 0};
+  }
+
+  Iterator<AsConst<Container>> begin() const {
+    return {std::as_const(container_), length_};
+  }
+
+  Iterator<AsConst<Container>> end() const {
+    return {std::as_const(container_), 0};
+  }
+};
+
+#endif
+#ifndef ITER_COMPRESS_H_
+#define ITER_COMPRESS_H_
+
+
+
+namespace iter {
+  namespace impl {
+    template <typename Container, typename Selector>
+    class Compressed;
+  }
+
+  template <typename Container, typename Selector>
+  impl::Compressed<Container, Selector> compress(Container&&, Selector&&);
+}
+
+template <typename Container, typename Selector>
+class iter::impl::Compressed {
+ private:
+  Container container_;
+  Selector selectors_;
+
+  friend Compressed iter::compress<Container, Selector>(
+      Container&&, Selector&&);
+
+  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 {
+   private:
+    template <typename, typename>
+    friend class Iterator;
+    IteratorWrapper<ContainerT> sub_iter_;
+    IteratorWrapper<ContainerT> sub_end_;
+
+    IteratorWrapper<SelectorT> selector_iter_;
+    IteratorWrapper<SelectorT> selector_end_;
+
+    void increment_iterators() {
+      ++sub_iter_;
+      ++selector_iter_;
+    }
+
+    void skip_failures() {
+      while (sub_iter_ != sub_end_ && selector_iter_ != selector_end_
+             && !*selector_iter_) {
+        increment_iterators();
+      }
+    }
+
+   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,
+        IteratorWrapper<SelectorT>&& 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)} {
+      skip_failures();
+    }
+
+    iterator_deref<ContainerT> operator*() {
+      return *sub_iter_;
+    }
+
+    iterator_arrow<ContainerT> operator->() {
+      return apply_arrow(sub_iter_);
+    }
+
+    Iterator& operator++() {
+      increment_iterators();
+      skip_failures();
+      return *this;
+    }
+
+    Iterator operator++(int) {
+      auto ret = *this;
+      ++*this;
+      return ret;
+    }
+
+    template <typename T, typename U>
+    bool operator!=(const Iterator<T, U>& other) const {
+      return sub_iter_ != other.sub_iter_
+             && selector_iter_ != other.selector_iter_;
+    }
+
+    template <typename T, typename U>
+    bool operator==(const Iterator<T, U>& other) const {
+      return !(*this != other);
+    }
+  };
+
+  Iterator<Container, Selector> begin() {
+    return {get_begin(container_), get_end(container_), get_begin(selectors_),
+        get_end(selectors_)};
+  }
+
+  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(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(std::as_const(container_)),
+        get_end(std::as_const(container_)),
+        get_end(std::as_const(selectors_)),
+        get_end(std::as_const(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_)};
+}
+
+#endif
+#ifndef ITER_COUNT_H_
+#define ITER_COUNT_H_
+
+
+#include <limits>
+
+namespace iter {
+  template <typename T>
+  constexpr auto count(T start, T step) noexcept {
+    T stop = step < T(0) ? std::numeric_limits<T>::lowest()
+                         : std::numeric_limits<T>::max();
+    return range(start, stop, step);
+  }
+
+  template <typename T = long>
+  constexpr auto count(T start = T(0)) noexcept {
+    return count(start, T(1));
+  }
+}
+
+#endif
+#ifndef ITER_CYCLE_H_
+#define ITER_CYCLE_H_
+
+
+
+namespace iter {
+  namespace impl {
+    template <typename Container>
+    class Cycler;
+
+    using CycleFn = IterToolFn<Cycler>;
+  }
+  constexpr impl::CycleFn cycle{};
+}
+
+template <typename Container>
+class iter::impl::Cycler {
+ private:
+  friend CycleFn;
+
+  Container container_;
+
+  Cycler(Container&& container)
+      : container_(std::forward<Container>(container)) {}
+
+ public:
+  Cycler(Cycler&&) = default;
+  template <typename ContainerT>
+  class Iterator {
+   private:
+    template <typename>
+    friend class Iterator;
+    IteratorWrapper<ContainerT> sub_iter_;
+    IteratorWrapper<ContainerT> sub_begin_;
+    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},
+          sub_begin_{sub_iter},
+          sub_end_{std::move(sub_end)} {}
+
+    iterator_deref<ContainerT> operator*() {
+      return *sub_iter_;
+    }
+
+    iterator_arrow<ContainerT> operator->() {
+      return apply_arrow(sub_iter_);
+    }
+
+    Iterator& operator++() {
+      ++sub_iter_;
+      // reset to beginning upon reaching the sub_end_
+      if (!(sub_iter_ != sub_end_)) {
+        sub_iter_ = sub_begin_;
+      }
+      return *this;
+    }
+
+    Iterator operator++(int) {
+      auto ret = *this;
+      ++*this;
+      return ret;
+    }
+
+    template <typename T>
+    bool operator!=(const Iterator<T>& other) const {
+      return sub_iter_ != other.sub_iter_;
+    }
+
+    template <typename T>
+    bool operator==(const Iterator<T>& other) const {
+      return !(*this != other);
+    }
+  };
+
+  Iterator<Container> begin() {
+    return {get_begin(container_), get_end(container_)};
+  }
+
+  Iterator<Container> end() {
+    return {get_end(container_), get_end(container_)};
+  }
+
+  Iterator<AsConst<Container>> begin() const {
+    return {get_begin(std::as_const(container_)),
+        get_end(std::as_const(container_))};
+  }
+
+  Iterator<AsConst<Container>> end() const {
+    return {get_end(std::as_const(container_)),
+        get_end(std::as_const(container_))};
+  }
+};
+
+#endif
+#ifndef ITER_DROPWHILE_H_
+#define ITER_DROPWHILE_H_
+
+
+
+namespace iter {
+  namespace impl {
+    template <typename FilterFunc, typename Container>
+    class Dropper;
+
+    using DropWhileFn = IterToolFnOptionalBindFirst<Dropper, BoolTester>;
+  }
+  constexpr impl::DropWhileFn dropwhile{};
+}
+
+template <typename FilterFunc, typename Container>
+class iter::impl::Dropper {
+ private:
+  Container container_;
+  mutable FilterFunc filter_func_;
+
+  friend DropWhileFn;
+
+  Dropper(FilterFunc filter_func, Container&& container)
+      : container_(std::forward<Container>(container)),
+        filter_func_(filter_func) {}
+
+ public:
+  Dropper(Dropper&&) = default;
+  template <typename ContainerT>
+  class Iterator {
+   private:
+    template <typename>
+    friend class Iterator;
+    using Holder = DerefHolder<iterator_deref<ContainerT>>;
+    mutable IteratorWrapper<ContainerT> sub_iter_;
+    IteratorWrapper<ContainerT> sub_end_;
+    mutable Holder item_;
+    FilterFunc* filter_func_;
+
+    // see comments from filter about mutability
+    void inc_sub_iter() const {
+      ++sub_iter_;
+      if (sub_iter_ != sub_end_) {
+        item_.reset(*sub_iter_);
+      }
+    }
+
+    // skip all values for which the predicate is true
+    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>;
+    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)},
+          sub_end_{std::move(sub_end)},
+          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;
+    }
+
+    Iterator operator++(int) {
+      auto ret = *this;
+      ++*this;
+      return ret;
+    }
+
+    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_;
+    }
+
+    template <typename T>
+    bool operator==(const Iterator<T>& other) const {
+      return !(*this != other);
+    }
+  };
+
+  Iterator<Container> begin() {
+    return {get_begin(container_), get_end(container_), filter_func_};
+  }
+
+  Iterator<Container> end() {
+    return {get_end(container_), get_end(container_), filter_func_};
+  }
+
+  Iterator<AsConst<Container>> begin() const {
+    return {get_begin(std::as_const(container_)),
+        get_end(std::as_const(container_)), filter_func_};
+  }
+
+  Iterator<AsConst<Container>> end() const {
+    return {get_end(std::as_const(container_)),
+        get_end(std::as_const(container_)), filter_func_};
+  }
+};
+
+#endif
+#ifndef ITER_ENUMERATE_H_
+#define ITER_ENUMERATE_H_
+
+
+
+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;
+
+     public:
+      typename BasePair::first_type index = BasePair::first;
+      typename BasePair::second_type element = BasePair::second;
+    };
+
+    template <typename Container, typename Index>
+    class Enumerable;
+
+    using EnumerateFn = IterToolFnOptionalBindSecond<Enumerable, std::size_t>;
+  }
+  constexpr impl::EnumerateFn enumerate{};
+}
+
+namespace std {
+  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>
+class iter::impl::Enumerable {
+ private:
+  Container container_;
+  const Index start_;
+
+  friend EnumerateFn;
+
+  // Value constructor for use only in the enumerate function
+  Enumerable(Container&& container, Index start)
+      : container_(std::forward<Container>(container)), start_{start} {}
+
+ public:
+  Enumerable(Enumerable&&) = default;
+
+  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.
+  template <typename ContainerT>
+  class Iterator {
+   private:
+    template <typename>
+    friend class Iterator;
+    IteratorWrapper<ContainerT> sub_iter_;
+    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} {}
+
+    IterYield<ContainerT> operator*() {
+      return {index_, *sub_iter_};
+    }
+
+    ArrowProxy<IterYield<ContainerT>> operator->() {
+      return {**this};
+    }
+
+    Iterator& operator++() {
+      ++sub_iter_;
+      ++index_;
+      return *this;
+    }
+
+    Iterator operator++(int) {
+      auto ret = *this;
+      ++*this;
+      return ret;
+    }
+
+    template <typename T>
+    bool operator!=(const Iterator<T>& other) const {
+      return sub_iter_ != other.sub_iter_;
+    }
+
+    template <typename T>
+    bool operator==(const Iterator<T>& other) const {
+      return !(*this != other);
+    }
+  };
+
+  Iterator<Container> begin() {
+    return {get_begin(container_), start_};
+  }
+
+  Iterator<Container> end() {
+    return {get_end(container_), start_};
+  }
+
+  Iterator<AsConst<Container>> begin() const {
+    return {get_begin(std::as_const(container_)), start_};
+  }
+
+  Iterator<AsConst<Container>> end() const {
+    return {get_end(std::as_const(container_)), start_};
+  }
+};
+#endif
+#ifndef ITER_FILTER_FALSE_HPP_
+#define ITER_FILTER_FALSE_HPP_
+
+
+
+namespace iter {
+  namespace impl {
+    // Callable object that reverses the boolean result of another
+    // callable, taking the object in a Container's iterator
+    template <typename FilterFunc>
+    class PredicateFlipper {
+     private:
+      FilterFunc filter_func_;
+
+     public:
+      PredicateFlipper(FilterFunc filter_func)
+          : filter_func_(std::move(filter_func)) {}
+
+      // Calls the filter_func_
+      template <typename T>
+      bool operator()(const T& item) const {
+        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(std::invoke(filter_func_, item));
+      }
+    };
+
+    template <typename FilterFunc, typename Container>
+    class FilterFalsed;
+
+    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
+#ifndef ITER_GROUP_BY_HPP_
+#define ITER_GROUP_BY_HPP_
+
+// this is easily the most functionally complex itertool
+
+
+
+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>;
+  }
+  constexpr impl::GroupByFn groupby{};
+}
+
+template <typename Container, typename KeyFunc>
+class iter::impl::GroupProducer {
+ private:
+  Container container_;
+  mutable KeyFunc key_func_;
+
+  friend GroupByFn;
+
+  template <typename 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) {}
+
+ public:
+  GroupProducer(GroupProducer&&) = default;
+
+  template <typename T>
+  class Iterator;
+  template <typename T>
+  class Group;
+
+ private:
+  template <typename T>
+  using KeyGroupPair = std::pair<key_func_ret<T>, Group<T>>;
+  template <typename T>
+  using Holder = DerefHolder<iterator_deref<T>>;
+
+ public:
+  template <typename ContainerT>
+  class Iterator {
+   private:
+    template <typename>
+    friend class Iterator;
+    IteratorWrapper<ContainerT> sub_iter_;
+    IteratorWrapper<ContainerT> sub_end_;
+    Holder<ContainerT> item_;
+    KeyFunc* key_func_;
+    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)},
+          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_} {}
+
+    Iterator& operator=(const Iterator& other) {
+      if (this == &other) {
+        return *this;
+      }
+      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;
+    }
+
+    ~Iterator() = default;
+
+    // NOTE the implicitly generated move constructor would
+    // be wrong
+
+    KeyGroupPair<ContainerT>& operator*() {
+      set_key_group_pair();
+      return *current_key_group_pair_;
+    }
+
+    KeyGroupPair<ContainerT>* operator->() {
+      set_key_group_pair();
+      return &*current_key_group_pair_;
+    }
+
+    Iterator& operator++() {
+      if (!current_key_group_pair_) {
+        set_key_group_pair();
+      }
+      current_key_group_pair_.reset();
+      return *this;
+    }
+
+    Iterator operator++(int) {
+      auto ret = *this;
+      ++*this;
+      return ret;
+    }
+
+    template <typename T>
+    bool operator!=(const Iterator<T>& other) const {
+      return sub_iter_ != other.sub_iter_;
+    }
+
+    template <typename T>
+    bool operator==(const Iterator<T>& other) const {
+      return !(*this != other);
+    }
+
+    void increment_iterator() {
+      if (sub_iter_ != sub_end_) {
+        ++sub_iter_;
+        if (sub_iter_ != sub_end_) {
+          item_.reset(*sub_iter_);
+        }
+      }
+    }
+
+    bool exhausted() const {
+      return !(sub_iter_ != sub_end_);
+    }
+
+    typename Holder<ContainerT>::reference get() {
+      return item_.get();
+    }
+
+    typename Holder<ContainerT>::pointer get_ptr() {
+      return item_.get_ptr();
+    }
+
+    key_func_ret<ContainerT> next_key() {
+      return std::invoke(*key_func_, item_.get());
+    }
+
+    void set_key_group_pair() {
+      if (!current_key_group_pair_) {
+        current_key_group_pair_.emplace(std::invoke(*key_func_, item_.get()),
+            Group<ContainerT>{*this, next_key()});
+      }
+    }
+  };
+
+  template <typename ContainerT>
+  class Group {
+   private:
+    template <typename>
+    friend class Iterator;
+    friend class GroupIterator;
+    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
+    // 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<ContainerT>& owner, key_func_ret<ContainerT> key)
+        : owner_(owner), key_(key) {}
+
+   public:
+    ~Group() {
+      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} {
+      other.completed = true;
+    }
+
+    class GroupIterator {
+     private:
+      std::remove_reference_t<key_func_ret<ContainerT>>* key_;
+      Group* group_p_;
+
+      bool not_at_end() {
+        return !group_p_->owner_.exhausted()
+               && group_p_->owner_.next_key() == *key_;
+      }
+
+     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} {}
+
+      bool operator!=(const GroupIterator& other) const {
+        return !(*this == other);
+      }
+
+      bool operator==(const GroupIterator& other) const {
+        return group_p_ == other.group_p_;
+      }
+
+      GroupIterator& operator++() {
+        group_p_->owner_.increment_iterator();
+        if (!not_at_end()) {
+          group_p_->completed = true;
+          group_p_ = nullptr;
+        }
+        return *this;
+      }
+
+      GroupIterator operator++(int) {
+        auto ret = *this;
+        ++*this;
+        return ret;
+      }
+
+      iterator_deref<ContainerT> operator*() {
+        return group_p_->owner_.get();
+      }
+
+      typename Holder<ContainerT>::pointer operator->() {
+        return group_p_->owner_.get_ptr();
+      }
+    };
+
+    GroupIterator begin() {
+      return {this, key_};
+    }
+
+    GroupIterator end() {
+      return {nullptr, key_};
+    }
+  };
+
+  Iterator<Container> begin() {
+    return {get_begin(container_), get_end(container_), key_func_};
+  }
+
+  Iterator<Container> end() {
+    return {get_end(container_), get_end(container_), key_func_};
+  }
+
+  Iterator<AsConst<Container>> begin() const {
+    return {get_begin(std::as_const(container_)),
+        get_end(std::as_const(container_)), key_func_};
+  }
+
+  Iterator<AsConst<Container>> end() const {
+    return {get_end(std::as_const(container_)),
+        get_end(std::as_const(container_)), key_func_};
+  }
+};
+
+#endif
+#ifndef ITER_IMAP_H_
+#define ITER_IMAP_H_
+
+
+
+namespace iter {
+  namespace impl {
+    struct IMapFn : PipeableAndBindFirst<IMapFn> {
+      template <typename MapFunc, typename... Containers>
+      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();
+    };
+  }
+  constexpr impl::IMapFn imap{};
+}
+
+#endif
+#ifndef ITERTOOLS_ALL_HPP_
+#define ITERTOOLS_ALL_HPP_
+
+
+// zip_longest is the only itertool with a boost depedency, so it must be
+// included explicitly
+
+#endif
+#ifndef ITER_PERMUTATIONS_HPP_
+#define ITER_PERMUTATIONS_HPP_
+
+
+
+namespace iter {
+  namespace impl {
+    template <typename Container>
+    class Permuter;
+    using PermutationsFn = IterToolFn<Permuter>;
+  }
+  constexpr impl::PermutationsFn permutations{};
+}
+
+template <typename Container>
+class iter::impl::Permuter {
+ private:
+  friend PermutationsFn;
+  Container container_;
+
+  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)) {}
+
+ public:
+  Permuter(Permuter&&) = default;
+
+  template <typename ContainerT>
+  class Iterator {
+   private:
+    template <typename>
+    friend class Iterator;
+    static constexpr const int COMPLETE = -1;
+    static bool cmp_iters(IteratorWrapper<ContainerT> lhs,
+        IteratorWrapper<ContainerT> rhs) noexcept {
+      return *lhs < *rhs;
+    }
+
+    Permutable<ContainerT> working_set_;
+    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} {
+      // 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) {
+        working_set_.get().push_back(sub_iter);
+        ++sub_iter;
+      }
+      std::sort(get_begin(working_set_.get()), get_end(working_set_.get()),
+          cmp_iters);
+    }
+
+    Permutable<ContainerT>& operator*() {
+      return working_set_;
+    }
+
+    Permutable<ContainerT>* operator->() {
+      return &working_set_;
+    }
+
+    Iterator& operator++() {
+      ++steps_;
+      if (!std::next_permutation(get_begin(working_set_.get()),
+              get_end(working_set_.get()), cmp_iters)) {
+        steps_ = COMPLETE;
+      }
+      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 steps_ == other.steps_;
+    }
+  };
+
+  Iterator<Container> begin() {
+    return {get_begin(container_), get_end(container_)};
+  }
+
+  Iterator<Container> end() {
+    return {get_end(container_), get_end(container_)};
+  }
+
+  Iterator<AsConst<Container>> begin() const {
+    return {get_begin(std::as_const(container_)),
+        get_end(std::as_const(container_))};
+  }
+
+  Iterator<AsConst<Container>> end() const {
+    return {get_end(std::as_const(container_)),
+        get_end(std::as_const(container_))};
+  }
+};
+
+#endif
+#ifndef ITER_POWERSET_HPP_
+#define ITER_POWERSET_HPP_
+
+
+
+namespace iter {
+  namespace impl {
+    template <typename Container>
+    class Powersetter;
+
+    using PowersetFn = IterToolFn<Powersetter>;
+  }
+  constexpr impl::PowersetFn powerset{};
+}
+
+template <typename Container>
+class iter::impl::Powersetter {
+ private:
+  Container container_;
+  template <typename T>
+  using CombinatorType = decltype(combinations(std::declval<T&>(), 0));
+
+  friend PowersetFn;
+
+  Powersetter(Container&& container)
+      : container_(std::forward<Container>(container)) {}
+
+ public:
+  Powersetter(Powersetter&&) = default;
+
+  template <typename ContainerT>
+  class Iterator {
+   private:
+#if 0
+    template <typename> friend class Iterator;
+#endif
+    std::remove_reference_t<ContainerT>* container_p_;
+    std::size_t set_size_{};
+    std::shared_ptr<CombinatorType<ContainerT>> comb_;
+    iterator_type<CombinatorType<ContainerT>> comb_iter_;
+    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},
+          comb_{std::make_shared<CombinatorType<ContainerT>>(
+              combinations(container, sz))},
+          comb_iter_{get_begin(*comb_)},
+          comb_end_{get_end(*comb_)} {}
+
+    Iterator& operator++() {
+      ++comb_iter_;
+      if (comb_iter_ == comb_end_) {
+        ++set_size_;
+        comb_ = std::make_shared<CombinatorType<ContainerT>>(
+            combinations(*container_p_, set_size_));
+
+        comb_iter_ = get_begin(*comb_);
+        comb_end_ = get_end(*comb_);
+      }
+      return *this;
+    }
+
+    Iterator operator++(int) {
+      auto ret = *this;
+      ++*this;
+      return ret;
+    }
+
+    iterator_deref<CombinatorType<ContainerT>> operator*() {
+      return *comb_iter_;
+    }
+
+    iterator_arrow<CombinatorType<ContainerT>> operator->() {
+      apply_arrow(comb_iter_);
+    }
+
+    bool operator!=(const Iterator& other) const {
+      return !(*this == other);
+    }
+
+    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<Container> begin() {
+    return {container_, 0};
+  }
+
+  Iterator<Container> end() {
+    return {container_, dumb_size(container_) + 1};
+  }
+
+  Iterator<AsConst<Container>> begin() const {
+    return {std::as_const(container_), 0};
+  }
+
+  Iterator<AsConst<Container>> end() const {
+    return {
+        std::as_const(container_), dumb_size(std::as_const(container_)) + 1};
+  }
+};
+
+#endif
+#ifndef ITER_PRODUCT_HPP_
+#define ITER_PRODUCT_HPP_
+
+
+
+namespace iter {
+  namespace impl {
+    template <typename TupleType, std::size_t... Is>
+    class Productor;
+
+    template <typename TupleType, std::size_t... Is>
+    Productor<TupleType, Is...> product_impl(
+        TupleType&& containers, std::index_sequence<Is...>);
+  }
+}
+
+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:
+  TupleType containers_;
+
+  Productor(TupleType&& containers) : containers_(std::move(containers)) {}
+
+ public:
+  Productor(Productor&&) = default;
+
+ private:
+  template <typename IterTupType>
+  class IteratorData {
+    IteratorData() = delete;
+    static_assert(
+        std::tuple_size<std::decay_t<IterTupType>>::value == sizeof...(Is),
+        "tuple size != sizeof Is");
+
+   public:
+    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 {
+#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_;
+    IterTupType end_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&;
+
+    IteratorTempl(IteratorTuple<TupleTypeT>&& iters,
+        IteratorTuple<TupleTypeT>&& end_iters)
+        : iters_(std::move(iters)),
+          begin_iters_(iters_),
+          end_iters_(std::move(end_iters)) {}
+
+    IteratorTempl& operator++() {
+      static constexpr int NUM_ELEMENTS = sizeof...(Is);
+      bool performed_increment = false;
+      for (int i = NUM_ELEMENTS - 1; i >= 0; --i) {
+        if (IteratorData<IterTupType>::incrementers[i](
+                iters_, begin_iters_, end_iters_)) {
+          performed_increment = true;
+          break;
+        }
+      }
+      if (!performed_increment) {
+        iters_ = end_iters_;
+      }
+      return *this;
+    }
+
+    IteratorTempl operator++(int) {
+      auto ret = *this;
+      ++*this;
+      return ret;
+    }
+
+    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;
+      } else {
+        return (... && (std::get<Is>(iters_) != std::get<Is>(other.iters_)));
+      }
+    }
+
+    template <typename T, template <typename> class IT,
+        template <typename> class TD>
+    bool operator==(const IteratorTempl<T, IT, TD>& other) const {
+      return !(*this != other);
+    }
+
+    TupleDeref<TupleTypeT> operator*() {
+      return {(*std::get<Is>(iters_))...};
+    }
+
+    auto operator-> () -> ArrowProxy<decltype(**this)> {
+      return {**this};
+    }
+  };
+
+  using Iterator =
+      IteratorTempl<TupleType, iterator_tuple_type, iterator_deref_tuple>;
+  using ConstIterator = IteratorTempl<AsConst<TupleType>,
+      const_iterator_tuple_type, const_iterator_deref_tuple>;
+
+ public:
+  Iterator begin() {
+    return {{get_begin(std::get<Is>(containers_))...},
+        {get_end(std::get<Is>(containers_))...}};
+  }
+
+  Iterator end() {
+    return {{get_end(std::get<Is>(containers_))...},
+        {get_end(std::get<Is>(containers_))...}};
+  }
+
+  ConstIterator begin() const {
+    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(std::get<Is>(containers_)))...},
+        {get_end(std::as_const(std::get<Is>(containers_)))...}};
+  }
+};
+
+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)};
+  }
+}
+
+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...>{});
+  }
+
+  constexpr std::array<std::tuple<>, 1> product() {
+    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))...);
+  }
+
+  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)...);
+  }
+}
+
+namespace iter {
+  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));
+  }
+}
+
+#endif
+#ifndef ITER_RANGE_H_
+#define ITER_RANGE_H_
+
+
+#include <exception>
+
+namespace iter {
+  namespace impl {
+    template <typename T>
+    class Range;
+  }
+
+  template <typename T>
+  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;
+}
+
+namespace iter {
+  namespace detail {
+    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 value_;
+      }
+
+      constexpr T step() const noexcept {
+        return step_;
+      }
+
+      void inc() noexcept {
+        value_ += step_;
+      }
+
+      constexpr bool operator==(const RangeIterData& other) const noexcept {
+        return value_ == other.value_;
+      }
+
+      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_{};
+      std::size_t 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 value_;
+      }
+
+      constexpr T step() const noexcept {
+        return step_;
+      }
+
+      void inc() noexcept {
+        ++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 (value_ < other.value_ ? other.value_ - value_
+                                      : value_ - other.value_)
+               < step_;
+      }
+
+      constexpr bool operator!=(const RangeIterData& other) const noexcept {
+        return !(*this == other);
+      }
+    };
+  }
+}
+
+template <typename T>
+class iter::impl::Range {
+  // 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_;
+  const T stop_;
+  const T step_;
+
+  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} {}
+
+  // 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_;
+  }
+
+  constexpr T stop() const noexcept {
+    return stop_;
+  }
+
+  constexpr T step() const noexcept {
+    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");
+    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
+
+  class Iterator {
+   private:
+    iter::detail::RangeIterData<T> data;
+    bool is_end{};
+
+    // 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);
+      return is_within_range(
+          lhs.data.value(), rhs.data.value(), lhs.data.step());
+    }
+
+    static bool not_equal_to_end(
+        const Iterator& lhs, const Iterator& rhs) noexcept {
+      if (rhs.is_end) {
+        return not_equal_to_impl(lhs, rhs);
+      }
+      return not_equal_to_impl(rhs, lhs);
+    }
+
+   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
+        : data(in_value, in_step), is_end{in_is_end} {}
+
+    constexpr T operator*() const noexcept {
+      return data.value();
+    }
+
+    constexpr ArrowProxy<T> operator->() const noexcept {
+      return {**this};
+    }
+
+    Iterator& operator++() noexcept {
+      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 (is_end && other.is_end) {
+        return false;
+      }
+
+      if (!is_end && !other.is_end) {
+        return 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};
+  }
+};
+
+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_REPEAT_HPP_
+#define ITER_REPEAT_HPP_
+
+
+namespace iter {
+  namespace impl {
+    template <typename T>
+    class RepeaterWithCount;
+  }
+
+  template <typename T>
+  constexpr impl::RepeaterWithCount<T> repeat(T&&, int);
+}
+
+template <typename T>
+class iter::impl::RepeaterWithCount {
+  // 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_;
+  int count_;
+
+  constexpr RepeaterWithCount(T e, int c)
+      : elem_(std::forward<T>(e)), count_{c} {}
+
+  using TPlain = typename std::remove_reference<T>::type;
+
+ public:
+  RepeaterWithCount(RepeaterWithCount&&) = default;
+
+  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++() {
+      --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() const {
+    return {&this->elem_, this->count_};
+  }
+
+  constexpr Iterator end() const {
+    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_};
+}
+
+namespace iter {
+  namespace impl {
+    template <typename T>
+    class Repeater;
+  }
+
+  template <typename T>
+  constexpr impl::Repeater<T> repeat(T&&);
+}
+
+template <typename T>
+class iter::impl::Repeater {
+  template <typename U>
+  friend constexpr Repeater<U> iter::repeat(U&&);
+
+ private:
+  using TPlain = typename std::remove_reference<T>::type;
+  T elem_;
+
+  constexpr Repeater(T e) : elem_(std::forward<T>(e)) {}
+
+ public:
+  Repeater(Repeater&&) = default;
+
+  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 {
+      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() const {
+    return {&this->elem_};
+  }
+
+  constexpr Iterator end() const {
+    return {nullptr};
+  }
+};
+
+template <typename T>
+constexpr iter::impl::Repeater<T> iter::repeat(T&& e) {
+  return {std::forward<T>(e)};
+}
+
+#endif
+#ifndef ITER_REVERSE_HPP_
+#define ITER_REVERSE_HPP_
+
+
+
+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_v<impl::reverse_iterator_type<Container>,
+                                                    impl::
+                                                        reverse_iterator_end_type<Container>>>::
+            type;
+
+    template <typename Container>
+    class Reverser;
+
+    using ReversedFn = IterToolFn<Reverser>;
+  }
+  constexpr impl::ReversedFn reversed{};
+}
+
+template <typename Container>
+class iter::impl::Reverser {
+ private:
+  Container container_;
+  friend ReversedFn;
+
+  Reverser(Container&& container)
+      : container_(std::forward<Container>(container)) {}
+
+  template <typename T>
+  using reverse_iterator_deref =
+      decltype(*std::declval<reverse_iterator_type<T>&>());
+
+  template <typename T>
+  using reverse_iterator_traits_deref =
+      std::remove_reference_t<reverse_iterator_deref<T>>;
+
+  template <typename T>
+  using reverse_iterator_arrow = detail::arrow<reverse_iterator_type<T>>;
+
+ public:
+  Reverser(Reverser&&) = default;
+  template <typename 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)} {}
+
+    reverse_iterator_deref<ContainerT> operator*() {
+      return *sub_iter_;
+    }
+
+    reverse_iterator_arrow<ContainerT> operator->() {
+      return apply_arrow(sub_iter_);
+    }
+
+    Iterator& operator++() {
+      ++sub_iter_;
+      return *this;
+    }
+
+    Iterator operator++(int) {
+      auto ret = *this;
+      ++*this;
+      return ret;
+    }
+
+    template <typename T>
+    bool operator!=(const Iterator<T>& other) const {
+      return sub_iter_ != other.sub_iter_;
+    }
+
+    template <typename T>
+    bool operator==(const Iterator<T>& other) const {
+      return !(*this != other);
+    }
+  };
+
+  Iterator<Container> begin() {
+    return {std::rbegin(container_)};
+  }
+
+  Iterator<Container> end() {
+    return {std::rend(container_)};
+  }
+
+  Iterator<AsConst<Container>> begin() const {
+    return {std::rbegin(std::as_const(container_))};
+  }
+
+  Iterator<AsConst<Container>> end() const {
+    return {std::rend(std::as_const(container_))};
+  }
+};
+
+#endif
+#ifndef ITER_SLICE_HPP_
+#define ITER_SLICE_HPP_
+
+
+
+namespace iter {
+  namespace impl {
+    template <typename Container, typename DifferenceType>
+    class Sliced;
+
+    struct SliceFn;
+  }
+}
+
+template <typename Container, typename DifferenceType>
+class iter::impl::Sliced {
+ private:
+  Container container_;
+  DifferenceType start_;
+  DifferenceType stop_;
+  DifferenceType step_;
+
+  friend SliceFn;
+
+  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;
+  template <typename ContainerT>
+  class Iterator {
+   private:
+    template <typename>
+    friend class Iterator;
+    IteratorWrapper<ContainerT> sub_iter_;
+    IteratorWrapper<ContainerT> sub_end_;
+    DifferenceType current_;
+    DifferenceType stop_;
+    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)
+        : sub_iter_{std::move(sub_iter)},
+          sub_end_{std::move(sub_end)},
+          current_{start},
+          stop_{stop},
+          step_{step} {}
+
+    iterator_deref<ContainerT> operator*() {
+      return *sub_iter_;
+    }
+
+    iterator_arrow<ContainerT> operator->() {
+      return apply_arrow(sub_iter_);
+    }
+
+    Iterator& operator++() {
+      dumb_advance(sub_iter_, sub_end_, step_);
+      current_ += step_;
+      if (stop_ < current_) {
+        current_ = stop_;
+      }
+      return *this;
+    }
+
+    Iterator operator++(int) {
+      auto ret = *this;
+      ++*this;
+      return ret;
+    }
+
+    template <typename T>
+    bool operator!=(const Iterator<T>& other) const {
+      return sub_iter_ != other.sub_iter_ && current_ != other.current_;
+    }
+
+    template <typename T>
+    bool operator==(const Iterator<T>& other) const {
+      return !(*this != other);
+    }
+  };
+
+  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<Container> end() {
+    return {get_end(container_), get_end(container_), stop_, stop_, step_};
+  }
+
+  Iterator<AsConst<Container>> begin() const {
+    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(std::as_const(container_)),
+        get_end(std::as_const(container_)), stop_, 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_};
+    }
+
+   private:
+    friend SliceFn;
+    constexpr FnPartial(DifferenceType start, DifferenceType stop,
+        DifferenceType step) noexcept : start_{start},
+                                        stop_{stop},
+                                        step_{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
+#ifndef ITER_SLIDING_WINDOW_HPP_
+#define ITER_SLIDING_WINDOW_HPP_
+
+
+#include <deque>
+
+namespace iter {
+  namespace impl {
+    template <typename Container>
+    class WindowSlider;
+    using SlidingWindowFn = IterToolFnBindSizeTSecond<WindowSlider>;
+  }
+  constexpr impl::SlidingWindowFn sliding_window{};
+}
+
+template <typename Container>
+class iter::impl::WindowSlider {
+ private:
+  Container container_;
+  std::size_t window_size_;
+
+  friend SlidingWindowFn;
+
+  WindowSlider(Container&& container, std::size_t win_sz)
+      : container_(std::forward<Container>(container)), window_size_{win_sz} {}
+
+  template <typename T>
+  using IndexVector = std::deque<IteratorWrapper<T>>;
+  template <typename T>
+  using DerefVec = IterIterWrapper<IndexVector<T>>;
+
+ public:
+  WindowSlider(WindowSlider&&) = default;
+  template <typename ContainerT>
+  class Iterator {
+   private:
+    template <typename>
+    friend class Iterator;
+    std::shared_ptr<DerefVec<ContainerT>> window_ =
+        std::make_shared<DerefVec<ContainerT>>();
+    IteratorWrapper<ContainerT> sub_iter_;
+
+   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)) {
+      std::size_t i{0};
+      while (i < window_sz && sub_iter_ != sub_end) {
+        window_->get().push_back(sub_iter_);
+        ++i;
+        if (i != window_sz) {
+          ++sub_iter_;
+        }
+      }
+    }
+
+    template <typename T>
+    bool operator!=(const Iterator<T>& other) const {
+      return sub_iter_ != other.sub_iter_;
+    }
+
+    template <typename T>
+    bool operator==(const Iterator<T>& other) const {
+      return !(*this != other);
+    }
+
+    DerefVec<ContainerT>& operator*() {
+      return *window_;
+    }
+
+    DerefVec<ContainerT>* operator->() {
+      return window_.get();
+    }
+
+    Iterator& operator++() {
+      ++sub_iter_;
+      window_->get().pop_front();
+      window_->get().push_back(sub_iter_);
+      return *this;
+    }
+
+    Iterator operator++(int) {
+      auto ret = *this;
+      ++*this;
+      return ret;
+    }
+  };
+
+  Iterator<Container> begin() {
+    return {
+        (window_size_ != 0 ? IteratorWrapper<Container>{get_begin(container_)}
+                           : IteratorWrapper<Container>{get_end(container_)}),
+        get_end(container_), window_size_};
+  }
+
+  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(
+                                     std::as_const(container_))}
+                               : IteratorWrapper<AsConst<Container>>{get_end(
+                                     std::as_const(container_))}),
+        get_end(std::as_const(container_)), window_size_};
+  }
+
+  Iterator<AsConst<Container>> end() const {
+    return {get_end(std::as_const(container_)),
+        get_end(std::as_const(container_)), window_size_};
+  }
+};
+
+#endif
+#ifndef ITER_SORTED_HPP_
+#define ITER_SORTED_HPP_
+
+
+
+namespace iter {
+  namespace impl {
+    template <typename Container, typename CompareFunc>
+    class SortedView;
+    using SortedFn = IterToolFnOptionalBindSecond<SortedView, std::less<>>;
+  }
+  constexpr impl::SortedFn sorted{};
+}
+
+template <typename Container, typename CompareFunc>
+class iter::impl::SortedView {
+ private:
+  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 std::invoke(compare_func, *it1, *it2);
+          });
+    }
+
+    ItIt begin() {
+      return sorted_iters_.begin();
+    }
+
+    ItIt end() {
+      return sorted_iters_.end();
+    }
+  };
+
+  template <typename ContainerT>
+  class SortedItersHolder<ContainerT,
+      std::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<ConstIterIterWrap>;
+
+   private:
+    ContainerT container_;
+    mutable CompareFunc compare_func_;
+    IterIterWrap sorted_iters_;
+    mutable ConstIterIterWrap const_sorted_iters_;
+
+    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_);
+           ++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()),
+          [this](iterator_type<ContainerT> it1, iterator_type<ContainerT> it2) {
+            return std::invoke(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(std::as_const(container_));
+           iter != get_end(std::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()),
+          [this](iterator_type<AsConst<ContainerT>> it1,
+              iterator_type<AsConst<ContainerT>> 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();
+    }
+  };
+
+  friend SortedFn;
+
+  SortedItersHolder<Container> sorted_iters_holder_;
+
+  SortedView(Container&& container, CompareFunc compare_func)
+      : sorted_iters_holder_{
+            std::forward<Container>(container), std::move(compare_func)} {}
+
+ public:
+  SortedView(SortedView&&) = default;
+
+  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();
+  }
+
+  typename SortedItersHolder<Container>::ConstItIt end() const {
+    return sorted_iters_holder_.end();
+  }
+};
+
+#endif
+#ifndef ITER_TAKEWHILE_H_
+#define ITER_TAKEWHILE_H_
+
+
+
+namespace iter {
+  namespace impl {
+    template <typename FilterFunc, typename Container>
+    class Taker;
+
+    using TakeWhileFn = IterToolFnOptionalBindFirst<Taker, BoolTester>;
+  }
+  constexpr impl::TakeWhileFn takewhile{};
+}
+
+template <typename FilterFunc, typename Container>
+class iter::impl::Taker {
+ private:
+  Container container_;
+  mutable FilterFunc filter_func_;
+
+  friend TakeWhileFn;
+
+  Taker(FilterFunc filter_func, Container&& container)
+      : container_(std::forward<Container>(container)),
+        filter_func_(filter_func) {}
+
+ public:
+  Taker(Taker&&) = default;
+
+  template <typename ContainerT>
+  class Iterator {
+   private:
+    template <typename>
+    friend class Iterator;
+    using Holder = DerefHolder<iterator_deref<ContainerT>>;
+    // 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_;
+    mutable Holder item_;
+    FilterFunc* filter_func_;
+
+    // see comments from filter about mutability
+    void inc_sub_iter() {
+      ++sub_iter_;
+      if (sub_iter_ != sub_end_) {
+        item_.reset(*sub_iter_);
+      }
+    }
+
+    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>;
+    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)},
+          sub_end_{std::move(sub_end)},
+          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;
+    }
+
+    Iterator operator++(int) {
+      auto ret = *this;
+      ++*this;
+      return ret;
+    }
+
+    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_;
+    }
+
+    template <typename T>
+    bool operator==(const Iterator<T>& other) const {
+      return !(*this != other);
+    }
+  };
+
+  Iterator<Container> begin() {
+    return {get_begin(container_), get_end(container_), filter_func_};
+  }
+
+  Iterator<Container> end() {
+    return {get_end(container_), get_end(container_), filter_func_};
+  }
+
+  Iterator<AsConst<Container>> begin() const {
+    return {get_begin(std::as_const(container_)),
+        get_end(std::as_const(container_)), filter_func_};
+  }
+
+  Iterator<AsConst<Container>> end() const {
+    return {get_end(std::as_const(container_)),
+        get_end(std::as_const(container_)), filter_func_};
+  }
+};
+
+#endif
+#ifndef ITER_UNIQUE_EVERSEEN_HPP_
+#define ITER_UNIQUE_EVERSEEN_HPP_
+
+
+#include <unordered_set>
+
+namespace iter {
+  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 std::remove_reference_t<elem_type>& e) mutable {
+          return elem_seen.insert(e).second;
+        };
+        return filter(func, std::forward<Container>(container));
+      }
+    };
+  }
+
+  constexpr impl::UniqueEverseenFn unique_everseen{};
+}
+
+#endif
+#ifndef ITER_UNIQUE_JUSTSEEN_HPP
+#define ITER_UNIQUE_JUSTSEEN_HPP
+
+
+
+namespace iter {
+  namespace impl {
+    struct UniqueJustseenFn : Pipeable<UniqueJustseenFn> {
+      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)));
+      }
+    };
+  }
+  constexpr impl::UniqueJustseenFn unique_justseen{};
+}
+
+#endif