Fill out the rest of the random_access_iterator spec.

include/iterator/zip_iterator.hpp

@@ -26,10 +26,83 @@ namespace iterator {
     reference operator*() const {
       return reference(*std::get<Iterators>(iterators_)...);
     }
+
+    zip_iterator & operator++() {
+      [[maybe_unused]] auto l = {(++(std::get<Iterators>(iterators_)), 0)...};
+      return *this;
+    }
+
+    zip_iterator operator++(int) {
+      zip_iterator tmp = *this;
+      operator++();
+      return tmp;
+    }
+
+    zip_iterator & operator--() {
+      [[maybe_unused]] auto l = {(--(std::get<Iterators>(iterators_)), 0)...};
+      return *this;
+    }
+
+    zip_iterator operator--(int) {
+      zip_iterator tmp = *this;
+      operator--();
+      return tmp;
+    }
+
+    zip_iterator & operator+=(difference_type d) {
+      [[maybe_unused]] auto l = {
+          ((std::get<Iterators>(iterators_) += d), 0)...};
+      return *this;
+    }
+
+    zip_iterator operator+(difference_type d) {
+      return zip_iterator{*this} += d;
+    }
+
+    reference operator[](difference_type d) { return *(*this + d); }
+
+    zip_iterator & operator-=(difference_type d) {
+      [[maybe_unused]] auto l = {
+          ((std::get<Iterators>(iterators_) -= d), 0)...};
+      return *this;
+    }
+
+    zip_iterator operator-(difference_type d) {
+      return zip_iterator{*this} -= d;
+    }
+
+    difference_type operator-(zip_iterator const & other) {
+      return std::get<0>(iterators_) - std::get<0>(other.iterators_);
+    }
+
+    bool operator==(zip_iterator const & rhs) const {
+      return iterators_ == rhs.iterators_;
+    }
+    bool operator!=(zip_iterator const & rhs) const {
+      return iterators_ != rhs.iterators_;
+    }
+    bool operator<(zip_iterator const & rhs) const {
+      return iterators_ < rhs.iterators_;
+    }
+    bool operator<=(zip_iterator const & rhs) const {
+      return iterators_ <= rhs.iterators_;
+    }
+    bool operator>(zip_iterator const & rhs) const {
+      return iterators_ > rhs.iterators_;
+    }
+    bool operator>=(zip_iterator const & rhs) const {
+      return iterators_ <= rhs.iterators_;
+    }
   };
+
+  template <typename... Is>
+  zip_iterator<Is...> operator+(typename zip_iterator<Is...>::difference_type d,
+                                zip_iterator<Is...> iter) {
+    return iter += d;
+  }
 }
 
-template <typename... Iterators>
-iterator::zip_iterator<Iterators...> make_zip_iterator(Iterators &&... iters) {
-  return {std::forward<Iterators>(iters)...};
+template <typename... Is>
+iterator::zip_iterator<Is...> make_zip_iterator(Is &&... iters) {
+  return {std::forward<Is>(iters)...};
 }