Apply clang-format to folly/gen/

Summary: [Folly] Apply `clang-format` to `folly/gen/`.

Reviewed By: Orvid

Differential Revision: D9671968

fbshipit-source-id: 1164cf0d236914b5fd7ed35d5d41c785935e876b

folly/gen/Base.h

@@ -86,8 +86,8 @@ namespace gen {
 class Less {
  public:
   template <class First, class Second>
-  auto operator()(const First& first, const Second& second) const ->
-  decltype(first < second) {
+  auto operator()(const First& first, const Second& second) const
+      -> decltype(first < second) {
     return first < second;
   }
 };
@@ -95,8 +95,8 @@ class Less {
 class Greater {
  public:
   template <class First, class Second>
-  auto operator()(const First& first, const Second& second) const ->
-  decltype(first > second) {
+  auto operator()(const First& first, const Second& second) const
+      -> decltype(first > second) {
     return first > second;
   }
 };
@@ -105,8 +105,8 @@ template <int n>
 class Get {
  public:
   template <class Value>
-  auto operator()(Value&& value) const ->
-  decltype(std::get<n>(std::forward<Value>(value))) {
+  auto operator()(Value&& value) const
+      -> decltype(std::get<n>(std::forward<Value>(value))) {
     return std::get<n>(std::forward<Value>(value));
   }
 };
@@ -115,12 +115,12 @@ template <class Class, class Result>
 class MemberFunction {
  public:
   typedef Result (Class::*MemberPtr)();
+
  private:
   MemberPtr member_;
+
  public:
-  explicit MemberFunction(MemberPtr member)
-    : member_(member)
-  {}
+  explicit MemberFunction(MemberPtr member) : member_(member) {}
 
   Result operator()(Class&& x) const {
     return (x.*member_)();
@@ -136,15 +136,15 @@ class MemberFunction {
 };
 
 template <class Class, class Result>
-class ConstMemberFunction{
+class ConstMemberFunction {
  public:
   typedef Result (Class::*MemberPtr)() const;
+
  private:
   MemberPtr member_;
+
  public:
-  explicit ConstMemberFunction(MemberPtr member)
-    : member_(member)
-  {}
+  explicit ConstMemberFunction(MemberPtr member) : member_(member) {}
 
   Result operator()(const Class& x) const {
     return (x.*member_)();
@@ -158,13 +158,13 @@ class ConstMemberFunction{
 template <class Class, class FieldType>
 class Field {
  public:
-  typedef FieldType (Class::*FieldPtr);
+  typedef FieldType(Class::*FieldPtr);
+
  private:
   FieldPtr field_;
+
  public:
-  explicit Field(FieldPtr field)
-    : field_(field)
-  {}
+  explicit Field(FieldPtr field) : field_(field) {}
 
   const FieldType& operator()(const Class& x) const {
     return x.*field_;
@@ -190,8 +190,8 @@ class Field {
 class Move {
  public:
   template <class Value>
-  auto operator()(Value&& value) const ->
-  decltype(std::move(std::forward<Value>(value))) {
+  auto operator()(Value&& value) const
+      -> decltype(std::move(std::forward<Value>(value))) {
     return std::move(std::forward<Value>(value));
   }
 };
@@ -206,9 +206,7 @@ class Negate {
  public:
   Negate() = default;
 
-  explicit Negate(Predicate pred)
-    : pred_(std::move(pred))
-  {}
+  explicit Negate(Predicate pred) : pred_(std::move(pred)) {}
 
   template <class Arg>
   bool operator()(Arg&& arg) const {
@@ -274,7 +272,6 @@ struct ValueTypeOfRange {
   using StorageType = typename std::decay<RefType>::type;
 };
 
-
 /*
  * Sources
  */
@@ -577,7 +574,7 @@ Map mapOp(Operator op) {
  */
 enum MemberType {
   Const,
-  Mutable
+  Mutable,
 };
 
 /**
@@ -588,14 +585,14 @@ enum MemberType {
 template <MemberType Constness>
 struct ExprIsConst {
   enum {
-    value = Constness == Const
+    value = Constness == Const,
   };
 };
 
 template <MemberType Constness>
 struct ExprIsMutable {
   enum {
-    value = Constness == Mutable
+    value = Constness == Mutable,
   };
 };
 
@@ -605,8 +602,8 @@ template <
     class Return,
     class Mem = ConstMemberFunction<Class, Return>,
     class Map = detail::Map<Mem>>
-typename std::enable_if<ExprIsConst<Constness>::value, Map>::type
-member(Return (Class::*member)() const) {
+typename std::enable_if<ExprIsConst<Constness>::value, Map>::type member(
+    Return (Class::*member)() const) {
   return Map(Mem(member));
 }
 
@@ -616,8 +613,8 @@ template <
     class Return,
     class Mem = MemberFunction<Class, Return>,
     class Map = detail::Map<Mem>>
-typename std::enable_if<ExprIsMutable<Constness>::value, Map>::type
-member(Return (Class::*member)()) {
+typename std::enable_if<ExprIsMutable<Constness>::value, Map>::type member(
+    Return (Class::*member)()) {
   return Map(Mem(member));
 }
 
@@ -671,10 +668,8 @@ template <
     class Selector = Identity,
     class Comparer = Less,
     class Order = detail::Order<Selector, Comparer>>
-Order orderBy(Selector selector = Selector(),
-              Comparer comparer = Comparer()) {
-  return Order(std::move(selector),
-               std::move(comparer));
+Order orderBy(Selector selector = Selector(), Comparer comparer = Comparer()) {
+  return Order(std::move(selector), std::move(comparer));
 }
 
 template <
@@ -793,10 +788,8 @@ Composed all(Predicate pred = Predicate()) {
 }
 
 template <class Seed, class Fold, class FoldLeft = detail::FoldLeft<Seed, Fold>>
-FoldLeft foldl(Seed seed = Seed(),
-               Fold fold = Fold()) {
-  return FoldLeft(std::move(seed),
-                  std::move(fold));
+FoldLeft foldl(Seed seed = Seed(), Fold fold = Fold()) {
+  return FoldLeft(std::move(seed), std::move(fold));
 }
 
 template <class Reducer, class Reduce = detail::Reduce<Reducer>>

folly/gen/Combine-inl.h

@@ -37,9 +37,10 @@ template <class Container>
 class Interleave : public Operator<Interleave<Container>> {
   // see comment about copies in CopiedSource
   const std::shared_ptr<const Container> container_;
+
  public:
   explicit Interleave(Container container)
-    : container_(new Container(std::move(container))) {}
+      : container_(new Container(std::move(container))) {}
 
   template <class Value, class Source>
   class Generator : public GenImpl<Value, Generator<Value, Source>> {
@@ -47,31 +48,32 @@ class Interleave : public Operator<Interleave<Container>> {
     const std::shared_ptr<const Container> container_;
     typedef const typename Container::value_type& ConstRefType;
 
-    static_assert(std::is_same<const Value&, ConstRefType>::value,
-                  "Only matching types may be interleaved");
+    static_assert(
+        std::is_same<const Value&, ConstRefType>::value,
+        "Only matching types may be interleaved");
 
    public:
-    explicit Generator(Source source,
-                       const std::shared_ptr<const Container> container)
-      : source_(std::move(source)),
-        container_(container) { }
+    explicit Generator(
+        Source source,
+        const std::shared_ptr<const Container> container)
+        : source_(std::move(source)), container_(container) {}
 
     template <class Handler>
     bool apply(Handler&& handler) const {
       auto iter = container_->begin();
       return source_.apply([&](const Value& value) -> bool {
-            if (iter == container_->end()) {
-              return false;
-            }
-            if (!handler(value)) {
-              return false;
-            }
-            if (!handler(*iter)) {
-              return false;
-            }
-            iter++;
-            return true;
-        });
+        if (iter == container_->end()) {
+          return false;
+        }
+        if (!handler(value)) {
+          return false;
+        }
+        if (!handler(*iter)) {
+          return false;
+        }
+        iter++;
+        return true;
+      });
     }
   };
 
@@ -97,9 +99,10 @@ template <class Container>
 class Zip : public Operator<Zip<Container>> {
   // see comment about copies in CopiedSource
   const std::shared_ptr<const Container> container_;
+
  public:
   explicit Zip(Container container)
-    : container_(new Container(std::move(container))) {}
+      : container_(new Container(std::move(container))) {}
 
   template <
       class Value1,
@@ -108,30 +111,30 @@ class Zip : public Operator<Zip<Container>> {
       class Result = std::tuple<
           typename std::decay<Value1>::type,
           typename std::decay<Value2>::type>>
-  class Generator : public GenImpl<Result,
-                                   Generator<Value1,Source,Value2,Result>> {
+  class Generator
+      : public GenImpl<Result, Generator<Value1, Source, Value2, Result>> {
     Source source_;
     const std::shared_ptr<const Container> container_;
 
    public:
-    explicit Generator(Source source,
-                       const std::shared_ptr<const Container> container)
-      : source_(std::move(source)),
-        container_(container) { }
+    explicit Generator(
+        Source source,
+        const std::shared_ptr<const Container> container)
+        : source_(std::move(source)), container_(container) {}
 
     template <class Handler>
     bool apply(Handler&& handler) const {
       auto iter = container_->begin();
       return (source_.apply([&](Value1 value) -> bool {
-            if (iter == container_->end()) {
-              return false;
-            }
-            if (!handler(std::make_tuple(std::forward<Value1>(value), *iter))) {
-              return false;
-            }
-            ++iter;
-            return true;
-          }));
+        if (iter == container_->end()) {
+          return false;
+        }
+        if (!handler(std::make_tuple(std::forward<Value1>(value), *iter))) {
+          return false;
+        }
+        ++iter;
+        return true;
+      }));
     }
   };
 
@@ -147,48 +150,45 @@ class Zip : public Operator<Zip<Container>> {
 };
 
 template <class... Types1, class... Types2>
-auto add_to_tuple(std::tuple<Types1...> t1, std::tuple<Types2...> t2) ->
-std::tuple<Types1..., Types2...> {
+auto add_to_tuple(std::tuple<Types1...> t1, std::tuple<Types2...> t2)
+    -> std::tuple<Types1..., Types2...> {
   return std::tuple_cat(std::move(t1), std::move(t2));
 }
 
 template <class... Types1, class Type2>
-auto add_to_tuple(std::tuple<Types1...> t1, Type2&& t2) ->
-decltype(std::tuple_cat(std::move(t1),
-                        std::make_tuple(std::forward<Type2>(t2)))) {
-  return std::tuple_cat(std::move(t1),
-                        std::make_tuple(std::forward<Type2>(t2)));
+auto add_to_tuple(std::tuple<Types1...> t1, Type2&& t2) -> decltype(
+    std::tuple_cat(std::move(t1), std::make_tuple(std::forward<Type2>(t2)))) {
+  return std::tuple_cat(
+      std::move(t1), std::make_tuple(std::forward<Type2>(t2)));
 }
 
 template <class Type1, class... Types2>
-auto add_to_tuple(Type1&& t1, std::tuple<Types2...> t2) ->
-decltype(std::tuple_cat(std::make_tuple(std::forward<Type1>(t1)),
-                        std::move(t2))) {
-  return std::tuple_cat(std::make_tuple(std::forward<Type1>(t1)),
-                        std::move(t2));
+auto add_to_tuple(Type1&& t1, std::tuple<Types2...> t2) -> decltype(
+    std::tuple_cat(std::make_tuple(std::forward<Type1>(t1)), std::move(t2))) {
+  return std::tuple_cat(
+      std::make_tuple(std::forward<Type1>(t1)), std::move(t2));
 }
 
 template <class Type1, class Type2>
-auto add_to_tuple(Type1&& t1, Type2&& t2) ->
-decltype(std::make_tuple(std::forward<Type1>(t1),
-                         std::forward<Type2>(t2))) {
-  return std::make_tuple(std::forward<Type1>(t1),
-                         std::forward<Type2>(t2));
+auto add_to_tuple(Type1&& t1, Type2&& t2) -> decltype(
+    std::make_tuple(std::forward<Type1>(t1), std::forward<Type2>(t2))) {
+  return std::make_tuple(std::forward<Type1>(t1), std::forward<Type2>(t2));
 }
 
 // Merges a 2-tuple into a single tuple (get<0> could already be a tuple)
 class MergeTuples {
  public:
   template <class Tuple>
-  auto operator()(Tuple&& value) const ->
-  decltype(add_to_tuple(std::get<0>(std::forward<Tuple>(value)),
-                        std::get<1>(std::forward<Tuple>(value)))) {
-    static_assert(std::tuple_size<
-                    typename std::remove_reference<Tuple>::type
-                    >::value == 2,
-                  "Can only merge tuples of size 2");
-    return add_to_tuple(std::get<0>(std::forward<Tuple>(value)),
-                        std::get<1>(std::forward<Tuple>(value)));
+  auto operator()(Tuple&& value) const -> decltype(add_to_tuple(
+      std::get<0>(std::forward<Tuple>(value)),
+      std::get<1>(std::forward<Tuple>(value)))) {
+    static_assert(
+        std::tuple_size<typename std::remove_reference<Tuple>::type>::value ==
+            2,
+        "Can only merge tuples of size 2");
+    return add_to_tuple(
+        std::get<0>(std::forward<Tuple>(value)),
+        std::get<1>(std::forward<Tuple>(value)));
   }
 };
 

folly/gen/Core-inl.h

@@ -108,8 +108,7 @@ template <
     class Left,
     class Right,
     class Composed = detail::Composed<Left, Right>>
-Composed operator|(const Operator<Left>& left,
-                   const Operator<Right>& right) {
+Composed operator|(const Operator<Left>& left, const Operator<Right>& right) {
   return Composed(left.self(), right.self());
 }
 
@@ -117,8 +116,7 @@ template <
     class Left,
     class Right,
     class Composed = detail::Composed<Left, Right>>
-Composed operator|(const Operator<Left>& left,
-                   Operator<Right>&& right) {
+Composed operator|(const Operator<Left>& left, Operator<Right>&& right) {
   return Composed(left.self(), std::move(right.self()));
 }
 
@@ -126,8 +124,7 @@ template <
     class Left,
     class Right,
     class Composed = detail::Composed<Left, Right>>
-Composed operator|(Operator<Left>&& left,
-                   const Operator<Right>& right) {
+Composed operator|(Operator<Left>&& left, const Operator<Right>& right) {
   return Composed(std::move(left.self()), right.self());
 }
 
@@ -135,8 +132,7 @@ template <
     class Left,
     class Right,
     class Composed = detail::Composed<Left, Right>>
-Composed operator|(Operator<Left>&& left,
-                   Operator<Right>&& right) {
+Composed operator|(Operator<Left>&& left, Operator<Right>&& right) {
   return Composed(std::move(left.self()), std::move(right.self()));
 }
 
@@ -176,10 +172,10 @@ class GenImpl : public FBounded<Self> {
   template <class Body>
   void foreach(Body&& body) const {
     this->self().apply([&](Value value) -> bool {
-        static_assert(!infinite, "Cannot call foreach on infinite GenImpl");
-        body(std::forward<Value>(value));
-        return true;
-      });
+      static_assert(!infinite, "Cannot call foreach on infinite GenImpl");
+      body(std::forward<Value>(value));
+      return true;
+    });
   }
 
   // Child classes should override if the sequence generated is *definitely*
@@ -201,11 +197,12 @@ template <
     class RightValue,
     class Right,
     class Chain = detail::Chain<LeftValue, Left, Right>>
-Chain operator+(const GenImpl<LeftValue, Left>& left,
-                const GenImpl<RightValue, Right>& right) {
+Chain operator+(
+    const GenImpl<LeftValue, Left>& left,
+    const GenImpl<RightValue, Right>& right) {
   static_assert(
-    std::is_same<LeftValue, RightValue>::value,
-    "Generators may ony be combined if Values are the exact same type.");
+      std::is_same<LeftValue, RightValue>::value,
+      "Generators may ony be combined if Values are the exact same type.");
   return Chain(left.self(), right.self());
 }
 
@@ -215,11 +212,12 @@ template <
     class RightValue,
     class Right,
     class Chain = detail::Chain<LeftValue, Left, Right>>
-Chain operator+(const GenImpl<LeftValue, Left>& left,
-                GenImpl<RightValue, Right>&& right) {
+Chain operator+(
+    const GenImpl<LeftValue, Left>& left,
+    GenImpl<RightValue, Right>&& right) {
   static_assert(
-    std::is_same<LeftValue, RightValue>::value,
-    "Generators may ony be combined if Values are the exact same type.");
+      std::is_same<LeftValue, RightValue>::value,
+      "Generators may ony be combined if Values are the exact same type.");
   return Chain(left.self(), std::move(right.self()));
 }
 
@@ -229,11 +227,12 @@ template <
     class RightValue,
     class Right,
     class Chain = detail::Chain<LeftValue, Left, Right>>
-Chain operator+(GenImpl<LeftValue, Left>&& left,
-                const GenImpl<RightValue, Right>& right) {
+Chain operator+(
+    GenImpl<LeftValue, Left>&& left,
+    const GenImpl<RightValue, Right>& right) {
   static_assert(
-    std::is_same<LeftValue, RightValue>::value,
-    "Generators may ony be combined if Values are the exact same type.");
+      std::is_same<LeftValue, RightValue>::value,
+      "Generators may ony be combined if Values are the exact same type.");
   return Chain(std::move(left.self()), right.self());
 }
 
@@ -243,11 +242,12 @@ template <
     class RightValue,
     class Right,
     class Chain = detail::Chain<LeftValue, Left, Right>>
-Chain operator+(GenImpl<LeftValue, Left>&& left,
-                GenImpl<RightValue, Right>&& right) {
+Chain operator+(
+    GenImpl<LeftValue, Left>&& left,
+    GenImpl<RightValue, Right>&& right) {
   static_assert(
-    std::is_same<LeftValue, RightValue>::value,
-    "Generators may ony be combined if Values are the exact same type.");
+      std::is_same<LeftValue, RightValue>::value,
+      "Generators may ony be combined if Values are the exact same type.");
   return Chain(std::move(left.self()), std::move(right.self()));
 }
 
@@ -257,10 +257,10 @@ Chain operator+(GenImpl<LeftValue, Left>&& left,
  */
 template <class Value, class Gen, class Handler>
 typename std::enable_if<
-  IsCompatibleSignature<Handler, void(Value)>::value>::type
+    IsCompatibleSignature<Handler, void(Value)>::value>::type
 operator|(const GenImpl<Value, Gen>& gen, Handler&& handler) {
-  static_assert(!Gen::infinite,
-                "Cannot pull all values from an infinite sequence.");
+  static_assert(
+      !Gen::infinite, "Cannot pull all values from an infinite sequence.");
   gen.self().foreach(std::forward<Handler>(handler));
 }
 
@@ -269,9 +269,9 @@ operator|(const GenImpl<Value, Gen>& gen, Handler&& handler) {
  *   gen | [](Value v) -> bool { return shouldContinue(); };
  */
 template <class Value, class Gen, class Handler>
-typename std::enable_if<
-  IsCompatibleSignature<Handler, bool(Value)>::value, bool>::type
-operator|(const GenImpl<Value, Gen>& gen, Handler&& handler) {
+typename std::
+    enable_if<IsCompatibleSignature<Handler, bool(Value)>::value, bool>::type
+    operator|(const GenImpl<Value, Gen>& gen, Handler&& handler) {
   return gen.self().apply(std::forward<Handler>(handler));
 }
 
@@ -281,14 +281,14 @@ operator|(const GenImpl<Value, Gen>& gen, Handler&& handler) {
  *   gen | map(square) | sum
  */
 template <class Value, class Gen, class Op>
-auto operator|(const GenImpl<Value, Gen>& gen, const Operator<Op>& op) ->
-decltype(op.self().compose(gen.self())) {
+auto operator|(const GenImpl<Value, Gen>& gen, const Operator<Op>& op)
+    -> decltype(op.self().compose(gen.self())) {
   return op.self().compose(gen.self());
 }
 
 template <class Value, class Gen, class Op>
-auto operator|(GenImpl<Value, Gen>&& gen, const Operator<Op>& op) ->
-decltype(op.self().compose(std::move(gen.self()))) {
+auto operator|(GenImpl<Value, Gen>&& gen, const Operator<Op>& op)
+    -> decltype(op.self().compose(std::move(gen.self()))) {
   return op.self().compose(std::move(gen.self()));
 }
 
@@ -309,12 +309,12 @@ template <class First, class Second>
 class Composed : public Operator<Composed<First, Second>> {
   First first_;
   Second second_;
+
  public:
   Composed() = default;
 
   Composed(First first, Second second)
-    : first_(std::move(first))
-    , second_(std::move(second)) {}
+      : first_(std::move(first)), second_(std::move(second)) {}
 
   template <
       class Source,
@@ -348,20 +348,18 @@ class Composed : public Operator<Composed<First, Second>> {
  *   int total = nums | sum;
  */
 template <class Value, class First, class Second>
-class Chain : public GenImpl<Value,
-                             Chain<Value, First, Second>> {
+class Chain : public GenImpl<Value, Chain<Value, First, Second>> {
   First first_;
   Second second_;
 
  public:
   explicit Chain(First first, Second second)
-      : first_(std::move(first))
-      , second_(std::move(second)) {}
+      : first_(std::move(first)), second_(std::move(second)) {}
 
   template <class Handler>
   bool apply(Handler&& handler) const {
-    return first_.apply(std::forward<Handler>(handler))
-        && second_.apply(std::forward<Handler>(handler));
+    return first_.apply(std::forward<Handler>(handler)) &&
+        second_.apply(std::forward<Handler>(handler));
   }
 
   template <class Body>

folly/gen/File-inl.h

@@ -29,8 +29,7 @@ namespace detail {
 class FileReader : public GenImpl<ByteRange, FileReader> {
  public:
   FileReader(File file, std::unique_ptr<IOBuf> buffer)
-    : file_(std::move(file)),
-      buffer_(std::move(buffer)) {
+      : file_(std::move(file)), buffer_(std::move(buffer)) {
     buffer_->clear();
   }
 
@@ -65,8 +64,7 @@ class FileReader : public GenImpl<ByteRange, FileReader> {
 class FileWriter : public Operator<FileWriter> {
  public:
   FileWriter(File file, std::unique_ptr<IOBuf> buffer)
-    : file_(std::move(file)),
-      buffer_(std::move(buffer)) {
+      : file_(std::move(file)), buffer_(std::move(buffer)) {
     if (buffer_) {
       buffer_->clear();
     }
@@ -102,8 +100,8 @@ class FileWriter : public Operator<FileWriter> {
         n = ::write(file_.fd(), v.data(), v.size());
       } while (n == -1 && errno == EINTR);
       if (n == -1) {
-        throw std::system_error(errno, std::system_category(),
-                                "write() failed");
+        throw std::system_error(
+            errno, std::system_category(), "write() failed");
       }
       v.advance(size_t(n));
     }
@@ -121,9 +119,11 @@ class FileWriter : public Operator<FileWriter> {
 };
 
 inline auto byLineImpl(File file, char delim, bool keepDelimiter) {
+  // clang-format off
   return fromFile(std::move(file))
-    | eachAs<StringPiece>()
-    | resplit(delim, keepDelimiter);
+      | eachAs<StringPiece>()
+      | resplit(delim, keepDelimiter);
+  // clang-format on
 }
 
 } // namespace detail

folly/gen/File.h

@@ -35,7 +35,7 @@ class FileWriter;
  * to hold each value).
  */
 template <class S = detail::FileReader>
-S fromFile(File file, size_t bufferSize=4096) {
+S fromFile(File file, size_t bufferSize = 4096) {
   return S(std::move(file), IOBuf::create(bufferSize));
 }
 
@@ -52,7 +52,7 @@ S fromFile(File file, std::unique_ptr<IOBuf> buffer) {
  * If bufferSize is 0, writes will be unbuffered.
  */
 template <class S = detail::FileWriter>
-S toFile(File file, size_t bufferSize=4096) {
+S toFile(File file, size_t bufferSize = 4096) {
   return S(std::move(file), bufferSize ? nullptr : IOBuf::create(bufferSize));
 }
 

folly/gen/Parallel-inl.h

@@ -45,8 +45,12 @@ class ClosableMPMCQueue {
     CHECK(!consumers());
   }
 
-  void openProducer() { ++producers_; }
-  void openConsumer() { ++consumers_; }
+  void openProducer() {
+    ++producers_;
+  }
+  void openConsumer() {
+    ++consumers_;
+  }
 
   void closeInputProducer() {
     size_t producers = producers_--;
@@ -159,13 +163,15 @@ class Parallel : public Operator<Parallel<Ops>> {
           decltype(std::declval<Ops>().compose(Empty<InputDecayed&&>())),
       class Output = typename Composed::ValueType,
       class OutputDecayed = typename std::decay<Output>::type>
-  class Generator : public GenImpl<OutputDecayed&&,
-                                   Generator<Input,
-                                             Source,
-                                             InputDecayed,
-                                             Composed,
-                                             Output,
-                                             OutputDecayed>> {
+  class Generator : public GenImpl<
+                        OutputDecayed&&,
+                        Generator<
+                            Input,
+                            Source,
+                            InputDecayed,
+                            Composed,
+                            Output,
+                            OutputDecayed>> {
     const Source source_;
     const Ops ops_;
     const size_t threads_;
@@ -269,9 +275,13 @@ class Parallel : public Operator<Parallel<Ops>> {
         CHECK(!outQueue_.producers());
       }
 
-      void closeInputProducer() { inQueue_.closeInputProducer(); }
+      void closeInputProducer() {
+        inQueue_.closeInputProducer();
+      }
 
-      void closeOutputConsumer() { outQueue_.closeOutputConsumer(); }
+      void closeOutputConsumer() {
+        outQueue_.closeOutputConsumer();
+      }
 
       bool writeUnlessClosed(Input&& input) {
         return inQueue_.writeUnlessClosed(std::forward<Input>(input));

folly/gen/Parallel.h

@@ -58,7 +58,6 @@ Chunked chunked(Container& container, int chunkSize = 256) {
   return Chunked(chunkSize, folly::range(container.begin(), container.end()));
 }
 
-
 /**
  * parallel - A parallelization operator.
  *

folly/gen/ParallelMap-inl.h

@@ -47,12 +47,12 @@ template <class Predicate>
 class PMap : public Operator<PMap<Predicate>> {
   Predicate pred_;
   size_t nThreads_;
+
  public:
   PMap() = default;
 
   PMap(Predicate pred, size_t nThreads)
-    : pred_(std::move(pred)),
-      nThreads_(nThreads) { }
+      : pred_(std::move(pred)), nThreads_(nThreads) {}
 
   template <
       class Value,
@@ -75,8 +75,7 @@ class PMap : public Operator<PMap<Predicate>> {
 
      public:
       ExecutionPipeline(const Predicate& pred, size_t nThreads)
-        : pred_(pred),
-          pipeline_(nThreads, nThreads) {
+          : pred_(pred), pipeline_(nThreads, nThreads) {
         workers_.reserve(nThreads);
         for (size_t i = 0; i < nThreads; i++) {
           workers_.push_back(std::thread([this] { this->predApplier(); }));
@@ -86,7 +85,9 @@ class PMap : public Operator<PMap<Predicate>> {
       ~ExecutionPipeline() {
         assert(pipeline_.sizeGuess() == 0);
         assert(done_.load());
-        for (auto& w : workers_) { w.join(); }
+        for (auto& w : workers_) {
+          w.join();
+        }
       }
 
       void stop() {
@@ -131,8 +132,7 @@ class PMap : public Operator<PMap<Predicate>> {
           if (pipeline_.template readStage<0>(ticket, in)) {
             wake_.cancelWait();
             Output out = pred_(std::move(in));
-            pipeline_.template blockingWriteStage<0>(ticket,
-                                                     std::move(out));
+            pipeline_.template blockingWriteStage<0>(ticket, std::move(out));
             continue;
           }
 
@@ -149,10 +149,9 @@ class PMap : public Operator<PMap<Predicate>> {
 
    public:
     Generator(Source source, const Predicate& pred, size_t nThreads)
-      : source_(std::move(source)),
-        pred_(pred),
-        nThreads_(nThreads ? nThreads : sysconf(_SC_NPROCESSORS_ONLN)) {
-    }
+        : source_(std::move(source)),
+          pred_(pred),
+          nThreads_(nThreads ? nThreads : sysconf(_SC_NPROCESSORS_ONLN)) {}
 
     template <class Body>
     void foreach(Body&& body) const {

folly/gen/ParallelMap.h

@@ -39,7 +39,7 @@ class PMap;
  *       caller thread.
  */
 template <class Predicate, class PMap = detail::PMap<Predicate>>
-  PMap pmap(Predicate pred = Predicate(), size_t nThreads = 0) {
+PMap pmap(Predicate pred = Predicate(), size_t nThreads = 0) {
   return PMap(std::move(pred), nThreads);
 }
 } // namespace gen

folly/gen/String-inl.h

@@ -34,9 +34,8 @@ namespace detail {
  * Returns the number of trailing bytes of "prefix" that make up the
  * delimiter, or 0 if the delimiter was not found.
  */
-inline size_t splitPrefix(StringPiece& in,
-                          StringPiece& prefix,
-                          char delimiter) {
+inline size_t
+splitPrefix(StringPiece& in, StringPiece& prefix, char delimiter) {
   size_t found = in.find(delimiter);
   if (found != StringPiece::npos) {
     ++found;
@@ -51,9 +50,8 @@ inline size_t splitPrefix(StringPiece& in,
 /**
  * As above, but supports multibyte delimiters.
  */
-inline size_t splitPrefix(StringPiece& in,
-                          StringPiece& prefix,
-                          StringPiece delimiter) {
+inline size_t
+splitPrefix(StringPiece& in, StringPiece& prefix, StringPiece delimiter) {
   auto found = in.find(delimiter);
   if (found != StringPiece::npos) {
     found += delimiter.size();
@@ -68,9 +66,7 @@ inline size_t splitPrefix(StringPiece& in,
 /**
  * As above, but splits by any of the EOL terms: \r, \n, or \r\n.
  */
-inline size_t splitPrefix(StringPiece& in,
-                         StringPiece& prefix,
-                         MixedNewlines) {
+inline size_t splitPrefix(StringPiece& in, StringPiece& prefix, MixedNewlines) {
   const auto kCRLF = "\r\n";
   const size_t kLenCRLF = 2;
 
@@ -171,7 +167,7 @@ bool StreamSplitter<Callback>::operator()(StringPiece in) {
     } else if (maxLength_ && buffer_.length() + in.size() >= maxLength_) {
       // Send all of buffer_, plus a bit of in, to the callback
       if (!detail::consumeBufferPlus(
-               pieceCb_, buffer_, in, maxLength_ - buffer_.length())) {
+              pieceCb_, buffer_, in, maxLength_ - buffer_.length())) {
         return false;
       }
       // Post-conditions:
@@ -183,7 +179,7 @@ bool StreamSplitter<Callback>::operator()(StringPiece in) {
   // len(buffer + in) < maxLength_.
 
   // Send lines to callback directly from input (no buffer)
-  while (found) {  // Buffer guaranteed to be empty
+  while (found) { // Buffer guaranteed to be empty
     if (!detail::consumeFixedSizeChunks(pieceCb_, prefix, maxLength_)) {
       return false;
     }
@@ -192,7 +188,7 @@ bool StreamSplitter<Callback>::operator()(StringPiece in) {
 
   // No more delimiters left; consume 'in' until it is shorter than maxLength_
   if (maxLength_) {
-    while (in.size() >= maxLength_) {  // Buffer is guaranteed to be empty
+    while (in.size() >= maxLength_) { // Buffer is guaranteed to be empty
       if (!pieceCb_(StringPiece(in.begin(), maxLength_))) {
         return false;
       }
@@ -200,7 +196,7 @@ bool StreamSplitter<Callback>::operator()(StringPiece in) {
     }
   }
 
-  if (!in.empty()) {  // Buffer may be nonempty
+  if (!in.empty()) { // Buffer may be nonempty
     // Incomplete line left, append to buffer
     buffer_.reserve(0, in.size());
     memcpy(buffer_.writableTail(), in.data(), in.size());
@@ -274,18 +270,17 @@ class SplitStringSource
     : public GenImpl<StringPiece, SplitStringSource<DelimiterType>> {
   StringPiece source_;
   DelimiterType delimiter_;
+
  public:
-  SplitStringSource(const StringPiece source,
-                    DelimiterType delimiter)
-    : source_(source)
-    , delimiter_(std::move(delimiter)) { }
+  SplitStringSource(const StringPiece source, DelimiterType delimiter)
+      : source_(source), delimiter_(std::move(delimiter)) {}
 
   template <class Body>
   bool apply(Body&& body) const {
     StringPiece rest(source_);
     StringPiece prefix;
     while (size_t delim_len = splitPrefix(rest, prefix, this->delimiter_)) {
-      prefix.subtract(delim_len);  // Remove the delimiter
+      prefix.subtract(delim_len); // Remove the delimiter
       if (!body(prefix)) {
         return false;
       }
@@ -308,10 +303,9 @@ class SplitStringSource
 template <class Delimiter, class Output>
 class Unsplit : public Operator<Unsplit<Delimiter, Output>> {
   Delimiter delimiter_;
+
  public:
-  explicit Unsplit(const Delimiter& delimiter)
-    : delimiter_(delimiter) {
-  }
+  explicit Unsplit(const Delimiter& delimiter) : delimiter_(delimiter) {}
 
   template <class Source, class Value>
   Output compose(const GenImpl<Value, Source>& source) const {
@@ -332,10 +326,10 @@ template <class Delimiter, class OutputBuffer>
 class UnsplitBuffer : public Operator<UnsplitBuffer<Delimiter, OutputBuffer>> {
   Delimiter delimiter_;
   OutputBuffer* outputBuffer_;
+
  public:
   UnsplitBuffer(const Delimiter& delimiter, OutputBuffer* outputBuffer)
-    : delimiter_(delimiter)
-    , outputBuffer_(outputBuffer) {
+      : delimiter_(delimiter), outputBuffer_(outputBuffer) {
     CHECK(outputBuffer);
   }
 
@@ -355,18 +349,19 @@ class UnsplitBuffer : public Operator<UnsplitBuffer<Delimiter, OutputBuffer>> {
   }
 };
 
-
 /**
  * Hack for static for-like constructs
  */
 template <class Target, class = void>
-inline Target passthrough(Target target) { return target; }
+inline Target passthrough(Target target) {
+  return target;
+}
 
 FOLLY_PUSH_WARNING
 #ifdef __clang__
 // Clang isn't happy with eatField() hack below.
 #pragma GCC diagnostic ignored "-Wreturn-stack-address"
-#endif  // __clang__
+#endif // __clang__
 
 /**
  * ParseToTuple - For splitting a record and immediatlely converting it to a
@@ -381,9 +376,9 @@ FOLLY_PUSH_WARNING
 template <class TargetContainer, class Delimiter, class... Targets>
 class SplitTo {
   Delimiter delimiter_;
+
  public:
-  explicit SplitTo(Delimiter delimiter)
-    : delimiter_(delimiter) {}
+  explicit SplitTo(Delimiter delimiter) : delimiter_(delimiter) {}
 
   TargetContainer operator()(StringPiece line) const {
     int i = 0;
@@ -391,9 +386,10 @@ class SplitTo {
     // HACK(tjackson): Used for referencing fields[] corresponding to variadic
     // template parameters.
     auto eatField = [&]() -> StringPiece& { return fields[i++]; };
-    if (!split(delimiter_,
-               line,
-               detail::passthrough<StringPiece&, Targets>(eatField())...)) {
+    if (!split(
+            delimiter_,
+            line,
+            detail::passthrough<StringPiece&, Targets>(eatField())...)) {
       throw std::runtime_error("field count mismatch");
     }
     i = 0;

folly/gen/String.h

@@ -92,7 +92,6 @@ S lines(StringPiece source) {
  *   assert(result == "a b c");
  */
 
-
 // NOTE: The template arguments are reversed to allow the user to cleanly
 // specify the output type while still inferring the type of the delimiter.
 template <
@@ -142,34 +141,33 @@ UnsplitBuffer unsplit(const char* delimiter, OutputBuffer* outputBuffer) {
 template <class... Targets>
 detail::Map<detail::SplitTo<std::tuple<Targets...>, char, Targets...>>
 eachToTuple(char delim) {
-  return detail::Map<
-    detail::SplitTo<std::tuple<Targets...>, char, Targets...>>(
-    detail::SplitTo<std::tuple<Targets...>, char, Targets...>(delim));
+  return detail::Map<detail::SplitTo<std::tuple<Targets...>, char, Targets...>>(
+      detail::SplitTo<std::tuple<Targets...>, char, Targets...>(delim));
 }
 
 template <class... Targets>
 detail::Map<detail::SplitTo<std::tuple<Targets...>, fbstring, Targets...>>
 eachToTuple(StringPiece delim) {
   return detail::Map<
-    detail::SplitTo<std::tuple<Targets...>, fbstring, Targets...>>(
-    detail::SplitTo<std::tuple<Targets...>, fbstring, Targets...>(delim));
+      detail::SplitTo<std::tuple<Targets...>, fbstring, Targets...>>(
+      detail::SplitTo<std::tuple<Targets...>, fbstring, Targets...>(delim));
 }
 
 template <class First, class Second>
 detail::Map<detail::SplitTo<std::pair<First, Second>, char, First, Second>>
 eachToPair(char delim) {
   return detail::Map<
-    detail::SplitTo<std::pair<First, Second>, char, First, Second>>(
-    detail::SplitTo<std::pair<First, Second>, char, First, Second>(delim));
+      detail::SplitTo<std::pair<First, Second>, char, First, Second>>(
+      detail::SplitTo<std::pair<First, Second>, char, First, Second>(delim));
 }
 
 template <class First, class Second>
 detail::Map<detail::SplitTo<std::pair<First, Second>, fbstring, First, Second>>
 eachToPair(StringPiece delim) {
   return detail::Map<
-    detail::SplitTo<std::pair<First, Second>, fbstring, First, Second>>(
-    detail::SplitTo<std::pair<First, Second>, fbstring, First, Second>(
-      to<fbstring>(delim)));
+      detail::SplitTo<std::pair<First, Second>, fbstring, First, Second>>(
+      detail::SplitTo<std::pair<First, Second>, fbstring, First, Second>(
+          to<fbstring>(delim)));
 }
 
 /**
@@ -196,12 +194,12 @@ eachToPair(StringPiece delim) {
  */
 template <class Callback>
 class StreamSplitter {
-
  public:
-  StreamSplitter(char delimiter,
-                 Callback&& pieceCb,
-                 uint64_t maxLength = 0,
-                 uint64_t initialCapacity = 0)
+  StreamSplitter(
+      char delimiter,
+      Callback&& pieceCb,
+      uint64_t maxLength = 0,
+      uint64_t initialCapacity = 0)
       : buffer_(IOBuf::CREATE, initialCapacity),
         delimiter_(delimiter),
         maxLength_(maxLength),
@@ -232,14 +230,13 @@ class StreamSplitter {
   // Holds the current "incomplete" chunk so that chunks can span calls to ()
   IOBuf buffer_;
   char delimiter_;
-  uint64_t maxLength_;  // The callback never gets more chars than this
+  uint64_t maxLength_; // The callback never gets more chars than this
   Callback pieceCb_;
 };
 
-template <class Callback>  // Helper to enable template deduction
-StreamSplitter<Callback> streamSplitter(char delimiter,
-                                        Callback&& pieceCb,
-                                        uint64_t capacity = 0) {
+template <class Callback> // Helper to enable template deduction
+StreamSplitter<Callback>
+streamSplitter(char delimiter, Callback&& pieceCb, uint64_t capacity = 0) {
   return StreamSplitter<Callback>(delimiter, std::move(pieceCb), capacity);
 }
 

folly/gen/test/BaseBenchmark.cpp

@@ -25,10 +25,11 @@ using namespace folly::gen;
 using folly::fbstring;
 using std::pair;
 using std::set;
-using std::vector;
 using std::tuple;
+using std::vector;
 
 static std::atomic<int> testSize(1000);
+// clang-format off
 static vector<int> testVector =
     seq(1, testSize.load())
   | mapped([](int) { return rand(); })
@@ -44,6 +45,7 @@ static vector<fbstring> strings =
     from(testVector)
   | eachTo<fbstring>()
   | as<vector>();
+// clang-format on
 
 auto square = [](int x) { return x * x; };
 
@@ -91,20 +93,24 @@ BENCHMARK_DRAW_LINE();
 
 BENCHMARK(Member, iters) {
   int s = 0;
-  while(iters--) {
+  while (iters--) {
+    // clang-format off
     s += from(strings)
        | member(&fbstring::size)
        | sum;
+    // clang-format on
   }
   folly::doNotOptimizeAway(s);
 }
 
 BENCHMARK_RELATIVE(MapMember, iters) {
   int s = 0;
-  while(iters--) {
+  while (iters--) {
+    // clang-format off
     s += from(strings)
        | map([](const fbstring& x) { return x.size(); })
        | sum;
+    // clang-format on
   }
   folly::doNotOptimizeAway(s);
 }
@@ -126,11 +132,13 @@ BENCHMARK(Count_Vector_NoGen, iters) {
 BENCHMARK_RELATIVE(Count_Vector_Gen, iters) {
   int s = 0;
   while (iters--) {
+    // clang-format off
     s += from(testVector)
        | filter([](int i) {
                   return i * 2 < rand();
                 })
        | count;
+    // clang-format on
   }
   folly::doNotOptimizeAway(s);
 }
@@ -356,7 +364,7 @@ BENCHMARK(Sample, iters) {
 // Sample                                                     176.48ms     5.67
 // ============================================================================
 
-int main(int argc, char *argv[]) {
+int main(int argc, char* argv[]) {
   gflags::ParseCommandLineFlags(&argc, &argv, true);
   folly::runBenchmarks();
   return 0;

folly/gen/test/Bench.h

@@ -18,15 +18,18 @@
 
 #include <folly/Benchmark.h>
 
-#define BENCH_GEN_IMPL(gen, prefix)                         \
-static bool FB_ANONYMOUS_VARIABLE(benchGen) = (             \
-  ::folly::addBenchmark(__FILE__, prefix FB_STRINGIZE(gen), \
-    [](unsigned iters){                                     \
-      const unsigned num = iters;                           \
-      while (iters--) {                                     \
-        folly::doNotOptimizeAway(gen);                      \
-      }                                                     \
-      return num;                                           \
-    }), true)
+#define BENCH_GEN_IMPL(gen, prefix)             \
+  static bool FB_ANONYMOUS_VARIABLE(benchGen) = \
+      (::folly::addBenchmark(                   \
+           __FILE__,                            \
+           prefix FB_STRINGIZE(gen),            \
+           [](unsigned iters) {                 \
+             const unsigned num = iters;        \
+             while (iters--) {                  \
+               folly::doNotOptimizeAway(gen);   \
+             }                                  \
+             return num;                        \
+           }),                                  \
+       true)
 #define BENCH_GEN(gen) BENCH_GEN_IMPL(gen, "")
 #define BENCH_GEN_REL(gen) BENCH_GEN_IMPL(gen, "%")

folly/gen/test/CombineTest.cpp

@@ -26,11 +26,10 @@
 using namespace folly::gen;
 using namespace folly;
 using std::string;
-using std::vector;
 using std::tuple;
+using std::vector;
 
-const folly::gen::detail::Map<
-  folly::gen::detail::MergeTuples> gTupleFlatten{};
+const folly::gen::detail::Map<folly::gen::detail::MergeTuples> gTupleFlatten{};
 
 auto even = [](int i) -> bool { return i % 2 == 0; };
 auto odd = [](int i) -> bool { return i % 2 == 1; };
@@ -46,8 +45,7 @@ TEST(CombineGen, Interleave) {
     auto base = seq(1) | filter(odd) | take(3);
     auto toInterleave = seq(1) | filter(even) | take(50);
     auto interleaved = base | interleave(toInterleave | as<vector>());
-    EXPECT_EQ(interleaved | as<vector>(),
-              vector<int>({1, 2, 3, 4, 5, 6}));
+    EXPECT_EQ(interleaved | as<vector>(), vector<int>({1, 2, 3, 4, 5, 6}));
   }
 }
 
@@ -56,9 +54,7 @@ TEST(CombineGen, Zip) {
   // We rely on std::move(fbvector) emptying the source vector
   auto zippee = fbvector<string>{"one", "two", "three"};
   {
-    auto combined = base0
-      | zip(zippee)
-      | as<vector>();
+    auto combined = base0 | zip(zippee) | as<vector>();
     ASSERT_EQ(combined.size(), 3);
     EXPECT_EQ(std::get<0>(combined[0]), 1);
     EXPECT_EQ(std::get<1>(combined[0]), "one");
@@ -67,13 +63,11 @@ TEST(CombineGen, Zip) {
     EXPECT_EQ(std::get<0>(combined[2]), 3);
     EXPECT_EQ(std::get<1>(combined[2]), "three");
     ASSERT_FALSE(zippee.empty());
-    EXPECT_FALSE(zippee.front().empty());  // shouldn't have been move'd
+    EXPECT_FALSE(zippee.front().empty()); // shouldn't have been move'd
   }
 
   { // same as top, but using std::move.
-    auto combined = base0
-      | zip(std::move(zippee))
-      | as<vector>();
+    auto combined = base0 | zip(std::move(zippee)) | as<vector>();
     ASSERT_EQ(combined.size(), 3);
     EXPECT_EQ(std::get<0>(combined[0]), 1);
     EXPECT_TRUE(zippee.empty());
@@ -81,9 +75,8 @@ TEST(CombineGen, Zip) {
 
   { // same as top, but base is truncated
     auto baseFinite = seq(1) | take(1);
-    auto combined = baseFinite
-      | zip(vector<string>{"one", "two", "three"})
-      | as<vector>();
+    auto combined =
+        baseFinite | zip(vector<string>{"one", "two", "three"}) | as<vector>();
     ASSERT_EQ(combined.size(), 1);
     EXPECT_EQ(std::get<0>(combined[0]), 1);
     EXPECT_EQ(std::get<1>(combined[0]), "one");
@@ -91,66 +84,77 @@ TEST(CombineGen, Zip) {
 }
 
 TEST(CombineGen, TupleFlatten) {
-  vector<tuple<int,string>> intStringTupleVec{
-    tuple<int,string>{1, "1"},
-    tuple<int,string>{2, "2"},
-    tuple<int,string>{3, "3"},
+  vector<tuple<int, string>> intStringTupleVec{
+      tuple<int, string>{1, "1"},
+      tuple<int, string>{2, "2"},
+      tuple<int, string>{3, "3"},
   };
 
   vector<tuple<char>> charTupleVec{
-    tuple<char>{'A'},
-    tuple<char>{'B'},
-    tuple<char>{'C'},
-    tuple<char>{'D'},
+      tuple<char>{'A'},
+      tuple<char>{'B'},
+      tuple<char>{'C'},
+      tuple<char>{'D'},
   };
 
   vector<double> doubleVec{
-    1.0,
-    4.0,
-    9.0,
-    16.0,
-    25.0,
+      1.0,
+      4.0,
+      9.0,
+      16.0,
+      25.0,
   };
 
+  // clang-format off
   auto zipped1 = from(intStringTupleVec)
     | zip(charTupleVec)
     | assert_type<tuple<tuple<int, string>, tuple<char>>>()
     | as<vector>();
+  // clang-format on
   EXPECT_EQ(std::get<0>(zipped1[0]), std::make_tuple(1, "1"));
   EXPECT_EQ(std::get<1>(zipped1[0]), std::make_tuple('A'));
 
+  // clang-format off
   auto zipped2 = from(zipped1)
     | gTupleFlatten
     | assert_type<tuple<int, string, char>&&>()
     | as<vector>();
+  // clang-format on
   ASSERT_EQ(zipped2.size(), 3);
   EXPECT_EQ(zipped2[0], std::make_tuple(1, "1", 'A'));
 
+  // clang-format off
   auto zipped3 = from(charTupleVec)
     | zip(intStringTupleVec)
     | gTupleFlatten
     | assert_type<tuple<char, int, string>&&>()
     | as<vector>();
+  // clang-format on
   ASSERT_EQ(zipped3.size(), 3);
   EXPECT_EQ(zipped3[0], std::make_tuple('A', 1, "1"));
 
+  // clang-format off
   auto zipped4 = from(intStringTupleVec)
     | zip(doubleVec)
     | gTupleFlatten
     | assert_type<tuple<int, string, double>&&>()
     | as<vector>();
+  // clang-format on
   ASSERT_EQ(zipped4.size(), 3);
   EXPECT_EQ(zipped4[0], std::make_tuple(1, "1", 1.0));
 
+  // clang-format off
   auto zipped5 = from(doubleVec)
     | zip(doubleVec)
     | assert_type<tuple<double, double>>()
     | gTupleFlatten  // essentially a no-op
     | assert_type<tuple<double, double>&&>()
     | as<vector>();
+  // clang-format on
   ASSERT_EQ(zipped5.size(), 5);
   EXPECT_EQ(zipped5[0], std::make_tuple(1.0, 1.0));
 
+  // clang-format off
   auto zipped6 = from(intStringTupleVec)
     | zip(charTupleVec)
     | gTupleFlatten
@@ -158,11 +162,12 @@ TEST(CombineGen, TupleFlatten) {
     | gTupleFlatten
     | assert_type<tuple<int, string, char, double>&&>()
     | as<vector>();
+  // clang-format on
   ASSERT_EQ(zipped6.size(), 3);
   EXPECT_EQ(zipped6[0], std::make_tuple(1, "1", 'A', 1.0));
 }
 
-int main(int argc, char *argv[]) {
+int main(int argc, char* argv[]) {
   testing::InitGoogleTest(&argc, argv);
   gflags::ParseCommandLineFlags(&argc, &argv, true);
   return RUN_ALL_TESTS();

folly/gen/test/FileBenchmark.cpp

@@ -36,7 +36,7 @@ BENCHMARK(ByLine_Pipes, iters) {
     wfd = p[1];
     thread = std::thread([wfd, iters] {
       char x = 'x';
-      PCHECK(::write(wfd, &x, 1) == 1);  // signal startup
+      PCHECK(::write(wfd, &x, 1) == 1); // signal startup
       FILE* f = fdopen(wfd, "w");
       PCHECK(f);
       for (size_t i = 1; i <= iters; ++i) {
@@ -45,7 +45,7 @@ BENCHMARK(ByLine_Pipes, iters) {
       fclose(f);
     });
     char buf;
-    PCHECK(::read(rfd, &buf, 1) == 1);  // wait for startup
+    PCHECK(::read(rfd, &buf, 1) == 1); // wait for startup
   }
 
   CHECK_ERR(rfd);
@@ -66,7 +66,7 @@ BENCHMARK(ByLine_Pipes, iters) {
 // ByLine_Pipes                                               148.63ns    6.73M
 // ============================================================================
 
-int main(int argc, char *argv[]) {
+int main(int argc, char* argv[]) {
   gflags::ParseCommandLineFlags(&argc, &argv, true);
   folly::runBenchmarks();
   return 0;

folly/gen/test/FileTest.cpp

@@ -58,8 +58,8 @@ TEST(FileGen, ByLine) {
 }
 
 TEST(FileGen, ByLineFull) {
-  auto cases = std::vector<std::string> {
-       stripLeftMargin(R"(
+  auto cases = std::vector<std::string>{
+      stripLeftMargin(R"(
          Hello world
          This is the second line
 
@@ -67,11 +67,12 @@ TEST(FileGen, ByLineFull) {
          a few empty lines above
          incomplete last line)"),
 
-         "complete last line\n",
+      "complete last line\n",
 
-         "\n",
+      "\n",
 
-         ""};
+      "",
+  };
 
   for (auto& lines : cases) {
     test::TemporaryFile file("ByLineFull");
@@ -113,8 +114,9 @@ TEST(FileGenBufferedTest, FileWriterSimple) {
 
   auto squares = seq(1, 100) | map([](int x) { return x * x; });
   squares | map(toLine) | eachAs<StringPiece>() | toFile(File(file.fd()));
-  EXPECT_EQ(squares | sum,
-            byLine(File(file.path().string().c_str())) | eachTo<int>() | sum);
+  EXPECT_EQ(
+      squares | sum,
+      byLine(File(file.path().string().c_str())) | eachTo<int>() | sum);
 }
 
 INSTANTIATE_TEST_CASE_P(

folly/gen/test/ParallelBenchmark.cpp

@@ -25,17 +25,18 @@
 #include <folly/gen/Parallel.h>
 #include <folly/gen/test/Bench.h>
 
-
-DEFINE_int32(threads,
-             std::max(1, (int32_t) sysconf(_SC_NPROCESSORS_CONF) / 2),
-             "Num threads.");
+DEFINE_int32(
+    threads,
+    std::max(1, (int32_t)sysconf(_SC_NPROCESSORS_CONF) / 2),
+    "Num threads.");
 
 using namespace folly::gen;
 using std::vector;
 
-
-constexpr int kFib = 28;  // unit of work
-size_t fib(int n) { return n <= 1 ? 1 : fib(n - 1) + fib(n - 2); }
+constexpr int kFib = 28; // unit of work
+size_t fib(int n) {
+  return n <= 1 ? 1 : fib(n - 1) + fib(n - 2);
+}
 
 static auto isPrimeSlow = [](int n) {
   if (n < 2) {
@@ -50,8 +51,7 @@ static auto isPrimeSlow = [](int n) {
   return true;
 };
 
-static auto primes =
-    seq(1, 1 << 20) | filter(isPrimeSlow) | as<vector>();
+static auto primes = seq(1, 1 << 20) | filter(isPrimeSlow) | as<vector>();
 
 static auto stopc(int n) {
   return [=](int d) { return d * d > n; };
@@ -78,9 +78,7 @@ static auto sleepyWork = [](int i) {
   return i;
 };
 
-static auto sleepAndWork = [](int i) {
-  return factorsSlow(i) + sleepyWork(i);
-};
+static auto sleepAndWork = [](int i) { return factorsSlow(i) + sleepyWork(i); };
 
 auto start = 1 << 20;
 auto v = seq(start) | take(1 << 20) | as<vector>();
@@ -116,19 +114,26 @@ BENCHMARK_DRAW_LINE();
 
 const int fibs = 1000;
 BENCH_GEN(seq(1, fibs) | map([](int) { return fib(kFib); }) | sum);
-BENCH_GEN_REL(seq(1, fibs) |
-              parallel(map([](int) { return fib(kFib); }) | sub(sum)) | sum);
+// clang-format off
+BENCH_GEN_REL(
+    seq(1, fibs)
+      | parallel(map([](int) { return fib(kFib); }) | sub(sum))
+      | sum);
+// clang-format on
 BENCH_GEN_REL([] {
+  // clang-format off
   auto threads = seq(1, int(FLAGS_threads))
-               | map([](int i) {
-                   return std::thread([=] {
-                     return range((i + 0) * fibs / FLAGS_threads,
-                                  (i + 1) * fibs / FLAGS_threads) |
-                            map([](int) { return fib(kFib); }) | sum;
-                   });
-                 })
-               | as<vector>();
+      | map([](int i) {
+        return std::thread([=] {
+          return range(
+              (i + 0) * fibs / FLAGS_threads, (i + 1) * fibs / FLAGS_threads)
+              | map([](int) { return fib(kFib); })
+              | sum;
+        });
+      })
+      | as<vector>();
   from(threads) | [](std::thread &thread) { thread.join(); };
+  // clang-format on
   return 1;
 }());
 BENCHMARK_DRAW_LINE();
@@ -160,7 +165,7 @@ seq(1, fibs) | parallel(map([](int) { return fi 1698.07%    87.96ms    11.37
 ----------------------------------------------------------------------------
 ============================================================================
 #endif
-int main(int argc, char *argv[]) {
+int main(int argc, char* argv[]) {
   gflags::ParseCommandLineFlags(&argc, &argv, true);
   folly::runBenchmarks();
   return 0;

folly/gen/test/ParallelMapBenchmark.cpp

@@ -26,18 +26,18 @@
 
 using namespace folly::gen;
 
-DEFINE_int32(threads,
-             std::max(1, (int32_t) sysconf(_SC_NPROCESSORS_CONF) / 2),
-             "Num threads.");
+DEFINE_int32(
+    threads,
+    std::max(1, (int32_t)sysconf(_SC_NPROCESSORS_CONF) / 2),
+    "Num threads.");
 
-constexpr int kFib = 35;  // unit of work
-size_t fib(int n) { return n <= 1 ? 1 : fib(n-1) * fib(n-2); }
+constexpr int kFib = 35; // unit of work
+size_t fib(int n) {
+  return n <= 1 ? 1 : fib(n - 1) * fib(n - 2);
+}
 
 BENCHMARK(FibSumMap, n) {
-  auto result =
-    seq(1, (int) n)
-    | map([](int) { return fib(kFib); })
-    | sum;
+  auto result = seq(1, (int)n) | map([](int) { return fib(kFib); }) | sum;
   folly::doNotOptimizeAway(result);
 }
 
@@ -45,10 +45,12 @@ BENCHMARK_RELATIVE(FibSumPmap, n) {
   // Schedule more work: enough so that each worker thread does the
   // same amount as one FibSumMap.
   const size_t kNumThreads = FLAGS_threads;
+  // clang-format off
   auto result =
-    seq(1, (int) (n * kNumThreads))
+    seq(1, (int)(n * kNumThreads))
     | pmap([](int) { return fib(kFib); }, kNumThreads)
     | sum;
+  // clang-format on
   folly::doNotOptimizeAway(result);
 }
 
@@ -58,16 +60,15 @@ BENCHMARK_RELATIVE(FibSumThreads, n) {
   std::vector<std::thread> workers;
   workers.reserve(kNumThreads);
   auto fn = [n] {
-    auto result =
-      seq(1, (int) n)
-      | map([](int) { return fib(kFib); })
-      | sum;
+    auto result = seq(1, (int)n) | map([](int) { return fib(kFib); }) | sum;
     folly::doNotOptimizeAway(result);
   };
   for (size_t i = 0; i < kNumThreads; i++) {
     workers.push_back(std::thread(fn));
   }
-  for (auto& w : workers) { w.join(); }
+  for (auto& w : workers) {
+    w.join();
+  }
 }
 
 /*
@@ -84,7 +85,7 @@ BENCHMARK_RELATIVE(FibSumThreads, n) {
   sys0m0.016s
 */
 
-int main(int argc, char *argv[]) {
+int main(int argc, char* argv[]) {
   gflags::ParseCommandLineFlags(&argc, &argv, true);
   folly::runBenchmarks();
   return 0;

folly/gen/test/ParallelMapTest.cpp

@@ -29,6 +29,7 @@ using namespace folly::gen;
 TEST(Pmap, InfiniteEquivalent) {
   // apply
   {
+    // clang-format off
     auto mapResult
       = seq(1)
       | map([](int x) { return x * x; })
@@ -40,12 +41,14 @@ TEST(Pmap, InfiniteEquivalent) {
       | pmap([](int x) { return x * x; }, 4)
       | until([](int x) { return x > 1000 * 1000; })
       | as<std::vector<int>>();
+    // clang-format on
 
     EXPECT_EQ(pmapResult, mapResult);
   }
 
   // foreach
   {
+    // clang-format off
     auto mapResult
       = seq(1, 10)
       | map([](int x) { return x * x; })
@@ -55,6 +58,7 @@ TEST(Pmap, InfiniteEquivalent) {
       = seq(1, 10)
       | pmap([](int x) { return x * x; }, 4)
       | as<std::vector<int>>();
+    // clang-format on
 
     EXPECT_EQ(pmapResult, mapResult);
   }
@@ -63,6 +67,7 @@ TEST(Pmap, InfiniteEquivalent) {
 TEST(Pmap, Empty) {
   // apply
   {
+    // clang-format off
     auto mapResult
       = seq(1)
       | map([](int x) { return x * x; })
@@ -74,6 +79,7 @@ TEST(Pmap, Empty) {
       | pmap([](int x) { return x * x; }, 4)
       | until([](int) { return true; })
       | as<std::vector<int>>();
+    // clang-format on
 
     EXPECT_EQ(mapResult.size(), 0);
     EXPECT_EQ(pmapResult, mapResult);
@@ -81,6 +87,7 @@ TEST(Pmap, Empty) {
 
   // foreach
   {
+    // clang-format off
     auto mapResult
       = empty<int>()
       | map([](int x) { return x * x; })
@@ -90,6 +97,7 @@ TEST(Pmap, Empty) {
       = empty<int>()
       | pmap([](int x) { return x * x; }, 4)
       | as<std::vector<int>>();
+    // clang-format on
 
     EXPECT_EQ(mapResult.size(), 0);
     EXPECT_EQ(pmapResult, mapResult);
@@ -99,6 +107,7 @@ TEST(Pmap, Empty) {
 TEST(Pmap, Rvalues) {
   // apply
   {
+    // clang-format off
     auto mapResult
         = seq(1)
         | map([](int x) { return std::make_unique<int>(x); })
@@ -116,12 +125,14 @@ TEST(Pmap, Rvalues) {
         | pmap([](std::unique_ptr<int> x) { return *x; })
         | take(1000)
         | sum;
+    // clang-format on
 
     EXPECT_EQ(pmapResult, mapResult);
   }
 
   // foreach
   {
+    // clang-format off
     auto mapResult
         = seq(1, 1000)
         | map([](int x) { return std::make_unique<int>(x); })
@@ -137,12 +148,13 @@ TEST(Pmap, Rvalues) {
             return std::make_unique<int>(*x * *x); })
         | pmap([](std::unique_ptr<int> x) { return *x; })
         | sum;
+    // clang-format on
 
     EXPECT_EQ(pmapResult, mapResult);
   }
 }
 
-int main(int argc, char *argv[]) {
+int main(int argc, char* argv[]) {
   testing::InitGoogleTest(&argc, argv);
   gflags::ParseCommandLineFlags(&argc, &argv, true);
   return RUN_ALL_TESTS();

folly/gen/test/ParallelTest.cpp

@@ -57,55 +57,55 @@ struct {
   }
 } makeUnique;
 
-static auto primes = seq(1, 1 << 14)
-                   | filter(isPrime)
-                   | as<vector<size_t>>();
+static auto primes = seq(1, 1 << 14) | filter(isPrime) | as<vector<size_t>>();
 
 static auto primeFactors = [](int n) {
-  return from(primes)
-       | filter([&](int d) { return 0 == n % d; })
-       | count;
+  return from(primes) | filter([&](int d) { return 0 == n % d; }) | count;
 };
 
 TEST(ParallelTest, Serial) {
   EXPECT_EQ(
-            seq(1,10) | map(square) | filter(even) | sum,
-            seq(1,10) | parallel(map(square) | filter(even)) | sum);
+      seq(1, 10) | map(square) | filter(even) | sum,
+      seq(1, 10) | parallel(map(square) | filter(even)) | sum);
 }
 
 auto heavyWork = map(primeFactors);
 
 TEST(ParallelTest, ComputeBound64) {
   int length = 1 << 10;
-  EXPECT_EQ(seq<size_t>(1, length) | heavyWork | sum,
-            seq<size_t>(1, length) | parallel(heavyWork) | sum);
+  EXPECT_EQ(
+      seq<size_t>(1, length) | heavyWork | sum,
+      seq<size_t>(1, length) | parallel(heavyWork) | sum);
 }
 
 TEST(ParallelTest, Take) {
   int length = 1 << 18;
   int limit = 1 << 14;
-  EXPECT_EQ(seq(1, length) | take(limit) | count,
-            seq(1, length) | parallel(heavyWork) | take(limit) | count);
+  EXPECT_EQ(
+      seq(1, length) | take(limit) | count,
+      seq(1, length) | parallel(heavyWork) | take(limit) | count);
 }
 
-
 TEST(ParallelTest, Unique) {
   auto uniqued = from(primes) | map(makeUnique) | as<vector>();
-  EXPECT_EQ(primes.size(),
-            from(primes) | parallel(map(makeUnique)) |
-                parallel(dereference | map(makeUnique)) | dereference | count);
-  EXPECT_EQ(2,
-            from(primes) | parallel(map(makeUnique)) |
-                parallel(dereference | map(makeUnique)) | dereference |
-                take(2) | count);
+  EXPECT_EQ(
+      primes.size(),
+      from(primes) | parallel(map(makeUnique)) |
+          parallel(dereference | map(makeUnique)) | dereference | count);
+  EXPECT_EQ(
+      2,
+      from(primes) | parallel(map(makeUnique)) |
+          parallel(dereference | map(makeUnique)) | dereference | take(2) |
+          count);
 }
 
 TEST(ParallelTest, PSum) {
-  EXPECT_EQ(from(primes) | map(sleepyWork) | sum,
-            from(primes) | parallel(map(sleepyWork) | sub(sum)) | sum);
+  EXPECT_EQ(
+      from(primes) | map(sleepyWork) | sum,
+      from(primes) | parallel(map(sleepyWork) | sub(sum)) | sum);
 }
 
-int main(int argc, char *argv[]) {
+int main(int argc, char* argv[]) {
   testing::InitGoogleTest(&argc, argv);
   gflags::ParseCommandLineFlags(&argc, &argv, true);
   return RUN_ALL_TESTS();

folly/gen/test/StringBenchmark.cpp

@@ -28,16 +28,14 @@ using namespace folly;
 using namespace folly::gen;
 using std::pair;
 using std::set;
-using std::vector;
 using std::tuple;
+using std::vector;
 
 namespace {
 
 static std::atomic<int> testSize(1000);
-static vector<fbstring> testStrVector
-  = seq(1, testSize.load())
-  | eachTo<fbstring>()
-  | as<vector>();
+static vector<fbstring> testStrVector =
+    seq(1, testSize.load()) | eachTo<fbstring>() | as<vector>();
 static auto testFileContent = from(testStrVector) | unsplit('\n');
 
 const char* const kLine = "The quick brown fox jumped over the lazy dog.\n";
@@ -61,7 +59,9 @@ void initStringResplitterBenchmark() {
   }
 }
 
-size_t len(folly::StringPiece s) { return s.size(); }
+size_t len(folly::StringPiece s) {
+  return s.size();
+}
 
 } // namespace
 
@@ -94,7 +94,6 @@ BENCHMARK(StringSplit_Old, iters) {
   folly::doNotOptimizeAway(s);
 }
 
-
 BENCHMARK_RELATIVE(StringSplit_Gen_Vector, iters) {
   size_t s = 0;
   StringPiece line(kLine);
@@ -196,9 +195,7 @@ BENCHMARK_DRAW_LINE();
 void StringUnsplit_Gen(size_t iters, size_t joinSize) {
   std::vector<fbstring> v;
   BENCHMARK_SUSPEND {
-    FOR_EACH_RANGE (i, 0, joinSize) {
-      v.push_back(to<fbstring>(rand()));
-    }
+    FOR_EACH_RANGE (i, 0, joinSize) { v.push_back(to<fbstring>(rand())); }
   }
   size_t s = 0;
   fbstring buffer;
@@ -231,20 +228,23 @@ BENCHMARK_RELATIVE_PARAM(Lines_Gen, 3e3)
 
 BENCHMARK_DRAW_LINE();
 
-fbstring records
-= seq<size_t>(1, 1000)
-  | mapped([](size_t i) {
+// clang-format off
+fbstring records = seq<size_t>(1, 1000)
+    | mapped([](size_t i) {
       return folly::to<fbstring>(i, ' ', i * i, ' ', i * i * i);
     })
-  | unsplit('\n');
+    | unsplit('\n');
+// clang-format o
 
 BENCHMARK(Records_EachToTuple, iters) {
   size_t s = 0;
   for (size_t i = 0; i < iters; i += 1000) {
+    // clang-format off
     s += split(records, '\n')
-       | eachToTuple<int, size_t, StringPiece>(' ')
-       | get<1>()
-       | sum;
+        | eachToTuple<int, size_t, StringPiece>(' ')
+        | get<1>()
+        | sum;
+    // clang-format on
   }
   folly::doNotOptimizeAway(s);
 }
@@ -253,18 +253,20 @@ BENCHMARK_RELATIVE(Records_VectorStringPieceReused, iters) {
   size_t s = 0;
   std::vector<StringPiece> fields;
   for (size_t i = 0; i < iters; i += 1000) {
+    // clang-format off
     s += split(records, '\n')
-       | mapped([&](StringPiece line) {
-           fields.clear();
-           folly::split(' ', line, fields);
-           CHECK(fields.size() == 3);
-           return std::make_tuple(
-             folly::to<int>(fields[0]),
-             folly::to<size_t>(fields[1]),
-             StringPiece(fields[2]));
-         })
-       | get<1>()
-       | sum;
+        | mapped([&](StringPiece line) {
+          fields.clear();
+          folly::split(' ', line, fields);
+          CHECK(fields.size() == 3);
+          return std::make_tuple(
+              folly::to<int>(fields[0]),
+              folly::to<size_t>(fields[1]),
+              StringPiece(fields[2]));
+        })
+        | get<1>()
+        | sum;
+    // clang-format on
   }
   folly::doNotOptimizeAway(s);
 }
@@ -272,18 +274,20 @@ BENCHMARK_RELATIVE(Records_VectorStringPieceReused, iters) {
 BENCHMARK_RELATIVE(Records_VectorStringPiece, iters) {
   size_t s = 0;
   for (size_t i = 0; i < iters; i += 1000) {
+    // clang-format off
     s += split(records, '\n')
-       | mapped([](StringPiece line) {
-           std::vector<StringPiece> fields;
-           folly::split(' ', line, fields);
-           CHECK(fields.size() == 3);
-           return std::make_tuple(
-             folly::to<int>(fields[0]),
-             folly::to<size_t>(fields[1]),
-             StringPiece(fields[2]));
-         })
-       | get<1>()
-       | sum;
+        | mapped([](StringPiece line) {
+          std::vector<StringPiece> fields;
+          folly::split(' ', line, fields);
+          CHECK(fields.size() == 3);
+          return std::make_tuple(
+              folly::to<int>(fields[0]),
+              folly::to<size_t>(fields[1]),
+              StringPiece(fields[2]));
+        })
+        | get<1>()
+        | sum;
+    // clang-format on
   }
   folly::doNotOptimizeAway(s);
 }
@@ -291,18 +295,20 @@ BENCHMARK_RELATIVE(Records_VectorStringPiece, iters) {
 BENCHMARK_RELATIVE(Records_VectorString, iters) {
   size_t s = 0;
   for (size_t i = 0; i < iters; i += 1000) {
+    // clang-format off
     s += split(records, '\n')
-       | mapped([](StringPiece line) {
-           std::vector<std::string> fields;
-           folly::split(' ', line, fields);
-           CHECK(fields.size() == 3);
-           return std::make_tuple(
-             folly::to<int>(fields[0]),
-             folly::to<size_t>(fields[1]),
-             StringPiece(fields[2]));
-         })
-       | get<1>()
-       | sum;
+        | mapped([](StringPiece line) {
+          std::vector<std::string> fields;
+          folly::split(' ', line, fields);
+          CHECK(fields.size() == 3);
+          return std::make_tuple(
+              folly::to<int>(fields[0]),
+              folly::to<size_t>(fields[1]),
+              StringPiece(fields[2]));
+        })
+        | get<1>()
+        | sum;
+    // clang-format on
   }
   folly::doNotOptimizeAway(s);
 }
@@ -338,7 +344,7 @@ BENCHMARK_RELATIVE(Records_VectorString, iters) {
 // Records_VectorString                              16.70%   607.47us    1.65K
 // ============================================================================
 
-int main(int argc, char *argv[]) {
+int main(int argc, char* argv[]) {
   gflags::ParseCommandLineFlags(&argc, &argv, true);
   initStringResplitterBenchmark();
   runBenchmarks();

folly/gen/test/StringTest.cpp

@@ -149,69 +149,83 @@ TEST(StringGen, ResplitKeepDelimiter) {
 TEST(StringGen, EachToTuple) {
   {
     auto lines = "2:1.414:yo 3:1.732:hi";
+    // clang-format off
     auto actual
       = split(lines, ' ')
       | eachToTuple<int, double, std::string>(':')
       | as<vector>();
-    vector<tuple<int, double, std::string>> expected {
-      make_tuple(2, 1.414, "yo"),
-      make_tuple(3, 1.732, "hi"),
+    // clang-format on
+    vector<tuple<int, double, std::string>> expected{
+        make_tuple(2, 1.414, "yo"),
+        make_tuple(3, 1.732, "hi"),
     };
     EXPECT_EQ(expected, actual);
   }
   {
     auto lines = "2 3";
+    // clang-format off
     auto actual
       = split(lines, ' ')
       | eachToTuple<int>(',')
       | as<vector>();
-    vector<tuple<int>> expected {
-      make_tuple(2),
-      make_tuple(3),
+    // clang-format on
+    vector<tuple<int>> expected{
+        make_tuple(2),
+        make_tuple(3),
     };
     EXPECT_EQ(expected, actual);
   }
   {
     // StringPiece target
     auto lines = "1:cat 2:dog";
+    // clang-format off
     auto actual
       = split(lines, ' ')
       | eachToTuple<int, StringPiece>(':')
       | as<vector>();
-    vector<tuple<int, StringPiece>> expected {
-      make_tuple(1, "cat"),
-      make_tuple(2, "dog"),
+    // clang-format on
+    vector<tuple<int, StringPiece>> expected{
+        make_tuple(1, "cat"),
+        make_tuple(2, "dog"),
     };
     EXPECT_EQ(expected, actual);
   }
   {
     // Empty field
     auto lines = "2:tjackson:4 3::5";
+    // clang-format off
     auto actual
       = split(lines, ' ')
       | eachToTuple<int, fbstring, int>(':')
       | as<vector>();
-    vector<tuple<int, fbstring, int>> expected {
-      make_tuple(2, "tjackson", 4),
-      make_tuple(3, "", 5),
+    // clang-format on
+    vector<tuple<int, fbstring, int>> expected{
+        make_tuple(2, "tjackson", 4),
+        make_tuple(3, "", 5),
     };
     EXPECT_EQ(expected, actual);
   }
   {
     // Excess fields
     auto lines = "1:2 3:4:5";
-    EXPECT_THROW((split(lines, ' ')
-                    | eachToTuple<int, int>(':')
-                    | as<vector>()),
-                 std::runtime_error);
+    // clang-format off
+    EXPECT_THROW(
+        (split(lines, ' ')
+          | eachToTuple<int, int>(':')
+          | as<vector>()),
+        std::runtime_error);
+    // clang-format on
   }
   {
     // Missing fields
     auto lines = "1:2:3 4:5";
-    EXPECT_THROW((split(lines, ' ')
-                    | eachToTuple<int, int, int>(':')
-                    | as<vector>()),
-                 std::runtime_error);
+    // clang-format off
+    EXPECT_THROW(
+        (split(lines, ' ')
+          | eachToTuple<int, int, int>(':')
+          | as<vector>()),
+        std::runtime_error);
+    // clang-format on
   }
 }
 
@@ -219,40 +233,48 @@ TEST(StringGen, EachToPair) {
   {
     // char delimiters
     auto lines = "2:1.414 3:1.732";
+    // clang-format off
     auto actual
       = split(lines, ' ')
       | eachToPair<int, double>(':')
       | as<std::map<int, double>>();
-    std::map<int, double> expected {
-      { 3, 1.732 },
-      { 2, 1.414 },
+    // clang-format on
+    std::map<int, double> expected{
+        {3, 1.732},
+        {2, 1.414},
     };
     EXPECT_EQ(expected, actual);
   }
   {
     // string delimiters
     auto lines = "ab=>cd ef=>gh";
+    // clang-format off
     auto actual
       = split(lines, ' ')
       | eachToPair<string, string>("=>")
       | as<std::map<string, string>>();
-    std::map<string, string> expected {
-      { "ab", "cd" },
-      { "ef", "gh" },
+    // clang-format on
+    std::map<string, string> expected{
+        {"ab", "cd"},
+        {"ef", "gh"},
     };
     EXPECT_EQ(expected, actual);
   }
 }
 
-void checkResplitMaxLength(vector<string> ins,
-                           char delim,
-                           uint64_t maxLength,
-                           vector<string> outs) {
+void checkResplitMaxLength(
+    vector<string> ins,
+    char delim,
+    uint64_t maxLength,
+    vector<string> outs) {
   vector<std::string> pieces;
-  auto splitter = streamSplitter(delim, [&pieces](StringPiece s) {
-    pieces.push_back(string(s.begin(), s.end()));
-    return true;
-  }, maxLength);
+  auto splitter = streamSplitter(
+      delim,
+      [&pieces](StringPiece s) {
+        pieces.push_back(string(s.begin(), s.end()));
+        return true;
+      },
+      maxLength);
   for (const auto& in : ins) {
     splitter(in);
   }
@@ -270,22 +292,21 @@ void checkResplitMaxLength(vector<string> ins,
 }
 
 TEST(StringGen, ResplitMaxLength) {
+  // clang-format off
   checkResplitMaxLength(
-    {"hel", "lo,", ", world", ", goodbye, m", "ew"}, ',', 5,
-    {"hello", ",", ",", " worl", "d,", " good", "bye,", " mew"}
-  );
+      {"hel", "lo,", ", world", ", goodbye, m", "ew"}, ',', 5,
+      {"hello", ",", ",", " worl", "d,", " good", "bye,", " mew"});
   // " meow" cannot be "end of stream", since it's maxLength long
   checkResplitMaxLength(
-    {"hel", "lo,", ", world", ", goodbye, m", "eow"}, ',', 5,
-    {"hello", ",", ",", " worl", "d,", " good", "bye,", " meow", ""}
-  );
+      {"hel", "lo,", ", world", ", goodbye, m", "eow"}, ',', 5,
+      {"hello", ",", ",", " worl", "d,", " good", "bye,", " meow", ""});
   checkResplitMaxLength(
-    {"||", "", "", "", "|a|b", "cdefghijklmn", "|opqrst",
-     "uvwx|y|||", "z", "0123456789", "|", ""}, '|', 2,
-    {"|", "|", "|", "a|", "bc", "de", "fg", "hi", "jk", "lm", "n|", "op", "qr",
-     "st", "uv", "wx", "|", "y|", "|", "|", "z0", "12", "34", "56", "78", "9|",
-     ""}
-  );
+      {"||", "", "", "", "|a|b", "cdefghijklmn", "|opqrst",
+       "uvwx|y|||", "z", "0123456789", "|", ""}, '|', 2,
+      {"|", "|", "|", "a|", "bc", "de", "fg", "hi", "jk", "lm", "n|", "op",
+       "qr", "st", "uv", "wx", "|", "y|", "|", "|", "z0", "12", "34", "56",
+       "78", "9|", ""});
+  // clang-format on
 }
 
 template <typename F>
@@ -299,7 +320,6 @@ void runUnsplitSuite(F fn) {
 }
 
 TEST(StringGen, Unsplit) {
-
   auto basicFn = [](StringPiece s) {
     EXPECT_EQ(split(s, ',') | unsplit(','), s);
   };
@@ -307,8 +327,7 @@ TEST(StringGen, Unsplit) {
   auto existingBuffer = [](StringPiece s) {
     folly::fbstring buffer("asdf");
     split(s, ',') | unsplit(',', &buffer);
-    auto expected = folly::to<folly::fbstring>(
-        "asdf", s.empty() ? "" : ",", s);
+    auto expected = folly::to<folly::fbstring>("asdf", s.empty() ? "" : ",", s);
     EXPECT_EQ(expected, buffer);
   };
 
@@ -334,16 +353,21 @@ TEST(StringGen, Unsplit) {
 
 TEST(StringGen, Batch) {
   std::vector<std::string> chunks{
-      "on", "e\nt", "w", "o", "\nthr", "ee\nfo", "ur\n",
-  };
-  std::vector<std::string> lines{
-      "one", "two", "three", "four",
-  };
+      "on", "e\nt", "w", "o", "\nthr", "ee\nfo", "ur\n"};
+  std::vector<std::string> lines{"one", "two", "three", "four"};
   EXPECT_EQ(4, from(chunks) | resplit('\n') | count);
   EXPECT_EQ(4, from(chunks) | resplit('\n') | batch(2) | rconcat | count);
   EXPECT_EQ(4, from(chunks) | resplit('\n') | batch(3) | rconcat | count);
-  EXPECT_EQ(lines, from(chunks) | resplit('\n') | eachTo<std::string>() |
-                       batch(3) | rconcat | as<vector>());
+  // clang-format off
+  EXPECT_EQ(
+      lines,
+      from(chunks)
+        | resplit('\n')
+        | eachTo<std::string>()
+        | batch(3)
+        | rconcat
+        | as<vector>());
+  // clang-format on
 }
 
 TEST(StringGen, UncurryTuple) {