Add STLExtras apply_tuple

[zturner]

Summary

This is based on the C++17 std::apply. Given a tuple std::tuple<Ts...> Tup and a Callbable F, this function invokes F(Ts...) and returns the result.

[dblaikie]

Looks good - couple of simple/optional things.

include/llvm/ADT/STLExtras.h

714

Probably call it 'apply', the same as the standard one? I think that's generally what we're doing for other not-yet-standardized implementaitons (llvm::make_unique, etc)

unittests/ADT/STLExtrasTest.cpp

91–114

I'd probably test slightly fewer cases (4 doesn't seem to be more interesting than 3, for example - I can see why 2 might be "degenerate"/boundary rather than a "middle of the road" test)

& might consider simplifying the testing to something like this:

auto R = apply_tuple([](int A, const char* B, double C) {
  EXPECT_EQ(1, A);
  ...
  return 47;
}, std::make_tuple(1, "foo", 3.14));
EXPECT_EQ(47, R);

There's no reason the output should be related to the input by type or value - just hard code some things, test that the things passed in make it into the lambda, and the thing returned makes it out again.

117–135

This seems to pull in a lot of code (all of std::vector, etc) to test what I would expect to be an isolated feature.

What cases are being exercised by this test case? Could it be a bit more targeted/explicit?

[pete]

Whats the behavior here in terms of implicit conversions and overloading?

Its probably handled however std::forward already does such things, but is it worth documenting/testing just to be clear what the expectation is?

BTW, no need for this to block the LGTM from David. Just something for a potential future patch.

include/llvm/ADT/STLExtras.h

 
 #include <algorithm> // for std::all_of
 #include <cassert>
 #include <cstddef> // for std::size_t
 #include <cstdlib> // for qsort
 #include <functional>
 #include <iterator>
 #include <memory>
+#include <tuple>
 #include <utility> // for std::pair
 
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/iterator.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/Support/Compiler.h"
 
 namespace llvm {

 ///   Item 3 - D
 ///
 template <typename R>
 auto enumerate(R &&Range)
     -> decltype(detail::make_enumerator(std::begin(Range), std::end(Range))) {
   return detail::make_enumerator(std::begin(Range), std::end(Range));
 }
 
+namespace detail {
+template <typename F, typename Tuple, std::size_t... I>
+auto apply_tuple_impl(F &&f, Tuple &&t, index_sequence<I...>)
+    -> decltype(std::forward<F>(f)(std::get<I>(std::forward<Tuple>(t))...)) {
+  return std::forward<F>(f)(std::get<I>(std::forward<Tuple>(t))...);
+}
+}
+
+/// Given an input tuple (a1, a2, ..., an), pass the arguments of the
+/// tuple variadically to f as if by calling f(a1, a2, ..., an) and
+/// return the result.
+template <typename F, typename Tuple>
+auto apply_tuple(F &&f, Tuple &&t) -> decltype(detail::apply_tuple_impl(
+    std::forward<F>(f), std::forward<Tuple>(t),
+    build_index_impl<
+        std::tuple_size<typename std::decay<Tuple>::type>::value>())) {
+  using Indices = build_index_impl<
+      std::tuple_size<typename std::decay<Tuple>::type>::value>;
+
+  return detail::apply_tuple_impl(std::forward<F>(f), std::forward<Tuple>(t),
+                                  Indices());
+}
 } // End llvm namespace
 
 #endif

unittests/ADT/STLExtrasTest.cpp

TEST(STLExtrasTest, EnumerateModify) {
   for (auto X : llvm::enumerate(foo)) {
     ++X.Value;
   }
 
   EXPECT_EQ('b', foo[0]);
   EXPECT_EQ('c', foo[1]);
   EXPECT_EQ('d', foo[2]);
 }
+
+TEST(STLExtrasTest, ApplyTuple) {
+  auto T = std::make_tuple(1, 2, 3, 4);
+  auto U = llvm::apply_tuple(
+      [](int A, int B, int C, int D) {
+        return std::make_tuple(A - B, B - C, C - D, D - A);
+      },
+      T);
+
+  EXPECT_EQ(-1, std::get<0>(U));
+  EXPECT_EQ(-1, std::get<1>(U));
+  EXPECT_EQ(-1, std::get<2>(U));
+  EXPECT_EQ(3, std::get<3>(U));
+
+  auto V = llvm::apply_tuple(
+      [](int A, int B, int C, int D) {
+        return std::make_tuple(std::make_pair(A, char('A' + A)),
+                               std::make_pair(B, char('A' + B)),
+                               std::make_pair(C, char('A' + C)), D);
+      },
+      T);
+
+  EXPECT_EQ(std::make_pair(1, 'B'), std::get<0>(V));
+  EXPECT_EQ(std::make_pair(2, 'C'), std::get<1>(V));
+  EXPECT_EQ(std::make_pair(3, 'D'), std::get<2>(V));
+  EXPECT_EQ(4, std::get<3>(V));
+}
+
+struct deref_iterator_tuple {
+  template <typename... Iters> auto operator()(Iters &&... Items) {
+    return std::make_tuple(*Items...);
+  }
+};
+
+struct increment_iterator_tuple {
+  template <typename... Iters> auto operator()(Iters &&... Items) {
+    return std::make_tuple(++Items...);
+  }
+};
+
+TEST(STLExtrasTest, ApplyTupleVariadic) {
+  std::vector<int> A = {1, 2, 3};
+  std::vector<char> B = {'A', 'B', 'C'};
+  std::vector<std::string> C = {"A", "B", "C"};
+
+  auto Iters = std::make_tuple(A.begin(), B.begin(), C.begin());
+  auto Values = apply_tuple(deref_iterator_tuple(), Iters);
+
+  static_assert(
+      std::is_same<std::tuple<int, char, std::string>, decltype(Values)>::value,
+      "Incorrect tuple type!");
+
+  EXPECT_EQ(1, std::get<0>(Values));
+  EXPECT_EQ('A', std::get<1>(Values));
+  EXPECT_EQ("A", std::get<2>(Values));
+
+  Iters = apply_tuple(increment_iterator_tuple(), Iters);
+  Values = apply_tuple(deref_iterator_tuple(), Iters);
+
+  EXPECT_EQ(2, std::get<0>(Values));
+  EXPECT_EQ('B', std::get<1>(Values));
+  EXPECT_EQ("B", std::get<2>(Values));
+}
 }