Revert "[folly::gen] Making 'just()' reference arguments like 'from()'"

Summary: This reverts commit 90da92b05762f8032560d0d6a66237ab2772d7f2.

Test Plan: compiles

Reviewed By: tjackson@fb.com

Subscribers: lins, anca, folly-diffs@, yfeldblum

FB internal diff: D1817376

Tasks: 6118752

diff --git a/folly/gen/Base-inl.h b/folly/gen/Base-inl.h
index e04c246cfe40501cbcb74e4910fdabe74798f7ae..083cf979b0f030051e75a2e72e49893bb0bfab26 100644 (file)
--- a/folly/gen/Base-inl.h
+++ b/folly/gen/Base-inl.h
@@ -328,32 +328,13 @@ class Empty : public GenImpl<Value, Empty<Value>> {
   void foreach(Body&&) const {}
 };
 
-template <class Value>
-class SingleReference : public GenImpl<Value&, SingleReference<Value>> {
-  static_assert(!std::is_reference<Value>::value,
-                "SingleReference requires non-ref types");
-  Value* ptr_;
- public:
-  explicit SingleReference(Value* ptr) : ptr_(ptr){}
-
-  template <class Handler>
-  bool apply(Handler&& handler) const {
-    return handler(*ptr_);
-  }
-
-  template <class Body>
-  void foreach(Body&& body) const {
-    body(*ptr_);
-  }
-};
-
-template <class Value>
-class SingleCopy : public GenImpl<const Value&, SingleCopy<Value>> {
+template<class Value>
+class Just : public GenImpl<const Value&, Just<Value>> {
   static_assert(!std::is_reference<Value>::value,
-                "SingleCopy requires non-ref types");
-  Value value_;
+                "Just requires non-ref types");
+  const Value value_;
  public:
-  explicit SingleCopy(Value value) : value_(std::forward<Value>(value)) {}
+  explicit Just(Value value) : value_(std::forward<Value>(value)) {}
 
   template <class Handler>
   bool apply(Handler&& handler) const {

diff --git a/folly/gen/Base.h b/folly/gen/Base.h
index bf9b4b535367446ae5f5943d4054de4ca9a62f3f..12d917edac6a3bed58f9907f2f056fdc4fd39d11 100644 (file)
--- a/folly/gen/Base.h
+++ b/folly/gen/Base.h
@@ -297,10 +297,7 @@ template<class Value>
 class Empty;
 
 template<class Value>
-class SingleReference;
-
-template<class Value>
-class SingleCopy;
+class Just;
 
 /*
  * Operators
@@ -485,25 +482,14 @@ Yield generator(Source&& source) {
 /*
  * empty() - for producing empty sequences.
  */
-template <class Value>
+template<class Value>
 detail::Empty<Value> empty() {
   return {};
 }
 
-template <class Value, class Just = detail::SingleReference<Value>>
-Just just(Value& value) {
-  return Just(&value);
-}
-
-template <class Value, class Just = detail::SingleReference<const Value>>
-Just just(const Value& value) {
-  return Just(&value);
-}
-
-template <class Value,
-          class Just = detail::SingleCopy<typename std::decay<Value>::type>>
-Just just(Value&& value) {
-  return Just(std::move(value));
+template<class Value>
+detail::Just<Value> just(Value value) {
+  return detail::Just<Value>(std::move(value));
 }
 
 /*

diff --git a/folly/gen/Parallel-inl.h b/folly/gen/Parallel-inl.h
index 06f1af012edc4dcadee6f49e082161221b34be76..666acb16d1e356c6a192ce177bb2af899cb6d931 100644 (file)
--- a/folly/gen/Parallel-inl.h
+++ b/folly/gen/Parallel-inl.h
@@ -136,7 +136,7 @@ class Sub : public Operator<Sub<Sink>> {
             class Source,
             class Result =
                 decltype(std::declval<Sink>().compose(std::declval<Source>())),
-            class Just = SingleCopy<typename std::decay<Result>::type>>
+            class Just = Just<typename std::decay<Result>::type>>
   Just compose(const GenImpl<Value, Source>& source) const {
     return Just(source | sink_);
   }

diff --git a/folly/gen/test/BaseTest.cpp b/folly/gen/test/BaseTest.cpp
index d403d99d4aeab579c2fa0d6cfb8f91c042da301b..2b99f15704c293f07b9f5b30fca30f2a919804cc 100644 (file)
--- a/folly/gen/test/BaseTest.cpp
+++ b/folly/gen/test/BaseTest.cpp
@@ -1073,31 +1073,6 @@ TEST(Gen, BatchMove) {
   EXPECT_EQ(expected, actual);
 }
 
-TEST(Gen, Just) {
-  {
-    int x = 3;
-    auto j = just(x);
-    EXPECT_EQ(&x, j | mapped([](const int& v) { return &v; }) | first);
-    x = 4;
-    EXPECT_EQ(4, j | first);
-  }
-  {
-    int x = 3;
-    const int& cx = x;
-    auto j = just(cx);
-    EXPECT_EQ(&x, j | mapped([](const int& v) { return &v; }) | first);
-    x = 5;
-    EXPECT_EQ(5, j | first);
-  }
-  {
-    int x = 3;
-    auto j = just(std::move(x));
-    EXPECT_NE(&x, j | mapped([](const int& v) { return &v; }) | first);
-    x = 5;
-    EXPECT_EQ(3, j | first);
-  }
-}
-
 int main(int argc, char *argv[]) {
   testing::InitGoogleTest(&argc, argv);
   gflags::ParseCommandLineFlags(&argc, &argv, true);