fix: typo spelling grammar (#1638)

Summary:
## description
fix typo spelling grammar and replace to correct words

Pull Request resolved: https://github.com/facebook/folly/pull/1638

Reviewed By: yfeldblum

Differential Revision: D30577141

Pulled By: Orvid

fbshipit-source-id: 20c3f49fafcb6ca01a9419f5d71a2414dc7ea635

folly/ConstexprMath.h

@@ -240,7 +240,7 @@ constexpr T constexpr_sub_overflow_clamped(T a, T b) {
 //
 // Float NaNs are converted to 0 in integral type.
 //
-// Here's some comparision with static_cast<>:
+// Here's some comparison with static_cast<>:
 // (with FB-internal gcc-5-glibc-2.23 toolchain)
 //
 // static_cast<int32_t>(NaN) = 6
@@ -313,7 +313,7 @@ constexpr float kClampCastLowerBoundFloatToInt32F = -2147483520.0f;
 constexpr float kClampCastUpperBoundFloatToInt32F = 2147483520.0f;
 constexpr float kClampCastUpperBoundFloatToUInt32F = 4294967040.0f;
 
-// This works the same as constexpr_clamp, but the comparision are done in Src
+// This works the same as constexpr_clamp, but the comparison are done in Src
 // to prevent any implicit promotions.
 template <typename D, typename S>
 constexpr D constexpr_clamp_cast_helper(S src, S sl, S su, D dl, D du) {

folly/FBVector.h

@@ -610,7 +610,7 @@ class fbvector {
   //  second exception being thrown. This is a known and unavoidable
   //  deficiency. In lieu of a strong exception guarantee, relocate_undo does
   //  the next best thing: it provides a weak exception guarantee by
-  //  destorying the new data, but leaving the old data in an indeterminate
+  //  destroying the new data, but leaving the old data in an indeterminate
   //  state. Note that that indeterminate state will be valid, since the
   //  old data has not been destroyed; it has merely been the source of a
   //  move, which is required to leave the source in a valid state.

folly/MPMCQueue.h

@@ -522,7 +522,7 @@ class MPMCQueue<T, Atom, true>
   }
 
   /// Try to expand the queue. Returns true if this expansion was
-  /// successful or a concurent expansion is in progress. Returns
+  /// successful or a concurrent expansion is in progress. Returns
   /// false if the queue has reached its maximum capacity or
   /// allocation has failed.
   bool tryExpand(const uint64_t state, const size_t cap) noexcept {

folly/detail/PolyDetail.h

@@ -878,7 +878,7 @@ struct Sig {
   }
 };
 
-// A functon type with no arguments means the user is trying to disambiguate
+// A function type with no arguments means the user is trying to disambiguate
 // a member function pointer.
 template <class R>
 struct Sig<R()> : Sig<R() const> {

folly/fibers/ForEach.h

@@ -21,7 +21,7 @@ namespace fibers {
 
 /**
  * Schedules several tasks and blocks until all of them are completed.
- * In the process of their successfull completion given callback would be called
+ * In the process of their successful completion given callback would be called
  * for each of them with the index of the task and the result it returned (if
  * not void).
  * If any of these n tasks throws an exception, this exception will be

folly/futures/Future.h

@@ -2391,7 +2391,7 @@ auto collectAll(Collection&& c) -> decltype(collectAll(c.begin(), c.end())) {
   return collectAll(c.begin(), c.end());
 }
 
-// Unsafe variant of collectAll, see coment above for details. Returns
+// Unsafe variant of collectAll, see comment above for details. Returns
 // a Future<std::tuple<Try<T1>, Try<T2>, ...>> on the Inline executor.
 template <typename... Fs>
 Future<std::tuple<Try<typename remove_cvref_t<Fs>::value_type>...>>

folly/synchronization/DistributedMutex-inl.h

@@ -1182,9 +1182,9 @@ lockImplementation(
     // previous value is zeroed out
     //
     // we use memory_order_acq_rel here because we want the read-modify-write
-    // operation to be both acquire and release.  Acquire becasue if this is a
+    // operation to be both acquire and release.  Acquire because if this is a
     // successful lock acquisition, we want to acquire state any other thread
-    // has released from a prior unlock.  We want release semantics becasue
+    // has released from a prior unlock.  We want release semantics because
     // other threads that read the address of this value should see the full
     // well-initialized node we are going to wait on if the mutex acquisition
     // was unsuccessful