Spelling stdlib/public/core (#42441)

* spelling: available

Signed-off-by: Josh Soref <jsoref@users.noreply.github.com>

* spelling: components

Signed-off-by: Josh Soref <jsoref@users.noreply.github.com>

* spelling: conjunction

Signed-off-by: Josh Soref <jsoref@users.noreply.github.com>

* spelling: conversion

Signed-off-by: Josh Soref <jsoref@users.noreply.github.com>

* spelling: enforce

Signed-off-by: Josh Soref <jsoref@users.noreply.github.com>

* spelling: guarantee

Signed-off-by: Josh Soref <jsoref@users.noreply.github.com>

* spelling: interchangeable

Signed-off-by: Josh Soref <jsoref@users.noreply.github.com>

* spelling: satisfied

Signed-off-by: Josh Soref <jsoref@users.noreply.github.com>

* spelling: superfluous

Signed-off-by: Josh Soref <jsoref@users.noreply.github.com>

Co-authored-by: Josh Soref <jsoref@users.noreply.github.com>

Author: jsoref

stdlib/public/core/ContiguouslyStored.swift

@@ -11,7 +11,7 @@
 //===----------------------------------------------------------------------===//
 
 // NOTE: The below is necessary for fast String initialization from untyped
-// memory. When we add Collection.withContiguousRawStorageIfAvailabe(), we can
+// memory. When we add Collection.withContiguousRawStorageIfAvailable(), we can
 // deprecate this functionality.
 
 @usableFromInline

stdlib/public/core/FloatingPointTypes.swift.gyb

@@ -1078,7 +1078,7 @@ extension ${Self} {
       // the original value; if so, the conversion was exact. We need to be
       // careful, however, to make sure that the first conversion does not
       // round to a value that is out of the defined range of the second
-      // converion. E.g. Float(Int.max) rounds to Int.max + 1, and converting
+      // conversion. E.g. Float(Int.max) rounds to Int.max + 1, and converting
       // that back to Int will trap. For Float, Double, and Float80, this is
       // only an issue for the upper bound (because the lower bound of [U]Int
       // is either zero or a power of two, both of which are exactly

stdlib/public/core/Integers.swift

@@ -2036,7 +2036,7 @@ where Magnitude: FixedWidthInteger & UnsignedInteger,
   ///     // result.low  == 128
   ///
   /// The product of `x` and `y` is `-1920`, which is too large to represent in
-  /// an `Int8` instance. The `high` and `low` compnents of the `result` value
+  /// an `Int8` instance. The `high` and `low` components of the `result` value
   /// represent `-1920` when concatenated to form a double-width integer; that
   /// is, using `result.high` as the high byte and `result.low` as the low byte
   /// of an `Int16` instance.

stdlib/public/core/SIMDConcreteOperations.swift.gyb

@@ -72,7 +72,7 @@ extension SIMDMask where Storage == ${Vector} {
     )))
   }
 
-  /// Replaces `a` with the pointwise logical conjuction of `a` and `b`.
+  /// Replaces `a` with the pointwise logical conjunction of `a` and `b`.
   ///
   /// Equivalent to:
   /// ```

stdlib/public/core/SIMDVector.swift

@@ -1415,7 +1415,7 @@ extension SIMDMask {
     return a .| SIMDMask(repeating: b)
   }
 
-  /// Replaces `a` with the pointwise logical conjuction of `a` and `b`.
+  /// Replaces `a` with the pointwise logical conjunction of `a` and `b`.
   ///
   /// Equivalent to:
   /// ```
@@ -1454,7 +1454,7 @@ extension SIMDMask {
     a = a .| b
   }
 
-  /// Replaces `a` with the pointwise logical conjuction of `a` and `b`.
+  /// Replaces `a` with the pointwise logical conjunction of `a` and `b`.
   ///
   /// Equivalent to:
   /// ```

stdlib/public/core/Sort.swift

@@ -570,7 +570,7 @@ extension UnsafeMutableBufferPointer {
     // (b) - for c = runs.count - 1:
     //         - runs[c - 1].count > runs[c].count
     //
-    // Loop until the invariant is satisified for the top four elements of
+    // Loop until the invariant is satisfied for the top four elements of
     // `runs`. Because this method is called for every added run, and only
     // the top three runs are ever merged, this guarantees the invariant holds
     // for the whole array.

stdlib/public/core/StringIndex.swift

@@ -336,7 +336,7 @@ extension String.Index {
 // (The sequence of characters in a substring depend only on the Unicode scalars
 // that make up its contents, not on their surrounding context.) Therefore, such
 // substrings must not look at or set this bit: indices must be reliably
-// interchangable between strings and their associated substrings, even if the
+// interchangeable between strings and their associated substrings, even if the
 // latter are irregular.
 //
 // Note that `startIndex` and `endIndex` have fully inlinable implementations.

stdlib/public/core/StringStorage.swift

@@ -134,7 +134,7 @@ fileprivate struct _CapacityAndFlags {
  Tail Allocations:
 
  `__StringStorage.create` takes a requested minimum code unit capacity and a
- count (which it uses to gurantee null-termination invariant). This will
+ count (which it uses to guarantee null-termination invariant). This will
  allocate the class header and a tail allocation for the requested capacity plus
  one (for the null-terminator), plus any excess `malloc` bucket space. If
  breadcrumbs need be present, they appear at the very end of the allocation.
@@ -457,7 +457,7 @@ extension __StringStorage {
   // The unused capacity available for appending. Note that this excludes the
   // required nul-terminator.
   //
-  // NOTE: Callers who wish to mutate this storage should enfore nul-termination
+  // NOTE: Callers who wish to mutate this storage should enforce nul-termination
   //
   // TODO: Refactoring or removing. Excluding the last byte is awkward.
   @inline(__always)

stdlib/public/core/UnsafeBufferPointer.swift.gyb

@@ -296,7 +296,7 @@ extension Unsafe${Mutable}BufferPointer: ${Mutable}Collection, RandomAccessColle
     // NOTE: Range checks are not performed here, because it is done later by
     // the subscript function.
     // NOTE: We allow the subtraction to silently overflow in release builds
-    // to eliminate a superflous check when `start` and `end` are both valid
+    // to eliminate a superfluous check when `start` and `end` are both valid
     // indices. (The operation can only overflow if `start` is negative, which
     // implies it's an invalid index.) `Collection` does not specify what
     // `distance` should return when given an invalid index pair.