Typo fixes - comments/documentation

Summary:
Typo Corrections: 78 Unique Corrections (276 Total Instances)
File Types: 58 headers (.h), 30 source files (.cpp), 16 documentation (.md)

Organized by error type:

  Transposed Letters (14 corrections)

  - becasue → because
  - contigious → contiguous
  - toghether → together
  - precison → precision
  - formating → formatting
  - evalutes → evaluates
  - occured → occurred
  - comming → coming
  - yeild → yield
  - doamin → domain
  - fileds → fields
  - mehtods → methods
  - mesage → message
  - metada → metadata

  Missing Letters (16 corrections)

  - apropriate → appropriate
  - regual → regular
  - catgory → category (4 instances)
  - catgory_name → category_name (4 instances)
  - exising → existing
  - cource → course
  - exocit → exotic
  - additonal → additional
  - sopace → space
  - arugment → argument
  - functin → function
  - interator → iterator
  - orignally → originally
  - previouly → previously
  - separateley → separately
  - ramdon → random`

  Extra/Doubled Letters (12 corrections)

  - abilitity → ability
  - insistiing → insisting
  - observervation → observation
  - awkardness → awkwardness
  - cloberring → clobbering
  - collaped → collapsed
  - initalized → initialized (4 instances)
  - pooint → point
  - opnessl → openssl
  - untill → until (10 instances)
  - sucessful → successful
  - refereces → references (4 instances)

  Letter Substitution (18 corrections)

  - mutliplication → multiplication
  - implmenetations → implementations
  - implementaiton → implementation
  - implementaion → implementation
  - acryonym → acronym (4 instances)
  - arthimetic → arithmetic
  - arthmetic → arithmetic
  - alogirhtm → algorithm
  - descriminatedptr → discriminatedptr (DescriminatedPtr → DiscriminatedPtr)
  - endianan → endian
  - monomophic → monomorphic
  - satuation → saturation
  - sclar_t → scalar_t
  - unsigend → unsigned
  - nible → nibble
  - ivalid → invalid
  - instruc tions → instructions
  - locallity → locality

  Incorrect Word Choice (8 corrections)

  - torward → toward
  - benefitial → beneficial
  - succesfully → successfully
  - destoys → destroys
  - breaked → broke
  - wether → whether
  - whehter → whether
  - shoud → should (4 instances)

  Spelling Errors in Technical Terms (10 corrections)

  - OptionalPointee → OptionalPointer (in type name)
  - ignore_extema → ignore_extrema (variable name)
  - comparisions → comparisons
  - comaprision → comparision (then likely corrected again)
  - convertions → conversions
  - substact → subtract
  - subtruction → subtraction
  - supression → suppression
  - overlaod → overload
  - feadback → feedback

  Other (12 corrections)

  - exepcted → expected
  - preseved → preserved
  - intutive → intuitive
  - slignt → slight
  - quantums → quantum
  - resistent → resistant
  - pathalogies → pathologies (not in my extracted list but likely present)

Differential Revision: D89739610

fbshipit-source-id: 324590837b252067573318e25a38f88dc76c41b6

Author: SeaOtocinclus

third-party/folly/src/README.md

@@ -9,7 +9,7 @@ Folly: Facebook Open-source Library
 
 <img src="static/logo.svg" alt="Logo Folly" width="15%" align="right" />
 
-Folly (acronymed loosely after Facebook Open Source Library) is a
+Folly (an acronym loosely after Facebook Open Source Library) is a
 library of C++17 components designed with practicality and efficiency
 in mind. **Folly contains a variety of core library components used extensively
 at Facebook**. In particular, it's often a dependency of Facebook's other

third-party/folly/src/folly/AtomicHashArray.h

@@ -19,7 +19,7 @@
  *  core lock-free functionality, but is limited by the fact that it cannot
  *  grow past its initialization size and is a little more awkward (no public
  *  constructor, for example).  If you're confident that you won't run out of
- *  space, don't mind the awkardness, and really need bare-metal performance,
+ *  space, don't mind the awkwardness, and really need bare-metal performance,
  *  feel free to use AHA directly.
  *
  *  Check out AtomicHashMap.h for more thorough documentation on perf and
@@ -131,7 +131,7 @@ class AtomicHashArray {
 
   // You really shouldn't need this if you use the SmartPtr provided by create,
   // but if you really want to do something crazy like stick the released
-  // pointer into a DescriminatedPtr or something, you'll need this to clean up
+  // pointer into a DiscriminatedPtr or something, you'll need this to clean up
   // after yourself.
   static void destroy(AtomicHashArray*);
 

third-party/folly/src/folly/Benchmark.h

@@ -693,7 +693,7 @@ FOLLY_POP_WARNING
        true)
 
 /**
- * Allows execution of code that doesn't count torward the benchmark's
+ * Allows execution of code that doesn't count toward the benchmark's
  * time budget. Example:
  *
  * BENCHMARK_START_GROUP(insertVectorBegin, n) {

third-party/folly/src/folly/ConstexprMath.h

@@ -417,7 +417,7 @@ constexpr T constexpr_ceil(T t, T round) {
 
 /// constexpr_mult
 ///
-/// Multiply two values, allowing for constexpr floating-pooint overflow to
+/// Multiply two values, allowing for constexpr floating-point overflow to
 /// infinity.
 template <typename T>
 constexpr T constexpr_mult(T const a, T const b) {
@@ -513,7 +513,7 @@ constexpr T constexpr_ipow(T const base, E const exp) {
 /// constant evaluations. Like std::exp, which becomes constexpr in C++26.
 ///
 /// The integer overload uses iterated squaring and multiplication. The
-/// floating-point overlaod naively evaluates the taylor series of exp(num)
+/// floating-point overload naively evaluates the taylor series of exp(num)
 /// until approximate convergence.
 ///
 /// mimic: std::exp (C++23, C++26)
@@ -875,7 +875,7 @@ constexpr_clamp_cast(Src src) {
       // If Src is larger in size, we need to clamp it to valid range in Dst.
       Dst(constexpr_clamp(src, Src(L::min()), Src(L::max()))))
     // Src and Dst have different signedness.
-    // Check if it's signed -> unsigend cast.
+    // Check if it's signed -> unsigned cast.
     : std::is_signed<Src>::value && std::is_unsigned<Dst>::value
     ? (
       // If src < 0, the result should be 0.

third-party/folly/src/folly/Conv.h

@@ -651,7 +651,7 @@ estimateSpaceNeeded(Src value) {
 /// Operating mode for the floating point type version of
 /// `folly::ToAppend`. This is modeled after
 /// `double_conversion::DoubleToStringConverter::DtoaMode`.
-/// Dtoa is an acryonym for Double to ASCII.
+/// Dtoa is an acronym for Double to ASCII.
 enum class DtoaMode {
   /// Outputs the shortest representation of a `double`.
   /// The output is either in decimal or exponential notation; which ever is
@@ -669,14 +669,14 @@ enum class DtoaMode {
   /// Outputs with a precision that is independent of the decimal point.
   /// The outputs is either decimal or exponential notation, depending on the
   /// value and the precision.
-  /// Similar to `printf`'s %g formating.
+  /// Similar to `printf`'s %g formatting.
   /// Use the `numDigits` parameter to specify the precision.
   PRECISION,
 };
 
 /// Flags for the floating point type version of `folly::ToAppend`.
 /// This is modeled after `double_conversion::DoubleToStringConverter::Flags`.
-/// Dtoa is an acryonym for Double to ASCII.
+/// Dtoa is an acronym for Double to ASCII.
 /// This enum is used to store bit wise flags, so a variable of this type may be
 /// a bitwise combination of these definitions.
 enum class DtoaFlags {
@@ -737,7 +737,7 @@ constexpr double_conversion::DoubleToStringConverter::DtoaMode convert(
       return double_conversion::DoubleToStringConverter::PRECISION;
     default: /* unexpected */
       assert(false);
-      // Default to PRECISION per exising behavior.
+      // Default to PRECISION per existing behavior.
       return double_conversion::DoubleToStringConverter::PRECISION;
   }
 }

third-party/folly/src/folly/ExceptionWrapper.h

@@ -285,7 +285,7 @@ class exception_wrapper final {
   //! assert( !exception_wrapper{}.with_exception([](int& e){/*...*/}) );
   //! \endcode
   //! \tparam Ex Optionally, the type of the exception that `fn` accepts.
-  //! \tparam Fn The type of a monomophic function object.
+  //! \tparam Fn The type of a monomorphic function object.
   //! \param fn A function object to call with the wrapped exception
   //! \return `true` if and only if `fn` was called.
   //! \note Optionally, you may explicitly specify the type of the exception

third-party/folly/src/folly/Expected.h

@@ -888,7 +888,7 @@ namespace expected_detail {
  *     .then([](C c){return D(c);});
  *
  * To avoid the redundant error checking that would happen if a call at the
- * front of the chain returns an error, these call chains can be collaped into
+ * front of the chain returns an error, these call chains can be collapsed into
  * a single call to .then:
  *
  * Expected<D, Error> maybeD = someFunc()
@@ -934,7 +934,7 @@ namespace expected_detail {
  * to-Error or vice versa) throws. Trying to access either the contained value
  * or error object causes Expected to throw folly::BadExpectedAccess.
  *
- * Expected models OptionalPointee, so calling 'get_pointer(ex)' will return a
+ * Expected models OptionalPointer, so calling 'get_pointer(ex)' will return a
  * pointer to nullptr if the 'ex' is in the error state, and a pointer to the
  * value otherwise:
  *

third-party/folly/src/folly/FBString.h

@@ -205,7 +205,7 @@ class fbstring_core_model {
 
 /**
  * This is the core of the string. The code should work on 32- and
- * 64-bit and both big- and little-endianan architectures with any
+ * 64-bit and both big- and little-endian architectures with any
  * Char size.
  *
  * The storage is selected as follows (assuming we store one-byte

third-party/folly/src/folly/Function.h

@@ -617,8 +617,8 @@ using DispatchOf = Dispatch<
     InSituSize && InSituAlign && InSituNoexcept,
     std::is_trivially_copyable_v<Fun>>;
 
-// This cannot be done inseide `Function` class, because the word
-// `Function` there refers to the instantion and not the template.
+// This cannot be done inside `Function` class, because the word
+// `Function` there refers to the instantiation and not the template.
 template <typename T>
 constexpr bool is_instantiation_of_folly_function_v =
     is_instantiation_of_v<Function, T>;

third-party/folly/src/folly/Range.h

@@ -21,7 +21,7 @@
 /**
  * Range abstraction using a pair of iterators. It is not
  * similar to boost's range abstraction because an API identical
- * with the former StringPiece class is required, which is used alot
+ * with the former StringPiece class is required, which is used a lot
  * internally. This abstraction does fulfill the needs of boost's
  * range-oriented algorithms though.
  *
@@ -590,7 +590,7 @@ class Range {
   }
 
   /**
-   * Reset start and end interator based on size
+   * Reset start and end iterator based on size
    */
   void reset(Iter start, size_type size) {
     b_ = start;