Merge branch 'master' into feature/new-bithelper-apis

Author: Sergio0694

Microsoft.Toolkit.HighPerformance/Box{T}.cs

@@ -87,7 +87,7 @@ public static Box<T> GetFrom(object obj)
         /// <param name="obj">The input <see cref="object"/> instance, representing a boxed <typeparamref name="T"/> value.</param>
         /// <returns>A <see cref="Box{T}"/> reference pointing to <paramref name="obj"/>.</returns>
         /// <remarks>
-        /// This method doesn't check the actual type of <paramref name="obj"/>, so it is responsability of the caller
+        /// This method doesn't check the actual type of <paramref name="obj"/>, so it is responsibility of the caller
         /// to ensure it actually represents a boxed <typeparamref name="T"/> value and not some other instance.
         /// </remarks>
         [Pure]

Microsoft.Toolkit.HighPerformance/Extensions/ArrayExtensions.2D.cs

@@ -61,7 +61,7 @@ public static ref T DangerousGetReference<T>(this T[,] array)
         /// <remarks>
         /// This method doesn't do any bounds checks, therefore it is responsibility of the caller to ensure the <paramref name="i"/>
         /// and <paramref name="j"/> parameters are valid. Furthermore, this extension will ignore the lower bounds for the input
-        /// array, and will just assume that the input index is 0-based. It is responsability of the caller to adjust the input
+        /// array, and will just assume that the input index is 0-based. It is responsibility of the caller to adjust the input
         /// indices to account for the actual lower bounds, if the input array has either axis not starting at 0.
         /// </remarks>
         [Pure]
@@ -234,7 +234,7 @@ public static Array2DColumnEnumerable<T> GetColumn<T>(this T[,] array, int colum
 
 #if SPAN_RUNTIME_SUPPORT
         /// <summary>
-        /// Cretes a new <see cref="Span{T}"/> over an input 2D <typeparamref name="T"/> array.
+        /// Creates a new <see cref="Span{T}"/> over an input 2D <typeparamref name="T"/> array.
         /// </summary>
         /// <typeparam name="T">The type of elements in the input 2D <typeparamref name="T"/> array instance.</typeparam>
         /// <param name="array">The input 2D <typeparamref name="T"/> array instance.</param>

Microsoft.Toolkit.HighPerformance/Extensions/MemoryExtensions.cs

@@ -22,7 +22,7 @@ public static class MemoryExtensions
         /// <returns>A <see cref="Stream"/> wrapping the data within <paramref name="memory"/>.</returns>
         /// <remarks>
         /// Since this method only receives a <see cref="Memory{T}"/> instance, which does not track
-        /// the lifetime of its underlying buffer, it is responsability of the caller to manage that.
+        /// the lifetime of its underlying buffer, it is responsibility of the caller to manage that.
         /// In particular, the caller must ensure that the target buffer is not disposed as long
         /// as the returned <see cref="Stream"/> is in use, to avoid unexpected issues.
         /// </remarks>

Microsoft.Toolkit.HighPerformance/Extensions/ObjectExtensions.cs

@@ -24,7 +24,7 @@ public static class ObjectExtensions
         /// The <see cref="IntPtr"/> value representing the offset to the target field from the start of the object data
         /// for the parameter <paramref name="obj"/>. The offset is in relation to the first usable byte after the method table.
         /// </returns>
-        /// <remarks>The input parameters are not validated, and it's responsability of the caller to ensure that
+        /// <remarks>The input parameters are not validated, and it's responsibility of the caller to ensure that
         /// the <paramref name="data"/> reference is actually pointing to a memory location within <paramref name="obj"/>.
         /// </remarks>
         [Pure]
@@ -46,7 +46,7 @@ public static IntPtr DangerousGetObjectDataByteOffset<T>(this object obj, ref T
         /// <param name="offset">The input byte offset for the <typeparamref name="T"/> reference to retrieve.</param>
         /// <returns>A <typeparamref name="T"/> reference at a specified offset within <paramref name="obj"/>.</returns>
         /// <remarks>
-        /// None of the input arguments is validated, and it is responsability of the caller to ensure they are valid.
+        /// None of the input arguments is validated, and it is responsibility of the caller to ensure they are valid.
         /// In particular, using an invalid offset might cause the retrieved reference to be misaligned with the
         /// desired data, which would break the type system. Or, if the offset causes the retrieved reference to point
         /// to a memory location outside of the input <see cref="object"/> instance, that might lead to runtime crashes.

Microsoft.Toolkit.HighPerformance/Extensions/ReadOnlyMemoryExtensions.cs

@@ -22,7 +22,7 @@ public static class ReadOnlyMemoryExtensions
         /// <returns>A <see cref="Stream"/> wrapping the data within <paramref name="memory"/>.</returns>
         /// <remarks>
         /// Since this method only receives a <see cref="Memory{T}"/> instance, which does not track
-        /// the lifetime of its underlying buffer, it is responsability of the caller to manage that.
+        /// the lifetime of its underlying buffer, it is responsibility of the caller to manage that.
         /// In particular, the caller must ensure that the target buffer is not disposed as long
         /// as the returned <see cref="Stream"/> is in use, to avoid unexpected issues.
         /// </remarks>

Microsoft.Toolkit.HighPerformance/Extensions/ReadOnlySpanExtensions.cs

@@ -279,7 +279,7 @@ public static ReadOnlySpanTokenizer<T> Tokenize<T>(this ReadOnlySpan<T> span, T
         /// even long sequences of values. For the reference implementation, see: <see href="http://www.cse.yorku.ca/~oz/hash.html"/>.
         /// For details on the used constants, see the details provided in this StackOverflow answer (as well as the accepted one):
         /// <see href="https://stackoverflow.com/questions/10696223/reason-for-5381-number-in-djb-hash-function/13809282#13809282"/>.
-        /// Additionally, a comparison between some common hashing algoriths can be found in the reply to this StackExchange question:
+        /// Additionally, a comparison between some common hashing algorithms can be found in the reply to this StackExchange question:
         /// <see href="https://softwareengineering.stackexchange.com/questions/49550/which-hashing-algorithm-is-best-for-uniqueness-and-speed"/>.
         /// Note that the exact implementation is slightly different in this method when it is not called on a sequence of <see cref="byte"/>
         /// values: in this case the <see cref="object.GetHashCode"/> method will be invoked for each <typeparamref name="T"/> value in

Microsoft.Toolkit.HighPerformance/Microsoft.Toolkit.HighPerformance.csproj

@@ -78,9 +78,9 @@
 
         <!-- NETCORE_RUNTIME: to avoid issues with APIs that assume a specific memory layout, we define a
              .NET Core runtime constant to indicate the either .NET Core 2.1 or .NET Core 3.1. These are
-             runtimes with the same overall memory layout for objects (in particular: strings, SZ arrays
+             runtimes with the same overall memory layout for objects (in particular: strings, SZ arrays,
              and 2D arrays). We can use this constant to make sure that APIs that are exclusively available
-             for .NET Standard targets do not make any assumtpion of any internals of the runtime being
+             for .NET Standard targets do not make any assumption of any internals of the runtime being
              actually used by the consumers. -->
         <DefineConstants>NETSTANDARD2_1_OR_GREATER;SPAN_RUNTIME_SUPPORT;NETCORE_RUNTIME</DefineConstants>
       </PropertyGroup>

Microsoft.Toolkit.HighPerformance/ReadOnlyRef{T}.cs

@@ -70,7 +70,7 @@ public static implicit operator ReadOnlyRef<T>(Ref<T> reference)
         /// </summary>
         /// <param name="owner">The owner <see cref="object"/> to create a portable reference for.</param>
         /// <param name="offset">The target offset within <paramref name="owner"/> for the target reference.</param>
-        /// <remarks>The <paramref name="offset"/> parameter is not validated, and it's responsability of the caller to ensure it's valid.</remarks>
+        /// <remarks>The <paramref name="offset"/> parameter is not validated, and it's responsibility of the caller to ensure it's valid.</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private ReadOnlyRef(object owner, IntPtr offset)
         {
@@ -83,7 +83,7 @@ private ReadOnlyRef(object owner, IntPtr offset)
         /// </summary>
         /// <param name="owner">The owner <see cref="object"/> to create a portable reference for.</param>
         /// <param name="value">The target reference to point to (it must be within <paramref name="owner"/>).</param>
-        /// <remarks>The <paramref name="value"/> parameter is not validated, and it's responsability of the caller to ensure it's valid.</remarks>
+        /// <remarks>The <paramref name="value"/> parameter is not validated, and it's responsibility of the caller to ensure it's valid.</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ReadOnlyRef(object owner, in T value)
         {

Microsoft.Toolkit.HighPerformance/Ref{T}.cs

@@ -62,7 +62,7 @@ public ref T Value
         /// </summary>
         /// <param name="owner">The owner <see cref="object"/> to create a portable reference for.</param>
         /// <param name="value">The target reference to point to (it must be within <paramref name="owner"/>).</param>
-        /// <remarks>The <paramref name="value"/> parameter is not validated, and it's responsability of the caller to ensure it's valid.</remarks>
+        /// <remarks>The <paramref name="value"/> parameter is not validated, and it's responsibility of the caller to ensure it's valid.</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public Ref(object owner, ref T value)
         {