Index: include/llvm/ADT/STLExtras.h
===================================================================
--- include/llvm/ADT/STLExtras.h
+++ include/llvm/ADT/STLExtras.h
@@ -235,6 +235,95 @@
                     llvm::make_reverse_iterator(std::begin(C)));
 }
 
+namespace detail {
+template <unsigned N, unsigned... Ns> struct NatList {
+  using eval = typename NatList<N - 1, N - 1, Ns...>::eval;
+};
+
+template <unsigned... Ns> struct NatList<0, Ns...> {
+  using eval = NatList<Ns...>;
+};
+
+template <typename... Iters> class ZipFirst {
+public:
+  typedef typename NatList<sizeof...(Iters)>::eval nat_list;
+  typedef std::input_iterator_tag iterator_category;
+  typedef std::tuple<decltype(*std::declval<Iters>())...> value_type;
+  std::tuple<Iters...> iterators;
+
+private:
+  template <unsigned... Ns> value_type deres(NatList<Ns...>) {
+    return value_type(*std::get<Ns>(iterators)...);
+  }
+
+  template <unsigned... Ns> decltype(iterators) tup_inc(NatList<Ns...>) {
+    return std::tuple<Iters...>(std::next(std::get<Ns>(iterators))...);
+  }
+
+public:
+  value_type operator*() { return deres(nat_list{}); }
+
+  void operator++() { iterators = tup_inc(nat_list{}); }
+
+  bool operator!=(const ZipFirst<Iters...> &other) const {
+    return std::get<0>(iterators) != std::get<0>(other.iterators);
+  }
+  ZipFirst(Iters &&... ts) : iterators(std::forward<Iters>(ts)...) {}
+};
+
+template <typename... Iters> class ZipShortest : public ZipFirst<Iters...> {
+  template <unsigned... Ns>
+  bool test(const ZipFirst<Iters...> &other, NatList<Ns...>) const {
+    std::array<bool, sizeof...(Iters)> conds = {
+        (std::get<Ns>(this->iterators) != std::get<Ns>(other.iterators))...};
+    return std::all_of(conds.begin(), conds.end(), [](bool a) { return a; });
+  }
+
+public:
+  bool operator!=(const ZipFirst<Iters...> &other) const {
+    return test(other, typename ZipFirst<Iters...>::nat_list{});
+  }
+  ZipShortest(Iters &&... ts)
+      : ZipFirst<Iters...>(std::forward<Iters>(ts)...) {}
+};
+
+template <template <typename...> class ItType, typename... Args> class Zippy {
+public:
+  typedef ItType<decltype(std::begin(std::declval<Args>()))...> iterator;
+
+private:
+  typedef typename NatList<sizeof...(Args)>::eval nat_list;
+  std::tuple<Args...> ts;
+
+  template <unsigned... Ns> iterator begin_impl(NatList<Ns...>) {
+    return iterator(std::begin(std::get<Ns>(ts))...);
+  }
+  template <unsigned... Ns> iterator end_impl(NatList<Ns...>) {
+    return iterator(std::end(std::get<Ns>(ts))...);
+  }
+
+public:
+  iterator begin() { return begin_impl(nat_list{}); }
+  iterator end() { return end_impl(nat_list{}); }
+  Zippy(Args &&... ts_) : ts(std::forward<Args>(ts_)...) {}
+};
+} // End detail namespace
+
+// zip iterator for two or more iteratable types.
+template <typename T, typename U, typename... Args>
+Zippy<ZipShortest, T, U, Args...> zip(T &&t, U &&u, Args &&... args) {
+  return Zippy<ZipShortest, T, U, Args...>(
+      std::forward<T>(t), std::forward<U>(u), std::forward<Args>(args)...);
+}
+
+// zip iterator that, for the sake of efficiency, assumes the first iteratee to
+// be the shortest.
+template <typename T, typename U, typename... Args>
+Zippy<ZipFirst, T, U, Args...> zip_first(T &&t, U &&u, Args &&... args) {
+  return Zippy<ZipFirst, T, U, Args...>(std::forward<T>(t), std::forward<U>(u),
+                                        std::forward<Args>(args)...);
+}
+
 //===----------------------------------------------------------------------===//
 //     Extra additions to <utility>
 //===----------------------------------------------------------------------===//
@@ -435,6 +524,17 @@
                         std::forward<UnaryPredicate>(P));
 }
 
+template <typename R, class OutputIt>
+OutputIt copy(R &&Range, OutputIt d_first) {
+  return std::copy(Range.begin(), Range.end(), d_first);
+}
+
+template <typename R, class OutputIt, typename UnaryPredicate>
+OutputIt copy_if(R &&Range, OutputIt d_first, UnaryPredicate &&P) {
+  return std::copy(Range.begin(), Range.end(), d_first,
+                   std::forward<UnaryPredicate>(P));
+}
+
 //===----------------------------------------------------------------------===//
 //     Extra additions to <memory>
 //===----------------------------------------------------------------------===//