From da014016bba4fca1f38253ffc596bafe39b7cf1f Mon Sep 17 00:00:00 2001
From: Stephen Toub <stoub@microsoft.com>
Date: Tue, 26 Nov 2024 13:35:52 -0500
Subject: [PATCH] Add MemoryExtensions overloads with comparer

---
 .../src/System/Diagnostics/TraceUtils.cs      |   12 +-
 .../System.Linq/src/System/Linq/Contains.cs   |   42 +-
 .../System.Memory/ref/System.Memory.cs        |   35 +
 .../tests/ReadOnlySpan/Comparers.cs           |   42 +
 .../tests/ReadOnlySpan/Contains.T.cs          |   38 +-
 .../tests/ReadOnlySpan/Count.T.cs             |   85 +-
 .../tests/ReadOnlySpan/EndsWith.T.cs          |   35 +-
 .../tests/ReadOnlySpan/IndexOf.T.cs           |   50 +-
 .../tests/ReadOnlySpan/IndexOfAny.T.cs        |  420 ++--
 .../tests/ReadOnlySpan/IndexOfSequence.T.cs   |  238 ++-
 .../tests/ReadOnlySpan/LastIndexOf.T.cs       |   50 +-
 .../tests/ReadOnlySpan/LastIndexOfAny.T.cs    |  424 +++--
 .../ReadOnlySpan/LastIndexOfSequence.T.cs     |  249 +--
 .../tests/ReadOnlySpan/SequenceCompareTo.T.cs |   78 +-
 .../tests/ReadOnlySpan/StartsWith.T.cs        |   42 +-
 .../tests/System.Memory.Tests.csproj          |    1 +
 .../src/System/MemoryExtensions.cs            | 1684 ++++++++++++++++-
 17 files changed, 2658 insertions(+), 867 deletions(-)
 create mode 100644 src/libraries/System.Memory/tests/ReadOnlySpan/Comparers.cs

diff --git a/src/libraries/System.Diagnostics.TraceSource/src/System/Diagnostics/TraceUtils.cs b/src/libraries/System.Diagnostics.TraceSource/src/System/Diagnostics/TraceUtils.cs
index 709075d9c77d66..da3af52b7a7bd1 100644
--- a/src/libraries/System.Diagnostics.TraceSource/src/System/Diagnostics/TraceUtils.cs
+++ b/src/libraries/System.Diagnostics.TraceSource/src/System/Diagnostics/TraceUtils.cs
@@ -19,17 +19,7 @@ internal static void VerifyAttributes(StringDictionary? attributes, string[]? su
 
             foreach (string key in attributes.Keys)
             {
-                bool found = false;
-                if (supportedAttributes != null)
-                {
-                    for (int i = 0; i < supportedAttributes.Length; i++)
-                    {
-                        if (supportedAttributes[i] == key)
-                            found = true;
-                    }
-                }
-
-                if (!found)
+                if (supportedAttributes is null || !supportedAttributes.Contains(key))
                 {
                     throw new ArgumentException(SR.Format(SR.AttributeNotSupported, key, parent.GetType().FullName));
                 }
diff --git a/src/libraries/System.Linq/src/System/Linq/Contains.cs b/src/libraries/System.Linq/src/System/Linq/Contains.cs
index f4dbd43ae00e39..0f56c219d29372 100644
--- a/src/libraries/System.Linq/src/System/Linq/Contains.cs
+++ b/src/libraries/System.Linq/src/System/Linq/Contains.cs
@@ -18,43 +18,37 @@ public static bool Contains<TSource>(this IEnumerable<TSource> source, TSource v
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.source);
             }
 
+            if (source.TryGetSpan(out ReadOnlySpan<TSource> span))
+            {
+                return span.Contains(value, comparer);
+            }
+
             if (comparer is null)
             {
                 // While it's tempting, this must not delegate to ICollection<TSource>.Contains, as the historical semantics
                 // of a null comparer with this method are to use EqualityComparer<TSource>.Default, and that might differ
                 // from the semantics encoded in ICollection<TSource>.Contains.
 
-                // We don't bother special-casing spans here as explicitly providing a null comparer with a known collection type
-                // is relatively rare. If you don't care about the comparer, you use the other overload, and while it will delegate
-                // to this overload with a null comparer, it'll only do so for collections from which we can't extract a span.
-                // And if you do care about the comparer, you're generally passing in a non-null one.
-
-                foreach (TSource element in source)
-                {
-                    if (EqualityComparer<TSource>.Default.Equals(element, value))
-                    {
-                        return true;
-                    }
-                }
-            }
-            else if (source.TryGetSpan(out ReadOnlySpan<TSource> span))
-            {
-                foreach (TSource element in span)
+                if (typeof(TSource).IsValueType)
                 {
-                    if (comparer.Equals(element, value))
+                    foreach (TSource element in source)
                     {
-                        return true;
+                        if (EqualityComparer<TSource>.Default.Equals(element, value))
+                        {
+                            return true;
+                        }
                     }
+
+                    return false;
                 }
+
+                comparer = EqualityComparer<TSource>.Default;
             }
-            else
+            foreach (TSource element in source)
             {
-                foreach (TSource element in source)
+                if (comparer.Equals(element, value))
                 {
-                    if (comparer.Equals(element, value))
-                    {
-                        return true;
-                    }
+                    return true;
                 }
             }
 
diff --git a/src/libraries/System.Memory/ref/System.Memory.cs b/src/libraries/System.Memory/ref/System.Memory.cs
index 53d3da5e0441c2..c90f8fb4b2b979 100644
--- a/src/libraries/System.Memory/ref/System.Memory.cs
+++ b/src/libraries/System.Memory/ref/System.Memory.cs
@@ -239,6 +239,7 @@ public static partial class MemoryExtensions
         public static int CompareTo(this System.ReadOnlySpan<char> span, System.ReadOnlySpan<char> other, System.StringComparison comparisonType) { throw null; }
         public static bool Contains(this System.ReadOnlySpan<char> span, System.ReadOnlySpan<char> value, System.StringComparison comparisonType) { throw null; }
         public static bool Contains<T>(this System.ReadOnlySpan<T> span, T value) where T : System.IEquatable<T>? { throw null; }
+        public static bool Contains<T>(this System.ReadOnlySpan<T> span, T value, System.Collections.Generic.IEqualityComparer<T>? comparer = null) { throw null; }
         [System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute(-1)]
         public static bool Contains<T>(this System.Span<T> span, T value) where T : System.IEquatable<T>? { throw null; }
         public static bool ContainsAny(this System.ReadOnlySpan<char> span, System.Buffers.SearchValues<string> values) { throw null; }
@@ -246,8 +247,11 @@ public static partial class MemoryExtensions
         public static bool ContainsAny(this System.Span<char> span, System.Buffers.SearchValues<string> values) { throw null; }
         public static bool ContainsAny<T>(this System.ReadOnlySpan<T> span, System.Buffers.SearchValues<T> values) where T : System.IEquatable<T>? { throw null; }
         public static bool ContainsAny<T>(this System.ReadOnlySpan<T> span, System.ReadOnlySpan<T> values) where T : System.IEquatable<T>? { throw null; }
+        public static bool ContainsAny<T>(this System.ReadOnlySpan<T> span, System.ReadOnlySpan<T> values, System.Collections.Generic.IEqualityComparer<T>? comparer = null) { throw null; }
         public static bool ContainsAny<T>(this System.ReadOnlySpan<T> span, T value0, T value1) where T : System.IEquatable<T>? { throw null; }
+        public static bool ContainsAny<T>(this System.ReadOnlySpan<T> span, T value0, T value1, System.Collections.Generic.IEqualityComparer<T>? comparer = null) { throw null; }
         public static bool ContainsAny<T>(this System.ReadOnlySpan<T> span, T value0, T value1, T value2) where T : System.IEquatable<T>? { throw null; }
+        public static bool ContainsAny<T>(this System.ReadOnlySpan<T> span, T value0, T value1, T value2, System.Collections.Generic.IEqualityComparer<T>? comparer = null) { throw null; }
         [System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute(-1)]
         public static bool ContainsAny<T>(this System.Span<T> span, System.Buffers.SearchValues<T> values) where T : System.IEquatable<T>? { throw null; }
         [System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute(-1)]
@@ -258,9 +262,13 @@ public static partial class MemoryExtensions
         public static bool ContainsAny<T>(this System.Span<T> span, T value0, T value1, T value2) where T : System.IEquatable<T>? { throw null; }
         public static bool ContainsAnyExcept<T>(this System.ReadOnlySpan<T> span, System.Buffers.SearchValues<T> values) where T : System.IEquatable<T>? { throw null; }
         public static bool ContainsAnyExcept<T>(this System.ReadOnlySpan<T> span, System.ReadOnlySpan<T> values) where T : System.IEquatable<T>? { throw null; }
+        public static bool ContainsAnyExcept<T>(this System.ReadOnlySpan<T> span, System.ReadOnlySpan<T> values, System.Collections.Generic.IEqualityComparer<T>? comparer = null) { throw null; }
         public static bool ContainsAnyExcept<T>(this System.ReadOnlySpan<T> span, T value) where T : System.IEquatable<T>? { throw null; }
+        public static bool ContainsAnyExcept<T>(this System.ReadOnlySpan<T> span, T value, System.Collections.Generic.IEqualityComparer<T>? comparer = null) { throw null; }
         public static bool ContainsAnyExcept<T>(this System.ReadOnlySpan<T> span, T value0, T value1) where T : System.IEquatable<T>? { throw null; }
+        public static bool ContainsAnyExcept<T>(this System.ReadOnlySpan<T> span, T value0, T value1, System.Collections.Generic.IEqualityComparer<T>? comparer = null) { throw null; }
         public static bool ContainsAnyExcept<T>(this System.ReadOnlySpan<T> span, T value0, T value1, T value2) where T : System.IEquatable<T>? { throw null; }
+        public static bool ContainsAnyExcept<T>(this System.ReadOnlySpan<T> span, T value0, T value1, T value2, System.Collections.Generic.IEqualityComparer<T>? comparer = null) { throw null; }
         [System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute(-1)]
         public static bool ContainsAnyExcept<T>(this System.Span<T> span, System.Buffers.SearchValues<T> values) where T : System.IEquatable<T>? { throw null; }
         [System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute(-1)]
@@ -282,14 +290,18 @@ public static void CopyTo<T>(this T[]? source, System.Span<T> destination) { }
         [System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute(-1)]
         public static int Count<T>(this System.Span<T> span, T value) where T : System.IEquatable<T>? { throw null; }
         public static int Count<T>(this System.ReadOnlySpan<T> span, T value) where T : System.IEquatable<T>? { throw null; }
+        public static int Count<T>(this System.ReadOnlySpan<T> span, T value, System.Collections.Generic.IEqualityComparer<T>? comparer = null) { throw null; }
         [System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute(-1)]
         public static int Count<T>(this System.Span<T> span, System.ReadOnlySpan<T> value) where T : System.IEquatable<T>? { throw null; }
         public static int Count<T>(this System.ReadOnlySpan<T> span, System.ReadOnlySpan<T> value) where T : System.IEquatable<T>? { throw null; }
+        public static int Count<T>(this System.ReadOnlySpan<T> span, System.ReadOnlySpan<T> value, System.Collections.Generic.IEqualityComparer<T>? comparer = null) { throw null; }
         public static bool EndsWith(this System.ReadOnlySpan<char> span, System.ReadOnlySpan<char> value, System.StringComparison comparisonType) { throw null; }
         public static bool EndsWith<T>(this System.ReadOnlySpan<T> span, System.ReadOnlySpan<T> value) where T : System.IEquatable<T>? { throw null; }
+        public static bool EndsWith<T>(this System.ReadOnlySpan<T> span, System.ReadOnlySpan<T> value, System.Collections.Generic.IEqualityComparer<T>? comparer = null) { throw null; }
         [System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute(-1)]
         public static bool EndsWith<T>(this System.Span<T> span, System.ReadOnlySpan<T> value) where T : System.IEquatable<T>? { throw null; }
         public static bool EndsWith<T>(this System.ReadOnlySpan<T> span, T value) where T : System.IEquatable<T>? { throw null; }
+        public static bool EndsWith<T>(this System.ReadOnlySpan<T> span, T value, System.Collections.Generic.IEqualityComparer<T>? comparer = null) { throw null; }
         public static System.Text.SpanLineEnumerator EnumerateLines(this System.ReadOnlySpan<char> span) { throw null; }
         [System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute(-1)]
         public static System.Text.SpanLineEnumerator EnumerateLines(this System.Span<char> span) { throw null; }
@@ -303,8 +315,11 @@ public static void CopyTo<T>(this T[]? source, System.Span<T> destination) { }
         public static int IndexOfAny(this System.Span<char> span, System.Buffers.SearchValues<string> values) { throw null; }
         public static int IndexOfAny<T>(this System.ReadOnlySpan<T> span, System.Buffers.SearchValues<T> values) where T : System.IEquatable<T>? { throw null; }
         public static int IndexOfAny<T>(this System.ReadOnlySpan<T> span, System.ReadOnlySpan<T> values) where T : System.IEquatable<T>? { throw null; }
+        public static int IndexOfAny<T>(this System.ReadOnlySpan<T> span, System.ReadOnlySpan<T> values, System.Collections.Generic.IEqualityComparer<T>? comparer = null) { throw null; }
         public static int IndexOfAny<T>(this System.ReadOnlySpan<T> span, T value0, T value1) where T : System.IEquatable<T>? { throw null; }
+        public static int IndexOfAny<T>(this System.ReadOnlySpan<T> span, T value0, T value1, System.Collections.Generic.IEqualityComparer<T>? comparer = null) { throw null; }
         public static int IndexOfAny<T>(this System.ReadOnlySpan<T> span, T value0, T value1, T value2) where T : System.IEquatable<T>? { throw null; }
+        public static int IndexOfAny<T>(this System.ReadOnlySpan<T> span, T value0, T value1, T value2, System.Collections.Generic.IEqualityComparer<T>? comparer = null) { throw null; }
         [System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute(-1)]
         public static int IndexOfAny<T>(this System.Span<T> span, System.Buffers.SearchValues<T> values) where T : System.IEquatable<T>? { throw null; }
         [System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute(-1)]
@@ -324,15 +339,21 @@ public static void CopyTo<T>(this T[]? source, System.Span<T> destination) { }
         [System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute(-1)]
         public static int IndexOfAnyExcept<T>(this System.Span<T> span, System.ReadOnlySpan<T> values) where T : System.IEquatable<T>? { throw null; }
         public static int IndexOfAnyExcept<T>(this System.ReadOnlySpan<T> span, T value) where T : System.IEquatable<T>? { throw null; }
+        public static int IndexOfAnyExcept<T>(this System.ReadOnlySpan<T> span, T value, System.Collections.Generic.IEqualityComparer<T>? comparer = null) { throw null; }
         public static int IndexOfAnyExcept<T>(this System.ReadOnlySpan<T> span, T value0, T value1) where T : System.IEquatable<T>? { throw null; }
+        public static int IndexOfAnyExcept<T>(this System.ReadOnlySpan<T> span, T value0, T value1, System.Collections.Generic.IEqualityComparer<T>? comparer = null) { throw null; }
         public static int IndexOfAnyExcept<T>(this System.ReadOnlySpan<T> span, T value0, T value1, T value2) where T : System.IEquatable<T>? { throw null; }
+        public static int IndexOfAnyExcept<T>(this System.ReadOnlySpan<T> span, T value0, T value1, T value2, System.Collections.Generic.IEqualityComparer<T>? comparer = null) { throw null; }
         public static int IndexOfAnyExcept<T>(this System.ReadOnlySpan<T> span, System.Buffers.SearchValues<T> values) where T : System.IEquatable<T>? { throw null; }
         public static int IndexOfAnyExcept<T>(this System.ReadOnlySpan<T> span, System.ReadOnlySpan<T> values) where T : System.IEquatable<T>? { throw null; }
+        public static int IndexOfAnyExcept<T>(this System.ReadOnlySpan<T> span, System.ReadOnlySpan<T> values, System.Collections.Generic.IEqualityComparer<T>? comparer = null) { throw null; }
         public static int IndexOfAnyExceptInRange<T>(this System.ReadOnlySpan<T> span, T lowInclusive, T highInclusive) where T : System.IComparable<T> { throw null; }
         [System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute(-1)]
         public static int IndexOfAnyExceptInRange<T>(this System.Span<T> span, T lowInclusive, T highInclusive) where T : System.IComparable<T> { throw null; }
         public static int IndexOf<T>(this System.ReadOnlySpan<T> span, System.ReadOnlySpan<T> value) where T : System.IEquatable<T>? { throw null; }
+        public static int IndexOf<T>(this System.ReadOnlySpan<T> span, System.ReadOnlySpan<T> value, System.Collections.Generic.IEqualityComparer<T>? comparer = null) { throw null; }
         public static int IndexOf<T>(this System.ReadOnlySpan<T> span, T value) where T : System.IEquatable<T>? { throw null; }
+        public static int IndexOf<T>(this System.ReadOnlySpan<T> span, T value, System.Collections.Generic.IEqualityComparer<T>? comparer = null) { throw null; }
         [System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute(-1)]
         public static int IndexOf<T>(this System.Span<T> span, System.ReadOnlySpan<T> value) where T : System.IEquatable<T>? { throw null; }
         [System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute(-1)]
@@ -344,8 +365,11 @@ public static void CopyTo<T>(this T[]? source, System.Span<T> destination) { }
         public static int LastIndexOf(this System.ReadOnlySpan<char> span, System.ReadOnlySpan<char> value, System.StringComparison comparisonType) { throw null; }
         public static int LastIndexOfAny<T>(this System.ReadOnlySpan<T> span, System.Buffers.SearchValues<T> values) where T : System.IEquatable<T>? { throw null; }
         public static int LastIndexOfAny<T>(this System.ReadOnlySpan<T> span, System.ReadOnlySpan<T> values) where T : System.IEquatable<T>? { throw null; }
+        public static int LastIndexOfAny<T>(this System.ReadOnlySpan<T> span, System.ReadOnlySpan<T> values, System.Collections.Generic.IEqualityComparer<T>? comparer = null) { throw null; }
         public static int LastIndexOfAny<T>(this System.ReadOnlySpan<T> span, T value0, T value1) where T : System.IEquatable<T>? { throw null; }
+        public static int LastIndexOfAny<T>(this System.ReadOnlySpan<T> span, T value0, T value1, System.Collections.Generic.IEqualityComparer<T>? comparer = null) { throw null; }
         public static int LastIndexOfAny<T>(this System.ReadOnlySpan<T> span, T value0, T value1, T value2) where T : System.IEquatable<T>? { throw null; }
+        public static int LastIndexOfAny<T>(this System.ReadOnlySpan<T> span, T value0, T value1, T value2, System.Collections.Generic.IEqualityComparer<T>? comparer = null) { throw null; }
         [System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute(-1)]
         public static int LastIndexOfAny<T>(this System.Span<T> span, System.Buffers.SearchValues<T> values) where T : System.IEquatable<T>? { throw null; }
         [System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute(-1)]
@@ -365,15 +389,21 @@ public static void CopyTo<T>(this T[]? source, System.Span<T> destination) { }
         [System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute(-1)]
         public static int LastIndexOfAnyExcept<T>(this System.Span<T> span, System.ReadOnlySpan<T> values) where T : System.IEquatable<T>? { throw null; }
         public static int LastIndexOfAnyExcept<T>(this System.ReadOnlySpan<T> span, T value) where T : System.IEquatable<T>? { throw null; }
+        public static int LastIndexOfAnyExcept<T>(this System.ReadOnlySpan<T> span, T value, System.Collections.Generic.IEqualityComparer<T>? comparer = null) { throw null; }
         public static int LastIndexOfAnyExcept<T>(this System.ReadOnlySpan<T> span, T value0, T value1) where T : System.IEquatable<T>? { throw null; }
+        public static int LastIndexOfAnyExcept<T>(this System.ReadOnlySpan<T> span, T value0, T value1, System.Collections.Generic.IEqualityComparer<T>? comparer = null) { throw null; }
         public static int LastIndexOfAnyExcept<T>(this System.ReadOnlySpan<T> span, T value0, T value1, T value2) where T : System.IEquatable<T>? { throw null; }
+        public static int LastIndexOfAnyExcept<T>(this System.ReadOnlySpan<T> span, T value0, T value1, T value2, System.Collections.Generic.IEqualityComparer<T>? comparer = null) { throw null; }
         public static int LastIndexOfAnyExcept<T>(this System.ReadOnlySpan<T> span, System.Buffers.SearchValues<T> values) where T : System.IEquatable<T>? { throw null; }
         public static int LastIndexOfAnyExcept<T>(this System.ReadOnlySpan<T> span, System.ReadOnlySpan<T> values) where T : System.IEquatable<T>? { throw null; }
+        public static int LastIndexOfAnyExcept<T>(this System.ReadOnlySpan<T> span, System.ReadOnlySpan<T> values, System.Collections.Generic.IEqualityComparer<T>? comparer = null) { throw null; }
         public static int LastIndexOfAnyExceptInRange<T>(this System.ReadOnlySpan<T> span, T lowInclusive, T highInclusive) where T : System.IComparable<T> { throw null; }
         [System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute(-1)]
         public static int LastIndexOfAnyExceptInRange<T>(this System.Span<T> span, T lowInclusive, T highInclusive) where T : System.IComparable<T> { throw null; }
         public static int LastIndexOf<T>(this System.ReadOnlySpan<T> span, System.ReadOnlySpan<T> value) where T : System.IEquatable<T>? { throw null; }
+        public static int LastIndexOf<T>(this System.ReadOnlySpan<T> span, System.ReadOnlySpan<T> value, System.Collections.Generic.IEqualityComparer<T>? comparer = null) { throw null; }
         public static int LastIndexOf<T>(this System.ReadOnlySpan<T> span, T value) where T : System.IEquatable<T>? { throw null; }
+        public static int LastIndexOf<T>(this System.ReadOnlySpan<T> span, T value, System.Collections.Generic.IEqualityComparer<T>? comparer = null) { throw null; }
         [System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute(-1)]
         public static int LastIndexOf<T>(this System.Span<T> span, System.ReadOnlySpan<T> value) where T : System.IEquatable<T>? { throw null; }
         [System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute(-1)]
@@ -388,9 +418,12 @@ public static void CopyTo<T>(this T[]? source, System.Span<T> destination) { }
         [System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute(-1)]
         public static bool Overlaps<T>(this System.Span<T> span, System.ReadOnlySpan<T> other, out int elementOffset) { throw null; }
         public static void Replace<T>(this System.Span<T> span, T oldValue, T newValue) where T : System.IEquatable<T>? { }
+        public static void Replace<T>(this System.Span<T> span, T oldValue, T newValue, System.Collections.Generic.IEqualityComparer<T>? comparer = null) { }
         public static void Replace<T>(this System.ReadOnlySpan<T> source, System.Span<T> destination, T oldValue, T newValue) where T : System.IEquatable<T>? { }
+        public static void Replace<T>(this System.ReadOnlySpan<T> source, System.Span<T> destination, T oldValue, T newValue, System.Collections.Generic.IEqualityComparer<T>? comparer = null) { }
         public static void Reverse<T>(this System.Span<T> span) { }
         public static int SequenceCompareTo<T>(this System.ReadOnlySpan<T> span, System.ReadOnlySpan<T> other) where T : System.IComparable<T>? { throw null; }
+        public static int SequenceCompareTo<T>(this System.ReadOnlySpan<T> span, System.ReadOnlySpan<T> other, System.Collections.Generic.IComparer<T>? comparer = null) { throw null; }
         [System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute(-1)]
         public static int SequenceCompareTo<T>(this System.Span<T> span, System.ReadOnlySpan<T> other) where T : System.IComparable<T>? { throw null; }
         public static bool SequenceEqual<T>(this System.ReadOnlySpan<T> span, System.ReadOnlySpan<T> other) where T : System.IEquatable<T>? { throw null; }
@@ -415,9 +448,11 @@ public static void Sort<TKey, TValue, TComparer>(this System.Span<TKey> keys, Sy
         public static int SplitAny(this System.ReadOnlySpan<char> source, System.Span<System.Range> destination, System.ReadOnlySpan<string> separators, System.StringSplitOptions options = System.StringSplitOptions.None) { throw null; }
         public static bool StartsWith(this System.ReadOnlySpan<char> span, System.ReadOnlySpan<char> value, System.StringComparison comparisonType) { throw null; }
         public static bool StartsWith<T>(this System.ReadOnlySpan<T> span, System.ReadOnlySpan<T> value) where T : System.IEquatable<T>? { throw null; }
+        public static bool StartsWith<T>(this System.ReadOnlySpan<T> span, System.ReadOnlySpan<T> value, System.Collections.Generic.IEqualityComparer<T>? comparer = null) { throw null; }
         [System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute(-1)]
         public static bool StartsWith<T>(this System.Span<T> span, System.ReadOnlySpan<T> value) where T : System.IEquatable<T>? { throw null; }
         public static bool StartsWith<T>(this System.ReadOnlySpan<T> span, T value) where T : System.IEquatable<T>? { throw null; }
+        public static bool StartsWith<T>(this System.ReadOnlySpan<T> span, T value, System.Collections.Generic.IEqualityComparer<T>? comparer = null) { throw null; }
         public static int ToLower(this System.ReadOnlySpan<char> source, System.Span<char> destination, System.Globalization.CultureInfo? culture) { throw null; }
         public static int ToLowerInvariant(this System.ReadOnlySpan<char> source, System.Span<char> destination) { throw null; }
         public static int ToUpper(this System.ReadOnlySpan<char> source, System.Span<char> destination, System.Globalization.CultureInfo? culture) { throw null; }
diff --git a/src/libraries/System.Memory/tests/ReadOnlySpan/Comparers.cs b/src/libraries/System.Memory/tests/ReadOnlySpan/Comparers.cs
new file mode 100644
index 00000000000000..233bd81192f6fe
--- /dev/null
+++ b/src/libraries/System.Memory/tests/ReadOnlySpan/Comparers.cs
@@ -0,0 +1,42 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.Generic;
+using Xunit;
+
+namespace System.SpanTests
+{
+    public static partial class ReadOnlySpanTests
+    {
+        private static IEnumerable<IEqualityComparer<T>?> GetDefaultEqualityComparers<T>()
+        {
+            yield return null;
+
+            yield return EqualityComparer<T>.Default;
+
+            yield return EqualityComparer<T>.Create((i, j) => EqualityComparer<T>.Default.Equals(i, j));
+
+            if (typeof(T) == typeof(string))
+            {
+                yield return (IEqualityComparer<T>)(object)StringComparer.Ordinal;
+            }
+        }
+
+        private static IEnumerable<IComparer<T>?> GetDefaultComparers<T>()
+        {
+            yield return null;
+
+            yield return Comparer<T>.Default;
+
+            yield return Comparer<T>.Create((i, j) => Comparer<T>.Default.Compare(i, j));
+
+            if (typeof(T) == typeof(string))
+            {
+                yield return (IComparer<T>)(object)StringComparer.Ordinal;
+            }
+        }
+
+        private static IEqualityComparer<T> GetFalseEqualityComparer<T>() =>
+            EqualityComparer<T>.Create((i, j) => false);
+    }
+}
diff --git a/src/libraries/System.Memory/tests/ReadOnlySpan/Contains.T.cs b/src/libraries/System.Memory/tests/ReadOnlySpan/Contains.T.cs
index 0aede51284e51b..8692f419d4a21a 100644
--- a/src/libraries/System.Memory/tests/ReadOnlySpan/Contains.T.cs
+++ b/src/libraries/System.Memory/tests/ReadOnlySpan/Contains.T.cs
@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Collections.Generic;
 using Xunit;
 
 namespace System.SpanTests
@@ -27,13 +28,13 @@ public static void TestContains()
                 {
                     a[i] = 10 * (i + 1);
                 }
-                ReadOnlySpan<int> span = new ReadOnlySpan<int>(a);
 
                 for (int targetIndex = 0; targetIndex < length; targetIndex++)
                 {
                     int target = a[targetIndex];
-                    bool found = span.Contains(target);
-                    Assert.True(found);
+                    Assert.True(new ReadOnlySpan<int>(a).Contains(target));
+                    Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.True(new ReadOnlySpan<int>(a).Contains(target, comparer)));
+                    Assert.False(new ReadOnlySpan<int>(a).Contains(target, GetFalseEqualityComparer<int>()));
                 }
             }
         }
@@ -52,9 +53,9 @@ public static void TestMultipleContains()
                 a[length - 1] = 5555;
                 a[length - 2] = 5555;
 
-                ReadOnlySpan<int> span = new ReadOnlySpan<int>(a);
-                bool found = span.Contains(5555);
-                Assert.True(found);
+                Assert.True(new ReadOnlySpan<int>(a).Contains(5555));
+                Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.True(new ReadOnlySpan<int>(a).Contains(5555, comparer)));
+                Assert.False(new ReadOnlySpan<int>(a).Contains(5555, GetFalseEqualityComparer<int>()));
             }
         }
 
@@ -71,8 +72,7 @@ public static void OnNoMatchForContainsMakeSureEveryElementIsCompared()
                     a[i] = new TInt(10 * (i + 1), log);
                 }
                 ReadOnlySpan<TInt> span = new ReadOnlySpan<TInt>(a);
-                bool found = span.Contains(new TInt(9999, log));
-                Assert.False(found);
+                Assert.False(span.Contains(new TInt(9999, log)));
 
                 // Since we asked for a non-existent value, make sure each element of the array was compared once.
                 // (Strictly speaking, it would not be illegal for IndexOf to compare an element more than once but
@@ -112,8 +112,7 @@ void checkForOutOfRangeAccess(int x, int y)
                 }
 
                 ReadOnlySpan<TInt> span = new ReadOnlySpan<TInt>(a, GuardLength, length);
-                bool found = span.Contains(new TInt(9999, checkForOutOfRangeAccess));
-                Assert.False(found);
+                Assert.False(span.Contains(new TInt(9999, checkForOutOfRangeAccess)));
             }
         }
 
@@ -121,8 +120,11 @@ void checkForOutOfRangeAccess(int x, int y)
         public static void ZeroLengthContains_String()
         {
             ReadOnlySpan<string> span = new ReadOnlySpan<string>(Array.Empty<string>());
-            bool found = span.Contains("a");
-            Assert.False(found);
+            Assert.False(span.Contains("a"));
+            Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.False(new ReadOnlySpan<string>(Array.Empty<string>()).Contains("a", comparer)));
+            Assert.False(span.Contains("a", null));
+            Assert.False(span.Contains("a", EqualityComparer<string>.Default));
+            Assert.False(span.Contains("a", EqualityComparer<string>.Create((i, j) => i == j)));
         }
 
         [Fact]
@@ -140,8 +142,9 @@ public static void TestMatchContains_String()
                 for (int targetIndex = 0; targetIndex < length; targetIndex++)
                 {
                     string target = a[targetIndex];
-                    bool found = span.Contains(target);
-                    Assert.True(found);
+                    Assert.True(span.Contains(target));
+                    Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.True(new ReadOnlySpan<string>(a).Contains(target, comparer)));
+                    Assert.False(span.Contains(target, GetFalseEqualityComparer<string>()));
                 }
             }
         }
@@ -161,8 +164,7 @@ public static void TestNoMatchContains_String()
                 }
                 ReadOnlySpan<string> span = new ReadOnlySpan<string>(a);
 
-                bool found = span.Contains(target);
-                Assert.False(found);
+                Assert.False(span.Contains(target));
             }
         }
 
@@ -181,8 +183,7 @@ public static void TestMultipleMatchContains_String()
                 a[length - 2] = "5555";
 
                 ReadOnlySpan<string> span = new ReadOnlySpan<string>(a);
-                bool found = span.Contains("5555");
-                Assert.True(found);
+                Assert.True(span.Contains("5555"));
             }
         }
 
@@ -192,6 +193,7 @@ public static void ContainsNull_String(string[] spanInput, bool expected)
         {
             ReadOnlySpan<string> theStrings = spanInput;
             Assert.Equal(expected, theStrings.Contains(null));
+            Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(expected, new ReadOnlySpan<string>(spanInput).Contains(null, comparer)));
         }
     }
 }
diff --git a/src/libraries/System.Memory/tests/ReadOnlySpan/Count.T.cs b/src/libraries/System.Memory/tests/ReadOnlySpan/Count.T.cs
index 6cc1ff7e353826..75c6c41c74e315 100644
--- a/src/libraries/System.Memory/tests/ReadOnlySpan/Count.T.cs
+++ b/src/libraries/System.Memory/tests/ReadOnlySpan/Count.T.cs
@@ -11,6 +11,7 @@ public static partial class ReadOnlySpanTests
         public static void ZeroLengthCount_Int()
         {
             Assert.Equal(0, ReadOnlySpan<int>.Empty.Count(0));
+            Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(0, ReadOnlySpan<int>.Empty.Count(0, comparer)));
         }
         
         [Fact]
@@ -19,15 +20,17 @@ public static void ZeroLengthCount_RosInt()
             for (int i = 0; i <= 2; i++)
             {
                 Assert.Equal(0, ReadOnlySpan<int>.Empty.Count(new int[i]));
+                Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(0, ReadOnlySpan<int>.Empty.Count(new int[i], comparer)));
             }
         }
 
         [Fact]
         public static void ZeroLengthNeedleCount_RosInt()
         {
-            ReadOnlySpan<int> span = new ReadOnlySpan<int>(new int[] { 5, 5, 5, 5, 5 });
+            int[] arr = [5, 5, 5, 5, 5];
 
-            Assert.Equal(0, span.Count<int>(ReadOnlySpan<int>.Empty));
+            Assert.Equal(0, new ReadOnlySpan<int>(arr).Count(ReadOnlySpan<int>.Empty));
+            Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(0, new ReadOnlySpan<int>(arr).Count(ReadOnlySpan<int>.Empty, comparer)));
         }
 
         [Fact]
@@ -40,11 +43,12 @@ public static void TestCount_Int()
                 {
                     a[i] = 10 * (i + 1);
                 }
-                ReadOnlySpan<int> span = new ReadOnlySpan<int>(a);
 
                 for (int targetIndex = 0; targetIndex < length; targetIndex++)
                 {
-                    Assert.Equal(1, span.Count(a[targetIndex]));
+                    Assert.Equal(1, new ReadOnlySpan<int>(a).Count(a[targetIndex]));
+                    Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(1, new ReadOnlySpan<int>(a).Count(a[targetIndex], comparer)));
+                    Assert.Equal(0, new ReadOnlySpan<int>(a).Count(a[targetIndex], GetFalseEqualityComparer<int>()));
                 }
             }
         }
@@ -59,11 +63,12 @@ public static void TestCount_RosInt()
                 {
                     a[i] = 10 * (i + 1);
                 }
-                ReadOnlySpan<int> span = new ReadOnlySpan<int>(a);
 
                 for (int targetIndex = 0; targetIndex < length - 1; targetIndex++)
                 {
-                    Assert.Equal(1, span.Count(new int[] { a[targetIndex], a[targetIndex + 1] }));
+                    Assert.Equal(1, new ReadOnlySpan<int>(a).Count(new int[] { a[targetIndex], a[targetIndex + 1] }));
+                    Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(1, new ReadOnlySpan<int>(a).Count(new int[] { a[targetIndex], a[targetIndex + 1] }, comparer)));
+                    Assert.Equal(0, new ReadOnlySpan<int>(a).Count(new int[] { a[targetIndex], a[targetIndex + 1] }, GetFalseEqualityComparer<int>()));
                 }
             }
         }
@@ -81,8 +86,9 @@ public static void TestMultipleCount_Int()
 
                 a[^1] = a[^2] = 5555;
 
-                ReadOnlySpan<int> span = new ReadOnlySpan<int>(a);
-                Assert.Equal(2, span.Count(5555));
+                Assert.Equal(2, new ReadOnlySpan<int>(a).Count(5555));
+                Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(2, new ReadOnlySpan<int>(a).Count(5555, comparer)));
+                Assert.Equal(0, new ReadOnlySpan<int>(a).Count(5555, GetFalseEqualityComparer<int>()));
             }
         }
         
@@ -98,8 +104,9 @@ public static void TestMultipleCount_RosInt()
                 }
                 a[0] = a[1] = a[^1] = a[^2] = 5555;
 
-                ReadOnlySpan<int> span = new ReadOnlySpan<int>(a);
-                Assert.Equal(2, span.Count<int>(new int[] { 5555, 5555 }));
+                Assert.Equal(2, new ReadOnlySpan<int>(a).Count(new int[] { 5555, 5555 }));
+                Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(2, new ReadOnlySpan<int>(a).Count(new int[] { 5555, 5555 }, comparer)));
+                Assert.Equal(0, new ReadOnlySpan<int>(a).Count(new int[] { 5555, 5555 }, GetFalseEqualityComparer<int>()));
             }
         }
 
@@ -222,12 +229,14 @@ void CheckForOutOfRangeAccess(int x, int y) =>
         public static void ZeroLengthCount_String()
         {
             Assert.Equal(0, ReadOnlySpan<string>.Empty.Count("a"));
+            Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(0, ReadOnlySpan<string>.Empty.Count("a", comparer)));
         }
-        
+
         [Fact]
         public static void ZeroLengthCount_RosString()
         {
             Assert.Equal(0, ReadOnlySpan<string>.Empty.Count(new[] { "a", "b" }));
+            Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(0, ReadOnlySpan<string>.Empty.Count(new[] { "a", "b" }, comparer)));
         }
 
         [Fact]
@@ -240,11 +249,12 @@ public static void TestMatchCount_String()
                 {
                     a[i] = (10 * (i + 1)).ToString();
                 }
-                ReadOnlySpan<string> span = new ReadOnlySpan<string>(a);
 
                 for (int targetIndex = 0; targetIndex < length; targetIndex++)
                 {
-                    Assert.Equal(1, span.Count(a[targetIndex]));
+                    Assert.Equal(1, new ReadOnlySpan<string>(a).Count(a[targetIndex]));
+                    Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(1, new ReadOnlySpan<string>(a).Count(a[targetIndex], comparer)));
+                    Assert.Equal(0, new ReadOnlySpan<string>(a).Count(a[targetIndex], GetFalseEqualityComparer<string>()));
                 }
             }
         }
@@ -259,11 +269,12 @@ public static void TestMatchCount_RosString()
                 {
                     a[i] = (10 * (i + 1)).ToString();
                 }
-                ReadOnlySpan<string> span = new ReadOnlySpan<string>(a);
 
                 for (int targetIndex = 0; targetIndex < length - 1; targetIndex++)
                 {
-                    Assert.Equal(1, span.Count(new string[] { a[targetIndex], a[targetIndex + 1] }));
+                    Assert.Equal(1, new ReadOnlySpan<string>(a).Count(new string[] { a[targetIndex], a[targetIndex + 1] }));
+                    Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(1, new ReadOnlySpan<string>(a).Count(new string[] { a[targetIndex], a[targetIndex + 1] }, comparer)));
+                    Assert.Equal(0, new ReadOnlySpan<string>(a).Count(new string[] { a[targetIndex], a[targetIndex + 1] }, GetFalseEqualityComparer<string>()));
                 }
             }
         }
@@ -282,8 +293,8 @@ public static void TestNoMatchCount_String()
                     a[i] = val == target ? (target + 1) : val;
                 }
 
-                ReadOnlySpan<string> span = new ReadOnlySpan<string>(a);
-                Assert.Equal(0, span.Count(target));
+                Assert.Equal(0, new ReadOnlySpan<string>(a).Count(target));
+                Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(0, new ReadOnlySpan<string>(a).Count(target, comparer)));
             }
         }
         
@@ -294,15 +305,15 @@ public static void TestNoMatchCount_RosString()
             for (int length = 0; length <= byte.MaxValue; length++)
             {
                 string[] a = new string[length];
-                ReadOnlySpan<string> target = new string[] { rnd.Next(0, 256).ToString(), "0" };
+                var target = new string[] { rnd.Next(0, 256).ToString(), "0" };
                 for (int i = 0; i < length; i++)
                 {
                     string val = (i + 1).ToString();
                     a[i] = val == target[0] ? (target[0] + 1) : val;
                 }
 
-                ReadOnlySpan<string> span = new ReadOnlySpan<string>(a);
-                Assert.Equal(0, span.Count(target));
+                Assert.Equal(0, new ReadOnlySpan<string>(a).Count(target));
+                Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(0, new ReadOnlySpan<string>(a).Count(target, comparer)));
             }
         }
 
@@ -319,8 +330,9 @@ public static void TestMultipleMatchCount_String()
 
                 a[^1] = a[^2] = "5555";
 
-                ReadOnlySpan<string> span = new ReadOnlySpan<string>(a);
-                Assert.Equal(2, span.Count("5555"));
+                Assert.Equal(2, new ReadOnlySpan<string>(a).Count("5555"));
+                Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(2, new ReadOnlySpan<string>(a).Count("5555", comparer)));
+                Assert.Equal(0, new ReadOnlySpan<string>(a).Count("5555", GetFalseEqualityComparer<string>()));
             }
         }
 
@@ -337,23 +349,28 @@ public static void TestMultipleMatchCount_RosString()
                 
                 a[0] = a[1] = a[^1] = a[^2] = "5555";
 
-                ReadOnlySpan<string> span = new ReadOnlySpan<string>(a);
-                Assert.Equal(2, span.Count(new string[] { "5555", "5555" }));
+                Assert.Equal(2, new ReadOnlySpan<string>(a).Count(new string[] { "5555", "5555" }));
+                Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(2, new ReadOnlySpan<string>(a).Count(new string[] { "5555", "5555" }, comparer)));
+                Assert.Equal(0, new ReadOnlySpan<string>(a).Count(new string[] { "5555", "5555" }, GetFalseEqualityComparer<string>()));
             }
         }
 
         [Fact]
         public static void TestOrdinalStringCount_String()
         {
-            ReadOnlySpan<string> span = new string[] { "ii", "II", "μμ", "ii" };
-            Assert.Equal(2, span.Count("ii"));
+            var arr = new string[] { "ii", "II", "μμ", "ii" };
+            Assert.Equal(2, new ReadOnlySpan<string>(arr).Count("ii"));
+            Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(2, new ReadOnlySpan<string>(arr).Count("ii", comparer)));
+            Assert.Equal(0, new ReadOnlySpan<string>(arr).Count("ii", GetFalseEqualityComparer<string>()));
         }
 
         [Fact]
         public static void TestOrdinalStringCount_RosString()
         {
-            ReadOnlySpan<string> span = new string[] { "ii", "II", "μμ", "ii", "μμ" };
-            Assert.Equal(1, span.Count(new string[] { "ii", "II" }));
+            var arr = new string[] { "ii", "II", "μμ", "ii", "μμ" };
+            Assert.Equal(1, new ReadOnlySpan<string>(arr).Count(new string[] { "ii", "II" }));
+            Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(1, new ReadOnlySpan<string>(arr).Count(new string[] { "ii", "II" }, comparer)));
+            Assert.Equal(0, new ReadOnlySpan<string>(arr).Count(new string[] { "ii", "II" }, GetFalseEqualityComparer<string>()));
         }
         
         [Fact]
@@ -367,17 +384,19 @@ public static void TestOverlapDoNotCount_RosChar()
         [MemberData(nameof(TestHelpers.CountNullData), MemberType = typeof(TestHelpers))]
         public static void CountNull_String(string[] spanInput, int expected)
         {
-            ReadOnlySpan<string> theStrings = spanInput;
-            Assert.Equal(expected, theStrings.Count((string)null));
+            Assert.Equal(expected, new ReadOnlySpan<string>(spanInput).Count((string)null));
+            Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(expected, new ReadOnlySpan<string>(spanInput).Count((string)null, comparer)));
+            Assert.Equal(0, new ReadOnlySpan<string>(spanInput).Count((string)null, GetFalseEqualityComparer<string>()));
         }
 
         [Theory]
         [MemberData(nameof(TestHelpers.CountNullRosData), MemberType = typeof(TestHelpers))]
         public static void CountNull_RosString(string[] spanInput, int expected)
         {
-            ReadOnlySpan<string> theStrings = spanInput;
-            ReadOnlySpan<string> target = new string[] { null, "9" };
-            Assert.Equal(expected, theStrings.Count(target));
+            var target = new string[] { null, "9" };
+            Assert.Equal(expected, new ReadOnlySpan<string>(spanInput).Count(target));
+            Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(expected, new ReadOnlySpan<string>(spanInput).Count(target, comparer)));
+            Assert.Equal(0, new ReadOnlySpan<string>(spanInput).Count(target, GetFalseEqualityComparer<string>()));
         }
     }
 }
diff --git a/src/libraries/System.Memory/tests/ReadOnlySpan/EndsWith.T.cs b/src/libraries/System.Memory/tests/ReadOnlySpan/EndsWith.T.cs
index 471e2613dd14a4..8813842745d4ba 100644
--- a/src/libraries/System.Memory/tests/ReadOnlySpan/EndsWith.T.cs
+++ b/src/libraries/System.Memory/tests/ReadOnlySpan/EndsWith.T.cs
@@ -12,39 +12,34 @@ public static void ZeroLengthEndsWith()
         {
             int[] a = new int[3];
 
-            ReadOnlySpan<int> first = new ReadOnlySpan<int>(a, 1, 0);
-            ReadOnlySpan<int> second = new ReadOnlySpan<int>(a, 2, 0);
-            bool b = first.EndsWith(second);
-            Assert.True(b);
+            Assert.True(new ReadOnlySpan<int>(a, 1, 0).EndsWith(new ReadOnlySpan<int>(a, 2, 0)));
+            Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.True(new ReadOnlySpan<int>(a, 1, 0).EndsWith(new ReadOnlySpan<int>(a, 2, 0), comparer)));
         }
 
         [Fact]
         public static void SameSpanEndsWith()
         {
             int[] a = { 4, 5, 6 };
-            ReadOnlySpan<int> span = new ReadOnlySpan<int>(a);
-            bool b = span.EndsWith(span);
-            Assert.True(b);
+            Assert.True(new ReadOnlySpan<int>(a).EndsWith(new ReadOnlySpan<int>(a)));
+            Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.True(new ReadOnlySpan<int>(a).EndsWith(new ReadOnlySpan<int>(a), comparer)));
+            Assert.False(new ReadOnlySpan<int>(a).EndsWith(new ReadOnlySpan<int>(a), GetFalseEqualityComparer<int>()));
         }
 
         [Fact]
         public static void LengthMismatchEndsWith()
         {
             int[] a = { 4, 5, 6 };
-            ReadOnlySpan<int> first = new ReadOnlySpan<int>(a, 0, 2);
-            ReadOnlySpan<int> second = new ReadOnlySpan<int>(a, 0, 3);
-            bool b = first.EndsWith(second);
-            Assert.False(b);
+            Assert.False(new ReadOnlySpan<int>(a, 0, 2).EndsWith(new ReadOnlySpan<int>(a, 0, 3)));
+            Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.False(new ReadOnlySpan<int>(a, 0, 2).EndsWith(new ReadOnlySpan<int>(a, 0, 3), comparer)));
         }
 
         [Fact]
         public static void EndsWithMatch()
         {
             int[] a = { 4, 5, 6 };
-            ReadOnlySpan<int> span = new ReadOnlySpan<int>(a, 0, 3);
-            ReadOnlySpan<int> slice = new ReadOnlySpan<int>(a, 1, 2);
-            bool b = span.EndsWith(slice);
-            Assert.True(b);
+            Assert.True(new ReadOnlySpan<int>(a, 0, 3).EndsWith(new ReadOnlySpan<int>(a, 1, 2)));
+            Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.True(new ReadOnlySpan<int>(a, 0, 3).EndsWith(new ReadOnlySpan<int>(a, 1, 2), comparer)));
+            Assert.False(new ReadOnlySpan<int>(a, 0, 3).EndsWith(new ReadOnlySpan<int>(a, 1, 2), GetFalseEqualityComparer<int>()));
         }
 
         [Fact]
@@ -52,10 +47,9 @@ public static void EndsWithMatchDifferentSpans()
         {
             int[] a = { 4, 5, 6 };
             int[] b = { 4, 5, 6 };
-            ReadOnlySpan<int> span = new ReadOnlySpan<int>(a, 0, 3);
-            ReadOnlySpan<int> slice = new ReadOnlySpan<int>(b, 0, 3);
-            bool c = span.EndsWith(slice);
-            Assert.True(c);
+            Assert.True(new ReadOnlySpan<int>(a, 0, 3).EndsWith(new ReadOnlySpan<int>(b, 0, 3)));
+            Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.True(new ReadOnlySpan<int>(a, 0, 3).EndsWith(new ReadOnlySpan<int>(b, 0, 3), comparer)));
+            Assert.False(new ReadOnlySpan<int>(a, 0, 3).EndsWith(new ReadOnlySpan<int>(b, 0, 3), GetFalseEqualityComparer<int>()));
         }
 
         [Fact]
@@ -74,8 +68,7 @@ public static void OnEndsWithOfEqualSpansMakeSureEveryElementIsCompared()
 
                 ReadOnlySpan<TInt> firstSpan = new ReadOnlySpan<TInt>(first);
                 ReadOnlySpan<TInt> secondSpan = new ReadOnlySpan<TInt>(second);
-                bool b = firstSpan.EndsWith(secondSpan);
-                Assert.True(b);
+                Assert.True(firstSpan.EndsWith(secondSpan));
 
                 // Make sure each element of the array was compared once. (Strictly speaking, it would not be illegal for
                 // EndsWith to compare an element more than once but that would be a non-optimal implementation and
diff --git a/src/libraries/System.Memory/tests/ReadOnlySpan/IndexOf.T.cs b/src/libraries/System.Memory/tests/ReadOnlySpan/IndexOf.T.cs
index 42111dbd2808e3..933d98671f95b7 100644
--- a/src/libraries/System.Memory/tests/ReadOnlySpan/IndexOf.T.cs
+++ b/src/libraries/System.Memory/tests/ReadOnlySpan/IndexOf.T.cs
@@ -10,9 +10,8 @@ public static partial class ReadOnlySpanTests
         [Fact]
         public static void ZeroLengthIndexOf()
         {
-            ReadOnlySpan<int> sp = new ReadOnlySpan<int>(Array.Empty<int>());
-            int idx = sp.IndexOf(0);
-            Assert.Equal(-1, idx);
+            Assert.Equal(-1, new ReadOnlySpan<int>(Array.Empty<int>()).IndexOf(0));
+            Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(-1, new ReadOnlySpan<int>(Array.Empty<int>()).IndexOf(0, comparer)));
         }
 
         [Fact]
@@ -25,13 +24,13 @@ public static void TestMatch()
                 {
                     a[i] = 10 * (i + 1);
                 }
-                ReadOnlySpan<int> span = new ReadOnlySpan<int>(a);
 
                 for (int targetIndex = 0; targetIndex < length; targetIndex++)
                 {
                     int target = a[targetIndex];
-                    int idx = span.IndexOf(target);
-                    Assert.Equal(targetIndex, idx);
+                    Assert.Equal(targetIndex, new ReadOnlySpan<int>(a).IndexOf(target));
+                    Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(targetIndex, new ReadOnlySpan<int>(a).IndexOf(target, comparer)));
+                    Assert.Equal(-1, new ReadOnlySpan<int>(a).IndexOf(target, GetFalseEqualityComparer<int>()));
                 }
             }
         }
@@ -50,9 +49,9 @@ public static void TestMultipleMatch()
                 a[length - 1] = 5555;
                 a[length - 2] = 5555;
 
-                ReadOnlySpan<int> span = new ReadOnlySpan<int>(a);
-                int idx = span.IndexOf(5555);
-                Assert.Equal(length - 2, idx);
+                Assert.Equal(length - 2, new ReadOnlySpan<int>(a).IndexOf(5555));
+                Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(length - 2, new ReadOnlySpan<int>(a).IndexOf(5555, comparer)));
+                Assert.Equal(-1, new ReadOnlySpan<int>(a).IndexOf(5555, GetFalseEqualityComparer<int>()));
             }
         }
 
@@ -110,18 +109,16 @@ public static void MakeSureNoChecksGoOutOfRange()
                     a[GuardLength + i] = new TInt(10 * (i + 1), checkForOutOfRangeAccess);
                 }
 
-                ReadOnlySpan<TInt> span = new ReadOnlySpan<TInt>(a, GuardLength, length);
-                int idx = span.IndexOf(new TInt(9999, checkForOutOfRangeAccess));
-                Assert.Equal(-1, idx);
+                Assert.Equal(-1, new ReadOnlySpan<TInt>(a, GuardLength, length).IndexOf(new TInt(9999, checkForOutOfRangeAccess)));
+                Assert.All(GetDefaultEqualityComparers<TInt>(), comparer => Assert.Equal(-1, new ReadOnlySpan<TInt>(a, GuardLength, length).IndexOf(new TInt(9999, checkForOutOfRangeAccess), comparer)));
             }
         }
 
         [Fact]
         public static void ZeroLengthIndexOf_String()
         {
-            ReadOnlySpan<string> sp = new ReadOnlySpan<string>(Array.Empty<string>());
-            int idx = sp.IndexOf("a");
-            Assert.Equal(-1, idx);
+            Assert.Equal(-1, new ReadOnlySpan<string>(Array.Empty<string>()).IndexOf("a"));
+            Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(-1, new ReadOnlySpan<string>(Array.Empty<string>()).IndexOf("a", comparer)));
         }
 
         [Fact]
@@ -134,13 +131,12 @@ public static void TestMatchIndexOf_String()
                 {
                     a[i] = (10 * (i + 1)).ToString();
                 }
-                ReadOnlySpan<string> span = new ReadOnlySpan<string>(a);
 
                 for (int targetIndex = 0; targetIndex < length; targetIndex++)
                 {
-                    string target = a[targetIndex];
-                    int idx = span.IndexOf(target);
-                    Assert.Equal(targetIndex, idx);
+                    Assert.Equal(targetIndex, new ReadOnlySpan<string>(a).IndexOf(a[targetIndex]));
+                    Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(targetIndex, new ReadOnlySpan<string>(a).IndexOf(a[targetIndex], comparer)));
+                    Assert.Equal(-1, new ReadOnlySpan<string>(a).IndexOf(a[targetIndex], GetFalseEqualityComparer<string>()));
                 }
             }
         }
@@ -158,10 +154,9 @@ public static void TestNoMatchIndexOf_String()
                     string val = (i + 1).ToString();
                     a[i] = val == target ? (target + 1) : val;
                 }
-                ReadOnlySpan<string> span = new ReadOnlySpan<string>(a);
 
-                int idx = span.IndexOf(target);
-                Assert.Equal(-1, idx);
+                Assert.Equal(-1, new ReadOnlySpan<string>(a).IndexOf(target));
+                Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(-1, new ReadOnlySpan<string>(a).IndexOf(target, comparer)));
             }
         }
 
@@ -179,9 +174,9 @@ public static void TestMultipleMatchIndexOf_String()
                 a[length - 1] = "5555";
                 a[length - 2] = "5555";
 
-                ReadOnlySpan<string> span = new ReadOnlySpan<string>(a);
-                int idx = span.IndexOf("5555");
-                Assert.Equal(length - 2, idx);
+                Assert.Equal(length - 2, new ReadOnlySpan<string>(a).IndexOf("5555"));
+                Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(length - 2, new ReadOnlySpan<string>(a).IndexOf("5555", comparer)));
+                Assert.Equal(-1, new ReadOnlySpan<string>(a).IndexOf("5555", GetFalseEqualityComparer<string>()));
             }
         }
 
@@ -189,8 +184,9 @@ public static void TestMultipleMatchIndexOf_String()
         [MemberData(nameof(TestHelpers.IndexOfNullData), MemberType = typeof(TestHelpers))]
         public static void IndexOfNull_String(string[] spanInput, int expected)
         {
-            ReadOnlySpan<string> theStrings = spanInput;
-            Assert.Equal(expected, theStrings.IndexOf((string)null));
+            Assert.Equal(expected, new ReadOnlySpan<string>(spanInput).IndexOf((string)null));
+            Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(expected, new ReadOnlySpan<string>(spanInput).IndexOf((string)null, comparer)));
+            Assert.Equal(-1, new ReadOnlySpan<string>(spanInput).IndexOf((string)null, GetFalseEqualityComparer<string>()));
         }
     }
 }
diff --git a/src/libraries/System.Memory/tests/ReadOnlySpan/IndexOfAny.T.cs b/src/libraries/System.Memory/tests/ReadOnlySpan/IndexOfAny.T.cs
index 70e2f177c49e2f..da57b026907644 100644
--- a/src/libraries/System.Memory/tests/ReadOnlySpan/IndexOfAny.T.cs
+++ b/src/libraries/System.Memory/tests/ReadOnlySpan/IndexOfAny.T.cs
@@ -10,9 +10,8 @@ public static partial class ReadOnlySpanTests
         [Fact]
         public static void ZeroLengthIndexOfAny_TwoInteger()
         {
-            var sp = new ReadOnlySpan<int>(Array.Empty<int>());
-            int idx = sp.IndexOfAny(0, 0);
-            Assert.Equal(-1, idx);
+            Assert.Equal(-1, new ReadOnlySpan<int>(Array.Empty<int>()).IndexOfAny(0, 0));
+            Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(-1, new ReadOnlySpan<int>(Array.Empty<int>()).IndexOfAny(0, 0, comparer)));
         }
 
         [Fact]
@@ -23,7 +22,6 @@ public static void DefaultFilledIndexOfAny_TwoInteger()
             for (int length = 0; length < byte.MaxValue; length++)
             {
                 var a = new int[length];
-                var span = new ReadOnlySpan<int>(a);
 
                 int[] targets = { default, 99 };
 
@@ -32,8 +30,9 @@ public static void DefaultFilledIndexOfAny_TwoInteger()
                     int index = rnd.Next(0, 2) == 0 ? 0 : 1;
                     int target0 = targets[index];
                     int target1 = targets[(index + 1) % 2];
-                    int idx = span.IndexOfAny(target0, target1);
-                    Assert.Equal(0, idx);
+                    Assert.Equal(0, new ReadOnlySpan<int>(a).IndexOfAny(target0, target1));
+                    Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(0, new ReadOnlySpan<int>(a).IndexOfAny(target0, target1, comparer)));
+                    Assert.Equal(-1, new ReadOnlySpan<int>(a).IndexOfAny(target0, target1, GetFalseEqualityComparer<int>()));
                 }
             }
         }
@@ -50,14 +49,14 @@ public static void TestMatchIndexOfAny_TwoInteger()
                 {
                     a[i] = i + 1;
                 }
-                var span = new ReadOnlySpan<int>(a);
 
                 for (int targetIndex = 0; targetIndex < length; targetIndex++)
                 {
                     int target0 = a[targetIndex];
                     int target1 = 0;
-                    int idx = span.IndexOfAny(target0, target1);
-                    Assert.Equal(targetIndex, idx);
+                    Assert.Equal(targetIndex, new ReadOnlySpan<int>(a).IndexOfAny(target0, target1));
+                    Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(targetIndex, new ReadOnlySpan<int>(a).IndexOfAny(target0, target1, comparer)));
+                    Assert.Equal(-1, new ReadOnlySpan<int>(a).IndexOfAny(target0, target1, GetFalseEqualityComparer<int>()));
                 }
 
                 for (int targetIndex = 0; targetIndex < length - 1; targetIndex++)
@@ -65,16 +64,18 @@ public static void TestMatchIndexOfAny_TwoInteger()
                     int index = rnd.Next(0, 2) == 0 ? 0 : 1;
                     int target0 = a[targetIndex + index];
                     int target1 = a[targetIndex + (index + 1) % 2];
-                    int idx = span.IndexOfAny(target0, target1);
-                    Assert.Equal(targetIndex, idx);
+                    Assert.Equal(targetIndex, new ReadOnlySpan<int>(a).IndexOfAny(target0, target1));
+                    Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(targetIndex, new ReadOnlySpan<int>(a).IndexOfAny(target0, target1, comparer)));
+                    Assert.Equal(-1, new ReadOnlySpan<int>(a).IndexOfAny(target0, target1, GetFalseEqualityComparer<int>()));
                 }
 
                 for (int targetIndex = 0; targetIndex < length; targetIndex++)
                 {
                     int target0 = 0;
                     int target1 = a[targetIndex];
-                    int idx = span.IndexOfAny(target0, target1);
-                    Assert.Equal(targetIndex, idx);
+                    Assert.Equal(targetIndex, new ReadOnlySpan<int>(a).IndexOfAny(target0, target1));
+                    Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(targetIndex, new ReadOnlySpan<int>(a).IndexOfAny(target0, target1, comparer)));
+                    Assert.Equal(-1, new ReadOnlySpan<int>(a).IndexOfAny(target0, target1, GetFalseEqualityComparer<int>()));
                 }
             }
         }
@@ -88,10 +89,9 @@ public static void TestNoMatchIndexOfAny_TwoInteger()
                 var a = new int[length];
                 int target0 = rnd.Next(1, 256);
                 int target1 = rnd.Next(1, 256);
-                var span = new ReadOnlySpan<int>(a);
 
-                int idx = span.IndexOfAny(target0, target1);
-                Assert.Equal(-1, idx);
+                Assert.Equal(-1, new ReadOnlySpan<int>(a).IndexOfAny(target0, target1));
+                Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(-1, new ReadOnlySpan<int>(a).IndexOfAny(target0, target1, comparer)));
             }
         }
 
@@ -111,9 +111,9 @@ public static void TestMultipleMatchIndexOfAny_TwoInteger()
                 a[length - 2] = 200;
                 a[length - 3] = 200;
 
-                var span = new ReadOnlySpan<int>(a);
-                int idx = span.IndexOfAny(200, 200);
-                Assert.Equal(length - 3, idx);
+                Assert.Equal(length - 3, new ReadOnlySpan<int>(a).IndexOfAny(200, 200));
+                Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(length - 3, new ReadOnlySpan<int>(a).IndexOfAny(200, 200, comparer)));
+                Assert.Equal(-1, new ReadOnlySpan<int>(a).IndexOfAny(200, 200, GetFalseEqualityComparer<int>()));
             }
         }
 
@@ -125,9 +125,9 @@ public static void MakeSureNoChecksGoOutOfRangeIndexOfAny_TwoInteger()
                 var a = new int[length + 2];
                 a[0] = 99;
                 a[length + 1] = 98;
-                var span = new ReadOnlySpan<int>(a, 1, length - 1);
-                int index = span.IndexOfAny(99, 98);
-                Assert.Equal(-1, index);
+
+                Assert.Equal(-1, new ReadOnlySpan<int>(a, 1, length - 1).IndexOfAny(99, 98));
+                Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(-1, new ReadOnlySpan<int>(a, 1, length - 1).IndexOfAny(99, 98, comparer)));
             }
 
             for (int length = 1; length < byte.MaxValue; length++)
@@ -135,18 +135,17 @@ public static void MakeSureNoChecksGoOutOfRangeIndexOfAny_TwoInteger()
                 var a = new int[length + 2];
                 a[0] = 99;
                 a[length + 1] = 99;
-                var span = new ReadOnlySpan<int>(a, 1, length - 1);
-                int index = span.IndexOfAny(99, 99);
-                Assert.Equal(-1, index);
+
+                Assert.Equal(-1, new ReadOnlySpan<int>(a, 1, length - 1).IndexOfAny(99, 99));
+                Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(-1, new ReadOnlySpan<int>(a, 1, length - 1).IndexOfAny(99, 99, comparer)));
             }
         }
 
         [Fact]
         public static void ZeroLengthIndexOfAny_ThreeInteger()
         {
-            var sp = new ReadOnlySpan<int>(Array.Empty<int>());
-            int idx = sp.IndexOfAny(0, 0, 0);
-            Assert.Equal(-1, idx);
+            Assert.Equal(-1, new ReadOnlySpan<int>(Array.Empty<int>()).IndexOfAny(0, 0, 0));
+            Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(-1, new ReadOnlySpan<int>(Array.Empty<int>()).IndexOfAny(0, 0, 0)));
         }
 
         [Fact]
@@ -157,7 +156,6 @@ public static void DefaultFilledIndexOfAny_ThreeInteger()
             for (int length = 0; length < byte.MaxValue; length++)
             {
                 var a = new int[length];
-                var span = new ReadOnlySpan<int>(a);
 
                 int[] targets = { default, 99, 98 };
 
@@ -167,8 +165,10 @@ public static void DefaultFilledIndexOfAny_ThreeInteger()
                     int target0 = targets[index];
                     int target1 = targets[(index + 1) % 2];
                     int target2 = targets[(index + 1) % 3];
-                    int idx = span.IndexOfAny(target0, target1, target2);
-                    Assert.Equal(0, idx);
+
+                    Assert.Equal(0, new ReadOnlySpan<int>(a).IndexOfAny(target0, target1, target2));
+                    Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(0, new ReadOnlySpan<int>(a).IndexOfAny(target0, target1, target2, comparer)));
+                    Assert.Equal(-1, new ReadOnlySpan<int>(a).IndexOfAny(target0, target1, target2, GetFalseEqualityComparer<int>()));
                 }
             }
         }
@@ -185,15 +185,16 @@ public static void TestMatchIndexOfAny_ThreeInteger()
                 {
                     a[i] = i + 1;
                 }
-                var span = new ReadOnlySpan<int>(a);
 
                 for (int targetIndex = 0; targetIndex < length; targetIndex++)
                 {
                     int target0 = a[targetIndex];
                     int target1 = 0;
                     int target2 = 0;
-                    int idx = span.IndexOfAny(target0, target1, target2);
-                    Assert.Equal(targetIndex, idx);
+
+                    Assert.Equal(targetIndex, new ReadOnlySpan<int>(a).IndexOfAny(target0, target1, target2));
+                    Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(targetIndex, new ReadOnlySpan<int>(a).IndexOfAny(target0, target1, target2, comparer)));
+                    Assert.Equal(-1, new ReadOnlySpan<int>(a).IndexOfAny(target0, target1, target2, GetFalseEqualityComparer<int>()));
                 }
 
                 for (int targetIndex = 0; targetIndex < length - 2; targetIndex++)
@@ -202,8 +203,10 @@ public static void TestMatchIndexOfAny_ThreeInteger()
                     int target0 = a[targetIndex + index];
                     int target1 = a[targetIndex + (index + 1) % 2];
                     int target2 = a[targetIndex + (index + 1) % 3];
-                    int idx = span.IndexOfAny(target0, target1, target2);
-                    Assert.Equal(targetIndex, idx);
+
+                    Assert.Equal(targetIndex, new ReadOnlySpan<int>(a).IndexOfAny(target0, target1, target2));
+                    Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(targetIndex, new ReadOnlySpan<int>(a).IndexOfAny(target0, target1, target2, comparer)));
+                    Assert.Equal(-1, new ReadOnlySpan<int>(a).IndexOfAny(target0, target1, target2, GetFalseEqualityComparer<int>()));
                 }
 
                 for (int targetIndex = 0; targetIndex < length; targetIndex++)
@@ -211,8 +214,10 @@ public static void TestMatchIndexOfAny_ThreeInteger()
                     int target0 = 0;
                     int target1 = 0;
                     int target2 = a[targetIndex];
-                    int idx = span.IndexOfAny(target0, target1, target2);
-                    Assert.Equal(targetIndex, idx);
+
+                    Assert.Equal(targetIndex, new ReadOnlySpan<int>(a).IndexOfAny(target0, target1, target2));
+                    Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(targetIndex, new ReadOnlySpan<int>(a).IndexOfAny(target0, target1, target2, comparer)));
+                    Assert.Equal(-1, new ReadOnlySpan<int>(a).IndexOfAny(target0, target1, target2, GetFalseEqualityComparer<int>()));
                 }
             }
         }
@@ -227,10 +232,9 @@ public static void TestNoMatchIndexOfAny_ThreeInteger()
                 int target0 = rnd.Next(1, 256);
                 int target1 = rnd.Next(1, 256);
                 int target2 = rnd.Next(1, 256);
-                var span = new ReadOnlySpan<int>(a);
 
-                int idx = span.IndexOfAny(target0, target1, target2);
-                Assert.Equal(-1, idx);
+                Assert.Equal(-1, new ReadOnlySpan<int>(a).IndexOfAny(target0, target1, target2));
+                Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(-1, new ReadOnlySpan<int>(a).IndexOfAny(target0, target1, target2, comparer)));
             }
         }
 
@@ -251,9 +255,9 @@ public static void TestMultipleMatchIndexOfAny_ThreeInteger()
                 a[length - 3] = 200;
                 a[length - 4] = 200;
 
-                var span = new ReadOnlySpan<int>(a);
-                int idx = span.IndexOfAny(200, 200, 200);
-                Assert.Equal(length - 4, idx);
+                Assert.Equal(length - 4, new ReadOnlySpan<int>(a).IndexOfAny(200, 200, 200));
+                Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(length - 4, new ReadOnlySpan<int>(a).IndexOfAny(200, 200, 200, comparer)));
+                Assert.Equal(-1, new ReadOnlySpan<int>(a).IndexOfAny(200, 200, 200, GetFalseEqualityComparer<int>()));
             }
         }
 
@@ -265,9 +269,9 @@ public static void MakeSureNoChecksGoOutOfRangeIndexOfAny_ThreeInteger()
                 var a = new int[length + 2];
                 a[0] = 99;
                 a[length + 1] = 98;
-                var span = new ReadOnlySpan<int>(a, 1, length - 1);
-                int index = span.IndexOfAny(99, 98, 99);
-                Assert.Equal(-1, index);
+
+                Assert.Equal(-1, new ReadOnlySpan<int>(a, 1, length - 1).IndexOfAny(99, 98, 99));
+                Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(-1, new ReadOnlySpan<int>(a, 1, length - 1).IndexOfAny(99, 98, 99, comparer)));
             }
 
             for (int length = 1; length < byte.MaxValue; length++)
@@ -275,23 +279,22 @@ public static void MakeSureNoChecksGoOutOfRangeIndexOfAny_ThreeInteger()
                 var a = new int[length + 2];
                 a[0] = 99;
                 a[length + 1] = 99;
-                var span = new ReadOnlySpan<int>(a, 1, length - 1);
-                int index = span.IndexOfAny(99, 99, 99);
-                Assert.Equal(-1, index);
+
+                Assert.Equal(-1, new ReadOnlySpan<int>(a, 1, length - 1).IndexOfAny(99, 99, 99));
+                Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(-1, new ReadOnlySpan<int>(a, 1, length - 1).IndexOfAny(99, 99, 99, comparer)));
             }
         }
 
         [Fact]
         public static void ZeroLengthIndexOfAny_ManyInteger()
         {
-            var sp = new ReadOnlySpan<int>(Array.Empty<int>());
-            var values = new ReadOnlySpan<int>(new int[] { 0, 0, 0, 0 });
-            int idx = sp.IndexOfAny(values);
-            Assert.Equal(-1, idx);
+            var values = new int[] { 0, 0, 0, 0 };
+            Assert.Equal(-1, new ReadOnlySpan<int>(Array.Empty<int>()).IndexOfAny(values));
+            Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(-1, new ReadOnlySpan<int>(Array.Empty<int>()).IndexOfAny(values, comparer)));
 
-            values = new ReadOnlySpan<int>(new int[] { });
-            idx = sp.IndexOfAny(values);
-            Assert.Equal(-1, idx);
+            values = new int[] { };
+            Assert.Equal(-1, new ReadOnlySpan<int>(Array.Empty<int>()).IndexOfAny(values));
+            Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(-1, new ReadOnlySpan<int>(Array.Empty<int>()).IndexOfAny(values, comparer)));
         }
 
         [Fact]
@@ -300,14 +303,13 @@ public static void DefaultFilledIndexOfAny_ManyInteger()
             for (int length = 0; length < byte.MaxValue; length++)
             {
                 var a = new int[length];
-                var span = new ReadOnlySpan<int>(a);
-
-                var values = new ReadOnlySpan<int>(new int[] { default, 99, 98, 0 });
+                var values = new int[] { default, 99, 98, 0 };
 
                 for (int i = 0; i < length; i++)
                 {
-                    int idx = span.IndexOfAny(values);
-                    Assert.Equal(0, idx);
+                    Assert.Equal(0, new ReadOnlySpan<int>(a).IndexOfAny(values));
+                    Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(0, new ReadOnlySpan<int>(a).IndexOfAny(values, comparer)));
+                    Assert.Equal(-1, new ReadOnlySpan<int>(a).IndexOfAny(values, GetFalseEqualityComparer<int>()));
                 }
             }
         }
@@ -324,34 +326,35 @@ public static void TestMatchIndexOfAny_ManyInteger()
                 {
                     a[i] = i + 1;
                 }
-                var span = new ReadOnlySpan<int>(a);
 
                 for (int targetIndex = 0; targetIndex < length; targetIndex++)
                 {
-                    var values = new ReadOnlySpan<int>(new int[] { a[targetIndex], 0, 0, 0 });
-                    int idx = span.IndexOfAny(values);
-                    Assert.Equal(targetIndex, idx);
+                    Assert.Equal(targetIndex, new ReadOnlySpan<int>(a).IndexOfAny(new ReadOnlySpan<int>(new int[] { a[targetIndex], 0, 0, 0 })));
+                    Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(targetIndex, new ReadOnlySpan<int>(a).IndexOfAny(new ReadOnlySpan<int>(new int[] { a[targetIndex], 0, 0, 0 }), comparer)));
+                    Assert.Equal(-1, new ReadOnlySpan<int>(a).IndexOfAny(new ReadOnlySpan<int>(new int[] { a[targetIndex], 0, 0, 0 }), GetFalseEqualityComparer<int>()));
                 }
 
                 for (int targetIndex = 0; targetIndex < length - 3; targetIndex++)
                 {
                     int index = rnd.Next(0, 4) == 0 ? 0 : 1;
-                    var values = new ReadOnlySpan<int>(new int[]
+                    var values = new int[]
                         {
                             a[targetIndex + index],
                             a[targetIndex + (index + 1) % 2],
                             a[targetIndex + (index + 1) % 3],
                             a[targetIndex + (index + 1) % 4]
-                        });
-                    int idx = span.IndexOfAny(values);
-                    Assert.Equal(targetIndex, idx);
+                        };
+
+                    Assert.Equal(targetIndex, new ReadOnlySpan<int>(a).IndexOfAny(values));
+                    Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(targetIndex, new ReadOnlySpan<int>(a).IndexOfAny(values, comparer)));
+                    Assert.Equal(-1, new ReadOnlySpan<int>(a).IndexOfAny(values, GetFalseEqualityComparer<int>()));
                 }
 
                 for (int targetIndex = 0; targetIndex < length; targetIndex++)
                 {
-                    var values = new ReadOnlySpan<int>(new int[] { 0, 0, 0, a[targetIndex] });
-                    int idx = span.IndexOfAny(values);
-                    Assert.Equal(targetIndex, idx);
+                    Assert.Equal(targetIndex, new ReadOnlySpan<int>(a).IndexOfAny(new ReadOnlySpan<int>(new int[] { 0, 0, 0, a[targetIndex] })));
+                    Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(targetIndex, new ReadOnlySpan<int>(a).IndexOfAny(new ReadOnlySpan<int>(new int[] { 0, 0, 0, a[targetIndex] }), comparer)));
+                    Assert.Equal(-1, new ReadOnlySpan<int>(a).IndexOfAny(new ReadOnlySpan<int>(new int[] { 0, 0, 0, a[targetIndex] }), GetFalseEqualityComparer<int>()));
                 }
             }
         }
@@ -372,7 +375,6 @@ public static void TestMatchValuesLargerIndexOfAny_ManyInteger()
                     }
                     a[i] = 255;
                 }
-                var span = new ReadOnlySpan<int>(a);
 
                 var targets = new int[length * 2];
                 for (int i = 0; i < targets.Length; i++)
@@ -384,9 +386,9 @@ public static void TestMatchValuesLargerIndexOfAny_ManyInteger()
                     targets[i] = rnd.Next(1, 255);
                 }
 
-                var values = new ReadOnlySpan<int>(targets);
-                int idx = span.IndexOfAny(values);
-                Assert.Equal(expectedIndex, idx);
+                Assert.Equal(expectedIndex, new ReadOnlySpan<int>(a).IndexOfAny(new ReadOnlySpan<int>(targets)));
+                Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(expectedIndex, new ReadOnlySpan<int>(a).IndexOfAny(new ReadOnlySpan<int>(targets), comparer)));
+                Assert.Equal(-1, new ReadOnlySpan<int>(a).IndexOfAny(new ReadOnlySpan<int>(targets), GetFalseEqualityComparer<int>()));
             }
         }
 
@@ -402,11 +404,9 @@ public static void TestNoMatchIndexOfAny_ManyInteger()
                 {
                     targets[i] = rnd.Next(1, 256);
                 }
-                var span = new ReadOnlySpan<int>(a);
-                var values = new ReadOnlySpan<int>(targets);
 
-                int idx = span.IndexOfAny(values);
-                Assert.Equal(-1, idx);
+                Assert.Equal(-1, new ReadOnlySpan<int>(a).IndexOfAny(targets));
+                Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(-1, new ReadOnlySpan<int>(a).IndexOfAny(targets, comparer)));
             }
         }
 
@@ -422,11 +422,9 @@ public static void TestNoMatchValuesLargerIndexOfAny_ManyInteger()
                 {
                     targets[i] = rnd.Next(1, 256);
                 }
-                var span = new ReadOnlySpan<int>(a);
-                var values = new ReadOnlySpan<int>(targets);
 
-                int idx = span.IndexOfAny(values);
-                Assert.Equal(-1, idx);
+                Assert.Equal(-1, new ReadOnlySpan<int>(a).IndexOfAny(targets));
+                Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(-1, new ReadOnlySpan<int>(a).IndexOfAny(targets, comparer)));
             }
         }
 
@@ -448,10 +446,11 @@ public static void TestMultipleMatchIndexOfAny_ManyInteger()
                 a[length - 4] = 200;
                 a[length - 5] = 200;
 
-                var span = new ReadOnlySpan<int>(a);
-                var values = new ReadOnlySpan<int>(new int[] { 200, 200, 200, 200, 200, 200, 200, 200, 200 });
-                int idx = span.IndexOfAny(values);
-                Assert.Equal(length - 5, idx);
+                var values = new int[] { 200, 200, 200, 200, 200, 200, 200, 200, 200 };
+
+                Assert.Equal(length - 5, new ReadOnlySpan<int>(a).IndexOfAny(values));
+                Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(length - 5, new ReadOnlySpan<int>(a).IndexOfAny(values, comparer)));
+                Assert.Equal(-1, new ReadOnlySpan<int>(a).IndexOfAny(values, GetFalseEqualityComparer<int>()));
             }
         }
 
@@ -463,10 +462,10 @@ public static void MakeSureNoChecksGoOutOfRangeIndexOfAny_ManyInteger()
                 var a = new int[length + 2];
                 a[0] = 99;
                 a[length + 1] = 98;
-                var span = new ReadOnlySpan<int>(a, 1, length - 1);
-                var values = new ReadOnlySpan<int>(new int[] { 99, 98, 99, 98, 99, 98 });
-                int index = span.IndexOfAny(values);
-                Assert.Equal(-1, index);
+                var values = new int[] { 99, 98, 99, 98, 99, 98 };
+
+                Assert.Equal(-1, new ReadOnlySpan<int>(a, 1, length - 1).IndexOfAny(values));
+                Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(-1, new ReadOnlySpan<int>(a, 1, length - 1).IndexOfAny(values, comparer)));
             }
 
             for (int length = 1; length < byte.MaxValue; length++)
@@ -474,19 +473,19 @@ public static void MakeSureNoChecksGoOutOfRangeIndexOfAny_ManyInteger()
                 var a = new int[length + 2];
                 a[0] = 99;
                 a[length + 1] = 99;
-                var span = new ReadOnlySpan<int>(a, 1, length - 1);
-                var values = new ReadOnlySpan<int>(new int[] { 99, 99, 99, 99, 99, 99 });
-                int index = span.IndexOfAny(values);
-                Assert.Equal(-1, index);
+
+                var values = new int[] { 99, 99, 99, 99, 99, 99 };
+
+                Assert.Equal(-1, new ReadOnlySpan<int>(a, 1, length - 1).IndexOfAny(values));
+                Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(-1, new ReadOnlySpan<int>(a, 1, length - 1).IndexOfAny(values, comparer)));
             }
         }
 
         [Fact]
         public static void ZeroLengthIndexOfAny_TwoString()
         {
-            var sp = new ReadOnlySpan<string>(Array.Empty<string>());
-            int idx = sp.IndexOfAny("0", "0");
-            Assert.Equal(-1, idx);
+            Assert.Equal(-1, new ReadOnlySpan<string>(Array.Empty<string>()).IndexOfAny("0", "0"));
+            Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(-1, new ReadOnlySpan<string>(Array.Empty<string>()).IndexOfAny("0", "0", comparer)));
         }
 
         [Fact]
@@ -497,9 +496,7 @@ public static void DefaultFilledIndexOfAny_TwoString()
             for (int length = 0; length < byte.MaxValue; length++)
             {
                 var a = new string[length];
-                var tempSpan = new Span<string>(a);
-                tempSpan.Fill("");
-                ReadOnlySpan<string> span = tempSpan;
+                Array.Fill(a, "");
 
                 string[] targets = { "", "99" };
 
@@ -508,8 +505,10 @@ public static void DefaultFilledIndexOfAny_TwoString()
                     int index = rnd.Next(0, 2) == 0 ? 0 : 1;
                     string target0 = targets[index];
                     string target1 = targets[(index + 1) % 2];
-                    int idx = span.IndexOfAny(target0, target1);
-                    Assert.Equal(0, idx);
+
+                    Assert.Equal(0, new ReadOnlySpan<string>(a).IndexOfAny(target0, target1));
+                    Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(0, new ReadOnlySpan<string>(a).IndexOfAny(target0, target1, comparer)));
+                    Assert.Equal(-1, new ReadOnlySpan<string>(a).IndexOfAny(target0, target1, GetFalseEqualityComparer<string>()));
                 }
             }
         }
@@ -526,14 +525,15 @@ public static void TestMatchIndexOfAny_TwoString()
                 {
                     a[i] = (i + 1).ToString();
                 }
-                var span = new ReadOnlySpan<string>(a);
 
                 for (int targetIndex = 0; targetIndex < length; targetIndex++)
                 {
                     string target0 = a[targetIndex];
                     string target1 = "0";
-                    int idx = span.IndexOfAny(target0, target1);
-                    Assert.Equal(targetIndex, idx);
+
+                    Assert.Equal(targetIndex, new ReadOnlySpan<string>(a).IndexOfAny(target0, target1));
+                    Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(targetIndex, new ReadOnlySpan<string>(a).IndexOfAny(target0, target1, comparer)));
+                    Assert.Equal(-1, new ReadOnlySpan<string>(a).IndexOfAny(target0, target1, GetFalseEqualityComparer<string>()));
                 }
 
                 for (int targetIndex = 0; targetIndex < length - 1; targetIndex++)
@@ -541,16 +541,20 @@ public static void TestMatchIndexOfAny_TwoString()
                     int index = rnd.Next(0, 2) == 0 ? 0 : 1;
                     string target0 = a[targetIndex + index];
                     string target1 = a[targetIndex + (index + 1) % 2];
-                    int idx = span.IndexOfAny(target0, target1);
-                    Assert.Equal(targetIndex, idx);
+
+                    Assert.Equal(targetIndex, new ReadOnlySpan<string>(a).IndexOfAny(target0, target1));
+                    Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(targetIndex, new ReadOnlySpan<string>(a).IndexOfAny(target0, target1, comparer)));
+                    Assert.Equal(-1, new ReadOnlySpan<string>(a).IndexOfAny(target0, target1, GetFalseEqualityComparer<string>()));
                 }
 
                 for (int targetIndex = 0; targetIndex < length - 1; targetIndex++)
                 {
                     string target0 = "0";
                     string target1 = a[targetIndex + 1];
-                    int idx = span.IndexOfAny(target0, target1);
-                    Assert.Equal(targetIndex + 1, idx);
+
+                    Assert.Equal(targetIndex + 1, new ReadOnlySpan<string>(a).IndexOfAny(target0, target1));
+                    Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(targetIndex + 1, new ReadOnlySpan<string>(a).IndexOfAny(target0, target1, comparer)));
+                    Assert.Equal(-1, new ReadOnlySpan<string>(a).IndexOfAny(target0, target1, GetFalseEqualityComparer<string>()));
                 }
             }
         }
@@ -564,10 +568,9 @@ public static void TestNoMatchIndexOfAny_TwoString()
                 var a = new string[length];
                 string target0 = rnd.Next(1, 256).ToString();
                 string target1 = rnd.Next(1, 256).ToString();
-                var span = new ReadOnlySpan<string>(a);
 
-                int idx = span.IndexOfAny(target0, target1);
-                Assert.Equal(-1, idx);
+                Assert.Equal(-1, new ReadOnlySpan<string>(a).IndexOfAny(target0, target1));
+                Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(-1, new ReadOnlySpan<string>(a).IndexOfAny(target0, target1, comparer)));
             }
         }
 
@@ -587,9 +590,9 @@ public static void TestMultipleMatchIndexOfAny_TwoString()
                 a[length - 2] = "200";
                 a[length - 3] = "200";
 
-                var span = new ReadOnlySpan<string>(a);
-                int idx = span.IndexOfAny("200", "200");
-                Assert.Equal(length - 3, idx);
+                Assert.Equal(length - 3, new ReadOnlySpan<string>(a).IndexOfAny("200", "200"));
+                Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(length - 3, new ReadOnlySpan<string>(a).IndexOfAny("200", "200", comparer)));
+                Assert.Equal(-1, new ReadOnlySpan<string>(a).IndexOfAny("200", "200", GetFalseEqualityComparer<string>()));
             }
         }
 
@@ -601,9 +604,9 @@ public static void MakeSureNoChecksGoOutOfRangeIndexOfAny_TwoString()
                 var a = new string[length + 2];
                 a[0] = "99";
                 a[length + 1] = "98";
-                var span = new ReadOnlySpan<string>(a, 1, length - 1);
-                int index = span.IndexOfAny("99", "98");
-                Assert.Equal(-1, index);
+
+                Assert.Equal(-1, new ReadOnlySpan<string>(a, 1, length - 1).IndexOfAny("99", "98"));
+                Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(-1, new ReadOnlySpan<string>(a, 1, length - 1).IndexOfAny("99", "98", comparer)));
             }
 
             for (int length = 1; length < byte.MaxValue; length++)
@@ -611,18 +614,17 @@ public static void MakeSureNoChecksGoOutOfRangeIndexOfAny_TwoString()
                 var a = new string[length + 2];
                 a[0] = "99";
                 a[length + 1] = "99";
-                var span = new ReadOnlySpan<string>(a, 1, length - 1);
-                int index = span.IndexOfAny("99", "99");
-                Assert.Equal(-1, index);
+
+                Assert.Equal(-1, new ReadOnlySpan<string>(a, 1, length - 1).IndexOfAny("99", "99"));
+                Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(-1, new ReadOnlySpan<string>(a, 1, length - 1).IndexOfAny("99", "99", comparer)));
             }
         }
 
         [Fact]
         public static void ZeroLengthIndexOf_ThreeString()
         {
-            var sp = new ReadOnlySpan<string>(Array.Empty<string>());
-            int idx = sp.IndexOfAny("0", "0", "0");
-            Assert.Equal(-1, idx);
+            Assert.Equal(-1, new ReadOnlySpan<string>(Array.Empty<string>()).IndexOfAny("0", "0", "0"));
+            Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(-1, new ReadOnlySpan<string>(Array.Empty<string>()).IndexOfAny("0", "0", "0", comparer)));
         }
 
         [Fact]
@@ -633,9 +635,7 @@ public static void DefaultFilledIndexOfAny_ThreeString()
             for (int length = 0; length < byte.MaxValue; length++)
             {
                 var a = new string[length];
-                var tempSpan = new Span<string>(a);
-                tempSpan.Fill("");
-                ReadOnlySpan<string> span = tempSpan;
+                Array.Fill(a, "");
 
                 string[] targets = { "", "99", "98" };
 
@@ -645,8 +645,10 @@ public static void DefaultFilledIndexOfAny_ThreeString()
                     string target0 = targets[index];
                     string target1 = targets[(index + 1) % 2];
                     string target2 = targets[(index + 1) % 3];
-                    int idx = span.IndexOfAny(target0, target1, target2);
-                    Assert.Equal(0, idx);
+
+                    Assert.Equal(0, new ReadOnlySpan<string>(a).IndexOfAny(target0, target1, target2));
+                    Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(0, new ReadOnlySpan<string>(a).IndexOfAny(target0, target1, target2, comparer)));
+                    Assert.Equal(-1, new ReadOnlySpan<string>(a).IndexOfAny(target0, target1, target2, GetFalseEqualityComparer<string>()));
                 }
             }
         }
@@ -663,15 +665,16 @@ public static void TestMatchIndexOfAny_ThreeString()
                 {
                     a[i] = (i + 1).ToString();
                 }
-                var span = new ReadOnlySpan<string>(a);
 
                 for (int targetIndex = 0; targetIndex < length; targetIndex++)
                 {
                     string target0 = a[targetIndex];
                     string target1 = "0";
                     string target2 = "0";
-                    int idx = span.IndexOfAny(target0, target1, target2);
-                    Assert.Equal(targetIndex, idx);
+
+                    Assert.Equal(targetIndex, new ReadOnlySpan<string>(a).IndexOfAny(target0, target1, target2));
+                    Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(targetIndex, new ReadOnlySpan<string>(a).IndexOfAny(target0, target1, target2, comparer)));
+                    Assert.Equal(-1, new ReadOnlySpan<string>(a).IndexOfAny(target0, target1, target2, GetFalseEqualityComparer<string>()));
                 }
 
                 for (int targetIndex = 0; targetIndex < length - 2; targetIndex++)
@@ -680,8 +683,10 @@ public static void TestMatchIndexOfAny_ThreeString()
                     string target0 = a[targetIndex + index];
                     string target1 = a[targetIndex + (index + 1) % 2];
                     string target2 = a[targetIndex + (index + 1) % 3];
-                    int idx = span.IndexOfAny(target0, target1, target2);
-                    Assert.Equal(targetIndex, idx);
+
+                    Assert.Equal(targetIndex, new ReadOnlySpan<string>(a).IndexOfAny(target0, target1, target2));
+                    Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(targetIndex, new ReadOnlySpan<string>(a).IndexOfAny(target0, target1, target2, comparer)));
+                    Assert.Equal(-1, new ReadOnlySpan<string>(a).IndexOfAny(target0, target1, target2, GetFalseEqualityComparer<string>()));
                 }
 
                 for (int targetIndex = 0; targetIndex < length; targetIndex++)
@@ -689,8 +694,10 @@ public static void TestMatchIndexOfAny_ThreeString()
                     string target0 = "0";
                     string target1 = "0";
                     string target2 = a[targetIndex];
-                    int idx = span.IndexOfAny(target0, target1, target2);
-                    Assert.Equal(targetIndex, idx);
+
+                    Assert.Equal(targetIndex, new ReadOnlySpan<string>(a).IndexOfAny(target0, target1, target2));
+                    Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(targetIndex, new ReadOnlySpan<string>(a).IndexOfAny(target0, target1, target2, comparer)));
+                    Assert.Equal(-1, new ReadOnlySpan<string>(a).IndexOfAny(target0, target1, target2, GetFalseEqualityComparer<string>()));
                 }
             }
         }
@@ -705,10 +712,9 @@ public static void TestNoMatchIndexOfAny_ThreeString()
                 string target0 = rnd.Next(1, 256).ToString();
                 string target1 = rnd.Next(1, 256).ToString();
                 string target2 = rnd.Next(1, 256).ToString();
-                var span = new ReadOnlySpan<string>(a);
 
-                int idx = span.IndexOfAny(target0, target1, target2);
-                Assert.Equal(-1, idx);
+                Assert.Equal(-1, new ReadOnlySpan<string>(a).IndexOfAny(target0, target1, target2));
+                Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(-1, new ReadOnlySpan<string>(a).IndexOfAny(target0, target1, target2, comparer)));
             }
         }
 
@@ -729,9 +735,9 @@ public static void TestMultipleMatchIndexOfAny_ThreeString()
                 a[length - 3] = "200";
                 a[length - 4] = "200";
 
-                var span = new ReadOnlySpan<string>(a);
-                int idx = span.IndexOfAny("200", "200", "200");
-                Assert.Equal(length - 4, idx);
+                Assert.Equal(length - 4, new ReadOnlySpan<string>(a).IndexOfAny("200", "200", "200"));
+                Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(length - 4, new ReadOnlySpan<string>(a).IndexOfAny("200", "200", "200", comparer)));
+                Assert.Equal(-1, new ReadOnlySpan<string>(a).IndexOfAny("200", "200", "200", GetFalseEqualityComparer<string>()));
             }
         }
 
@@ -743,9 +749,9 @@ public static void MakeSureNoChecksGoOutOfRangeIndexOfAny_ThreeString()
                 var a = new string[length + 2];
                 a[0] = "99";
                 a[length + 1] = "98";
-                var span = new ReadOnlySpan<string>(a, 1, length - 1);
-                int index = span.IndexOfAny("99", "98", "99");
-                Assert.Equal(-1, index);
+ 
+                Assert.Equal(-1, new ReadOnlySpan<string>(a, 1, length - 1).IndexOfAny("99", "98", "99"));
+                Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(-1, new ReadOnlySpan<string>(a, 1, length - 1).IndexOfAny("99", "98", "99", comparer)));
             }
 
             for (int length = 1; length < byte.MaxValue; length++)
@@ -753,23 +759,22 @@ public static void MakeSureNoChecksGoOutOfRangeIndexOfAny_ThreeString()
                 var a = new string[length + 2];
                 a[0] = "99";
                 a[length + 1] = "99";
-                var span = new ReadOnlySpan<string>(a, 1, length - 1);
-                int index = span.IndexOfAny("99", "99", "99");
-                Assert.Equal(-1, index);
+
+                Assert.Equal(-1, new ReadOnlySpan<string>(a, 1, length - 1).IndexOfAny("99", "99", "99"));
+                Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(-1, new ReadOnlySpan<string>(a, 1, length - 1).IndexOfAny("99", "99", "99", comparer)));
             }
         }
 
         [Fact]
         public static void ZeroLengthIndexOfAny_ManyString()
         {
-            var sp = new ReadOnlySpan<string>(Array.Empty<string>());
-            var values = new ReadOnlySpan<string>(new string[] { "0", "0", "0", "0" });
-            int idx = sp.IndexOfAny(values);
-            Assert.Equal(-1, idx);
+            var values = new string[] { "0", "0", "0", "0" };
+            Assert.Equal(-1, new ReadOnlySpan<string>(Array.Empty<string>()).IndexOfAny(values));
+            Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(-1, new ReadOnlySpan<string>(Array.Empty<string>()).IndexOfAny(values, comparer)));
 
-            values = new ReadOnlySpan<string>(new string[] { });
-            idx = sp.IndexOfAny(values);
-            Assert.Equal(-1, idx);
+            values = new string[] { };
+            Assert.Equal(-1, new ReadOnlySpan<string>(Array.Empty<string>()).IndexOfAny(values));
+            Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(-1, new ReadOnlySpan<string>(Array.Empty<string>()).IndexOfAny(values, comparer)));
         }
 
         [Fact]
@@ -778,16 +783,15 @@ public static void DefaultFilledIndexOfAny_ManyString()
             for (int length = 0; length < byte.MaxValue; length++)
             {
                 var a = new string[length];
-                var tempSpan = new Span<string>(a);
-                tempSpan.Fill("");
-                ReadOnlySpan<string> span = tempSpan;
+                Array.Fill(a, "");
 
-                var values = new ReadOnlySpan<string>(new string[] { "", "99", "98", "0" });
+                var values = new string[] { "", "99", "98", "0" };
 
                 for (int i = 0; i < length; i++)
                 {
-                    int idx = span.IndexOfAny(values);
-                    Assert.Equal(0, idx);
+                    Assert.Equal(0, new ReadOnlySpan<string>(a).IndexOfAny(values));
+                    Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(0, new ReadOnlySpan<string>(a).IndexOfAny(values, comparer)));
+                    Assert.Equal(-1, new ReadOnlySpan<string>(a).IndexOfAny(values, GetFalseEqualityComparer<string>()));
                 }
             }
         }
@@ -804,34 +808,39 @@ public static void TestMatchIndexOfAny_ManyString()
                 {
                     a[i] = (i + 1).ToString();
                 }
-                var span = new ReadOnlySpan<string>(a);
 
                 for (int targetIndex = 0; targetIndex < length; targetIndex++)
                 {
-                    var values = new ReadOnlySpan<string>(new string[] { a[targetIndex], "0", "0", "0" });
-                    int idx = span.IndexOfAny(values);
-                    Assert.Equal(targetIndex, idx);
+                    var values = new string[] { a[targetIndex], "0", "0", "0" };
+
+                    Assert.Equal(targetIndex, new ReadOnlySpan<string>(a).IndexOfAny(values));
+                    Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(targetIndex, new ReadOnlySpan<string>(a).IndexOfAny(values, comparer)));
+                    Assert.Equal(-1, new ReadOnlySpan<string>(a).IndexOfAny(values, GetFalseEqualityComparer<string>()));
                 }
 
                 for (int targetIndex = 0; targetIndex < length - 3; targetIndex++)
                 {
                     int index = rnd.Next(0, 4) == 0 ? 0 : 1;
-                    var values = new ReadOnlySpan<string>(new string[]
+                    var values = new string[]
                     {
                         a[targetIndex + index],
                         a[targetIndex + (index + 1) % 2],
                         a[targetIndex + (index + 1) % 3],
                         a[targetIndex + (index + 1) % 4]
-                    });
-                    int idx = span.IndexOfAny(values);
-                    Assert.Equal(targetIndex, idx);
+                    };
+
+                    Assert.Equal(targetIndex, new ReadOnlySpan<string>(a).IndexOfAny(values));
+                    Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(targetIndex, new ReadOnlySpan<string>(a).IndexOfAny(values, comparer)));
+                    Assert.Equal(-1, new ReadOnlySpan<string>(a).IndexOfAny(values, GetFalseEqualityComparer<string>()));
                 }
 
                 for (int targetIndex = 0; targetIndex < length; targetIndex++)
                 {
-                    var values = new ReadOnlySpan<string>(new string[] { "0", "0", "0", a[targetIndex] });
-                    int idx = span.IndexOfAny(values);
-                    Assert.Equal(targetIndex, idx);
+                    var values = new string[] { "0", "0", "0", a[targetIndex] };
+
+                    Assert.Equal(targetIndex, new ReadOnlySpan<string>(a).IndexOfAny(values));
+                    Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(targetIndex, new ReadOnlySpan<string>(a).IndexOfAny(values, comparer)));
+                    Assert.Equal(-1, new ReadOnlySpan<string>(a).IndexOfAny(values, GetFalseEqualityComparer<string>()));
                 }
             }
         }
@@ -853,7 +862,6 @@ public static void TestMatchValuesLargerIndexOfAny_ManyString()
                     }
                     a[i] = "255";
                 }
-                var span = new ReadOnlySpan<string>(a);
 
                 var targets = new string[length * 2];
                 for (int i = 0; i < targets.Length; i++)
@@ -866,9 +874,9 @@ public static void TestMatchValuesLargerIndexOfAny_ManyString()
                     targets[i] = rnd.Next(1, 255).ToString();
                 }
 
-                var values = new ReadOnlySpan<string>(targets);
-                int idx = span.IndexOfAny(values);
-                Assert.Equal(expectedIndex, idx);
+                Assert.Equal(expectedIndex, new ReadOnlySpan<string>(a).IndexOfAny(targets));
+                Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(expectedIndex, new ReadOnlySpan<string>(a).IndexOfAny(targets, comparer)));
+                Assert.Equal(-1, new ReadOnlySpan<string>(a).IndexOfAny(targets, GetFalseEqualityComparer<string>()));
             }
         }
 
@@ -884,11 +892,9 @@ public static void TestNoMatchIndexOfAny_ManyString()
                 {
                     targets[i] = rnd.Next(1, 256).ToString();
                 }
-                var span = new ReadOnlySpan<string>(a);
-                var values = new ReadOnlySpan<string>(targets);
 
-                int idx = span.IndexOfAny(values);
-                Assert.Equal(-1, idx);
+                Assert.Equal(-1, new ReadOnlySpan<string>(a).IndexOfAny(targets));
+                Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(-1, new ReadOnlySpan<string>(a).IndexOfAny(targets, comparer)));
             }
         }
 
@@ -904,11 +910,9 @@ public static void TestNoMatchValuesLargerIndexOfAny_ManyString()
                 {
                     targets[i] = rnd.Next(1, 256).ToString();
                 }
-                var span = new ReadOnlySpan<string>(a);
-                var values = new ReadOnlySpan<string>(targets);
 
-                int idx = span.IndexOfAny(values);
-                Assert.Equal(-1, idx);
+                Assert.Equal(-1, new ReadOnlySpan<string>(a).IndexOfAny(targets));
+                Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(-1, new ReadOnlySpan<string>(a).IndexOfAny(targets, comparer)));
             }
         }
 
@@ -930,10 +934,11 @@ public static void TestMultipleMatchIndexOfAny_ManyString()
                 a[length - 4] = "200";
                 a[length - 5] = "200";
 
-                var span = new ReadOnlySpan<string>(a);
-                var values = new ReadOnlySpan<string>(new string[] { "200", "200", "200", "200", "200", "200", "200", "200", "200" });
-                int idx = span.IndexOfAny(values);
-                Assert.Equal(length - 5, idx);
+                var values = new string[] { "200", "200", "200", "200", "200", "200", "200", "200", "200" };
+
+                Assert.Equal(length - 5, new ReadOnlySpan<string>(a).IndexOfAny(values));
+                Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(length - 5, new ReadOnlySpan<string>(a).IndexOfAny(values, comparer)));
+                Assert.Equal(-1, new ReadOnlySpan<string>(a).IndexOfAny(values, GetFalseEqualityComparer<string>()));
             }
         }
 
@@ -945,10 +950,10 @@ public static void MakeSureNoChecksGoOutOfRangeIndexOfAny_ManyString()
                 var a = new string[length + 2];
                 a[0] = "99";
                 a[length + 1] = "98";
-                var span = new ReadOnlySpan<string>(a, 1, length - 1);
-                var values = new ReadOnlySpan<string>(new string[] { "99", "98", "99", "98", "99", "98" });
-                int index = span.IndexOfAny(values);
-                Assert.Equal(-1, index);
+                var values = new string[] { "99", "98", "99", "98", "99", "98" };
+
+                Assert.Equal(-1, new ReadOnlySpan<string>(a, 1, length - 1).IndexOfAny(values));
+                Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(-1, new ReadOnlySpan<string>(a, 1, length - 1).IndexOfAny(values, comparer)));
             }
 
             for (int length = 1; length < byte.MaxValue; length++)
@@ -956,10 +961,10 @@ public static void MakeSureNoChecksGoOutOfRangeIndexOfAny_ManyString()
                 var a = new string[length + 2];
                 a[0] = "99";
                 a[length + 1] = "99";
-                var span = new ReadOnlySpan<string>(a, 1, length - 1);
-                var values = new ReadOnlySpan<string>(new string[] { "99", "99", "99", "99", "99", "99" });
-                int index = span.IndexOfAny(values);
-                Assert.Equal(-1, index);
+                var values = new string[] { "99", "99", "99", "99", "99", "99" };
+
+                Assert.Equal(-1, new ReadOnlySpan<string>(a, 1, length - 1).IndexOfAny(values));
+                Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(-1, new ReadOnlySpan<string>(a, 1, length - 1).IndexOfAny(values, comparer)));
             }
         }
 
@@ -967,20 +972,27 @@ public static void MakeSureNoChecksGoOutOfRangeIndexOfAny_ManyString()
         [MemberData(nameof(TestHelpers.IndexOfAnyNullSequenceData), MemberType = typeof(TestHelpers))]
         public static void IndexOfAnyNullSequence_String(string[] spanInput, string[] searchInput, int expected)
         {
-            ReadOnlySpan<string> theStrings = spanInput;
-            Assert.Equal(expected, theStrings.IndexOfAny(searchInput));
-            Assert.Equal(expected, theStrings.IndexOfAny((ReadOnlySpan<string>)searchInput));
+            Assert.Equal(expected, new ReadOnlySpan<string>(spanInput).IndexOfAny(searchInput));
+            Assert.Equal(expected, new ReadOnlySpan<string>(spanInput).IndexOfAny((ReadOnlySpan<string>)searchInput));
+
+            Assert.All(GetDefaultEqualityComparers<string>(), comparer =>
+            {
+                Assert.Equal(expected, new ReadOnlySpan<string>(spanInput).IndexOfAny(searchInput, comparer));
+                Assert.Equal(expected, new ReadOnlySpan<string>(spanInput).IndexOfAny((ReadOnlySpan<string>)searchInput, comparer));
+            });
 
             if (searchInput != null)
             {
                 if (searchInput.Length >= 3)
                 {
-                    Assert.Equal(expected, theStrings.IndexOfAny(searchInput[0], searchInput[1], searchInput[2]));
+                    Assert.Equal(expected, new ReadOnlySpan<string>(spanInput).IndexOfAny(searchInput[0], searchInput[1], searchInput[2]));
+                    Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(expected, new ReadOnlySpan<string>(spanInput).IndexOfAny(searchInput[0], searchInput[1], searchInput[2], comparer)));
                 }
 
                 if (searchInput.Length >= 2)
                 {
-                    Assert.Equal(expected, theStrings.IndexOfAny(searchInput[0], searchInput[1]));
+                    Assert.Equal(expected, new ReadOnlySpan<string>(spanInput).IndexOfAny(searchInput[0], searchInput[1]));
+                    Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(expected, new ReadOnlySpan<string>(spanInput).IndexOfAny(searchInput[0], searchInput[1], comparer)));
                 }
             }
         }
diff --git a/src/libraries/System.Memory/tests/ReadOnlySpan/IndexOfSequence.T.cs b/src/libraries/System.Memory/tests/ReadOnlySpan/IndexOfSequence.T.cs
index 9d07604f312d4a..66cdab3d41d388 100644
--- a/src/libraries/System.Memory/tests/ReadOnlySpan/IndexOfSequence.T.cs
+++ b/src/libraries/System.Memory/tests/ReadOnlySpan/IndexOfSequence.T.cs
@@ -10,228 +10,262 @@ public static partial class ReadOnlySpanTests
         [Fact]
         public static void IndexOfSequenceMatchAtStart()
         {
-            ReadOnlySpan<int> span = new ReadOnlySpan<int>(new int[] { 5, 1, 77, 2, 3, 77, 77, 4, 5, 77, 77, 77, 88, 6, 6, 77, 77, 88, 9 });
-            ReadOnlySpan<int> value = new ReadOnlySpan<int>(new int[] { 5, 1, 77 });
-            int index = span.IndexOf(value);
-            Assert.Equal(0, index);
+            var source = new int[] { 5, 1, 77, 2, 3, 77, 77, 4, 5, 77, 77, 77, 88, 6, 6, 77, 77, 88, 9 };
+            var value = new int[] { 5, 1, 77 };
+
+            Assert.Equal(0, new ReadOnlySpan<int>(source).IndexOf(value));
+            Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(0, new ReadOnlySpan<int>(source).IndexOf(value, comparer)));
+            Assert.Equal(-1, new ReadOnlySpan<int>(source).IndexOf(value, GetFalseEqualityComparer<int>()));
         }
 
         [Fact]
         public static void IndexOfSequenceMultipleMatch()
         {
-            ReadOnlySpan<int> span = new ReadOnlySpan<int>(new int[] { 1, 2, 3, 1, 2, 3, 1, 2, 3 });
-            ReadOnlySpan<int> value = new ReadOnlySpan<int>(new int[] { 2, 3 });
-            int index = span.IndexOf(value);
-            Assert.Equal(1, index);
+            var source = new int[] { 1, 2, 3, 1, 2, 3, 1, 2, 3 };
+            var value = new int[] { 2, 3 };
+
+            Assert.Equal(1, new ReadOnlySpan<int>(source).IndexOf(value));
+            Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(1, new ReadOnlySpan<int>(source).IndexOf(value, comparer)));
+            Assert.Equal(-1, new ReadOnlySpan<int>(source).IndexOf(value, GetFalseEqualityComparer<int>()));
         }
 
         [Fact]
         public static void IndexOfSequenceRestart()
         {
-            ReadOnlySpan<int> span = new ReadOnlySpan<int>(new int[] { 0, 1, 77, 2, 3, 77, 77, 4, 5, 77, 77, 77, 88, 6, 6, 77, 77, 88, 9 });
-            ReadOnlySpan<int> value = new ReadOnlySpan<int>(new int[] { 77, 77, 88 });
-            int index = span.IndexOf(value);
-            Assert.Equal(10, index);
+            var source = new int[] { 0, 1, 77, 2, 3, 77, 77, 4, 5, 77, 77, 77, 88, 6, 6, 77, 77, 88, 9 };
+            var value = new int[] { 77, 77, 88 };
+
+            Assert.Equal(10, new ReadOnlySpan<int>(source).IndexOf(value));
+            Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(10, new ReadOnlySpan<int>(source).IndexOf(value, comparer)));
+            Assert.Equal(-1, new ReadOnlySpan<int>(source).IndexOf(value, GetFalseEqualityComparer<int>()));
         }
 
         [Fact]
         public static void IndexOfSequenceNoMatch()
         {
-            ReadOnlySpan<int> span = new ReadOnlySpan<int>(new int[] { 0, 1, 77, 2, 3, 77, 77, 4, 5, 77, 77, 77, 88, 6, 6, 77, 77, 88, 9 });
-            ReadOnlySpan<int> value = new ReadOnlySpan<int>(new int[] { 77, 77, 88, 99 });
-            int index = span.IndexOf(value);
-            Assert.Equal(-1, index);
+            var source = new int[] { 0, 1, 77, 2, 3, 77, 77, 4, 5, 77, 77, 77, 88, 6, 6, 77, 77, 88, 9 };
+            var value = new int[] { 77, 77, 88, 99 };
+
+            Assert.Equal(-1, new ReadOnlySpan<int>(source).IndexOf(value));
+            Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(-1, new ReadOnlySpan<int>(source).IndexOf(value, comparer)));
         }
 
         [Fact]
         public static void IndexOfSequenceNotEvenAHeadMatch()
         {
-            ReadOnlySpan<int> span = new ReadOnlySpan<int>(new int[] { 0, 1, 77, 2, 3, 77, 77, 4, 5, 77, 77, 77, 88, 6, 6, 77, 77, 88, 9 });
-            ReadOnlySpan<int> value = new ReadOnlySpan<int>(new int[] { 100, 77, 88, 99 });
-            int index = span.IndexOf(value);
-            Assert.Equal(-1, index);
+            var source = new int[] { 0, 1, 77, 2, 3, 77, 77, 4, 5, 77, 77, 77, 88, 6, 6, 77, 77, 88, 9 };
+            var value = new int[] { 100, 77, 88, 99 };
+
+            Assert.Equal(-1, new ReadOnlySpan<int>(source).IndexOf(value));
+            Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(-1, new ReadOnlySpan<int>(source).IndexOf(value, comparer)));
         }
 
         [Fact]
         public static void IndexOfSequenceMatchAtVeryEnd()
         {
-            ReadOnlySpan<int> span = new ReadOnlySpan<int>(new int[] { 0, 1, 2, 3, 4, 5 });
-            ReadOnlySpan<int> value = new ReadOnlySpan<int>(new int[] { 3, 4, 5 });
-            int index = span.IndexOf(value);
-            Assert.Equal(3, index);
+            var source = new int[] { 0, 1, 2, 3, 4, 5 };
+            var value = new int[] { 3, 4, 5 };
+
+            Assert.Equal(3, new ReadOnlySpan<int>(source).IndexOf(value));
+            Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(3, new ReadOnlySpan<int>(source).IndexOf(value, comparer)));
         }
 
         [Fact]
         public static void IndexOfSequenceJustPastVeryEnd()
         {
-            ReadOnlySpan<int> span = new ReadOnlySpan<int>(new int[] { 0, 1, 2, 3, 4, 5 }, 0, 5);
-            ReadOnlySpan<int> value = new ReadOnlySpan<int>(new int[] { 3, 4, 5 });
-            int index = span.IndexOf(value);
-            Assert.Equal(-1, index);
+            var source = new int[] { 0, 1, 2, 3, 4, 5 };
+            var value = new int[] { 3, 4, 5 };
+
+            Assert.Equal(-1, new ReadOnlySpan<int>(source, 0, 5).IndexOf(value));
+            Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(-1, new ReadOnlySpan<int>(source, 0, 5).IndexOf(value, comparer)));
         }
 
         [Fact]
         public static void IndexOfSequenceZeroLengthValue()
         {
-            // A zero-length value is always "found" at the start of the span.
-            ReadOnlySpan<int> span = new ReadOnlySpan<int>(new int[] { 0, 1, 77, 2, 3, 77, 77, 4, 5, 77, 77, 77, 88, 6, 6, 77, 77, 88, 9 });
-            ReadOnlySpan<int> value = new ReadOnlySpan<int>(Array.Empty<int>());
-            int index = span.IndexOf(value);
-            Assert.Equal(0, index);
+            // A zero-length value is always "found" at the start of the source.
+            var source = new int[] { 0, 1, 77, 2, 3, 77, 77, 4, 5, 77, 77, 77, 88, 6, 6, 77, 77, 88, 9 };
+            var value = Array.Empty<int>();
+
+            Assert.Equal(0, new ReadOnlySpan<int>(source).IndexOf(value));
+            Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(0, new ReadOnlySpan<int>(source).IndexOf(value, comparer)));
         }
 
         [Fact]
         public static void IndexOfSequenceZeroLengthSpan()
         {
-            ReadOnlySpan<int> span = new ReadOnlySpan<int>(Array.Empty<int>());
-            ReadOnlySpan<int> value = new ReadOnlySpan<int>(new int[] { 1, 2, 3 });
-            int index = span.IndexOf(value);
-            Assert.Equal(-1, index);
+            var source = Array.Empty<int>();
+            var value = new int[] { 1, 2, 3 };
+
+            Assert.Equal(-1, new ReadOnlySpan<int>(source).IndexOf(value));
+            Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(-1, new ReadOnlySpan<int>(source).IndexOf(value, comparer)));
         }
 
         [Fact]
         public static void IndexOfSequenceLengthOneValue()
         {
-            ReadOnlySpan<int> span = new ReadOnlySpan<int>(new int[] { 0, 1, 2, 3, 4, 5 });
-            ReadOnlySpan<int> value = new ReadOnlySpan<int>(new int[] { 2 });
-            int index = span.IndexOf(value);
-            Assert.Equal(2, index);
+            var source = new int[] { 0, 1, 2, 3, 4, 5 };
+            var value = new int[] { 2 };
+
+            Assert.Equal(2, new ReadOnlySpan<int>(source).IndexOf(value));
+            Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(2, new ReadOnlySpan<int>(source).IndexOf(value, comparer)));
+            Assert.Equal(-1, new ReadOnlySpan<int>(source).IndexOf(value, GetFalseEqualityComparer<int>()));
         }
 
         [Fact]
         public static void IndexOfSequenceLengthOneValueAtVeryEnd()
         {
-            ReadOnlySpan<int> span = new ReadOnlySpan<int>(new int[] { 0, 1, 2, 3, 4, 5 });
-            ReadOnlySpan<int> value = new ReadOnlySpan<int>(new int[] { 5 });
-            int index = span.IndexOf(value);
-            Assert.Equal(5, index);
+            var source = new int[] { 0, 1, 2, 3, 4, 5 };
+            var value = new int[] { 5 };
+
+            Assert.Equal(5, new ReadOnlySpan<int>(source).IndexOf(value));
+            Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(5, new ReadOnlySpan<int>(source).IndexOf(value, comparer)));
+            Assert.Equal(-1, new ReadOnlySpan<int>(source).IndexOf(value, GetFalseEqualityComparer<int>()));
         }
 
         [Fact]
         public static void IndexOfSequenceLengthOneValueJustPasttVeryEnd()
         {
-            ReadOnlySpan<int> span = new ReadOnlySpan<int>(new int[] { 0, 1, 2, 3, 4, 5 }, 0, 5);
-            ReadOnlySpan<int> value = new ReadOnlySpan<int>(new int[] { 5 });
-            int index = span.IndexOf(value);
-            Assert.Equal(-1, index);
+            var source = new int[] { 0, 1, 2, 3, 4, 5 };
+            var value = new int[] { 5 };
+
+            Assert.Equal(-1, new ReadOnlySpan<int>(source, 0, 5).IndexOf(value));
+            Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(-1, new ReadOnlySpan<int>(source, 0, 5).IndexOf(value, comparer)));
         }
 
         [Fact]
         public static void IndexOfSequenceMatchAtStart_String()
         {
-            ReadOnlySpan<string> span = new ReadOnlySpan<string>(new string[] { "5", "1", "77", "2", "3", "77", "77", "4", "5", "77", "77", "77", "88", "6", "6", "77", "77", "88", "9" });
-            ReadOnlySpan<string> value = new ReadOnlySpan<string>(new string[] { "5", "1", "77" });
-            int index = span.IndexOf(value);
-            Assert.Equal(0, index);
+            var source = new string[] { "5", "1", "77", "2", "3", "77", "77", "4", "5", "77", "77", "77", "88", "6", "6", "77", "77", "88", "9" };
+            var value = new string[] { "5", "1", "77" };
+
+            Assert.Equal(0, new ReadOnlySpan<string>(source).IndexOf(value));
+            Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(0, new ReadOnlySpan<string>(source).IndexOf(value, comparer)));
+            Assert.Equal(-1, new ReadOnlySpan<string>(source).IndexOf(value, GetFalseEqualityComparer<string>()));
         }
 
         [Fact]
         public static void IndexOfSequenceMultipleMatch_String()
         {
-            ReadOnlySpan<string> span = new ReadOnlySpan<string>(new string[] { "1", "2", "3", "1", "2", "3", "1", "2", "3" });
-            ReadOnlySpan<string> value = new ReadOnlySpan<string>(new string[] { "2", "3" });
-            int index = span.IndexOf(value);
-            Assert.Equal(1, index);
+            var source = new string[] { "1", "2", "3", "1", "2", "3", "1", "2", "3" };
+            var value = new string[] { "2", "3" };
+
+            Assert.Equal(1, new ReadOnlySpan<string>(source).IndexOf(value));
+            Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(1, new ReadOnlySpan<string>(source).IndexOf(value, comparer)));
+            Assert.Equal(-1, new ReadOnlySpan<string>(source).IndexOf(value, GetFalseEqualityComparer<string>()));
         }
 
         [Fact]
         public static void IndexOfSequenceRestart_String()
         {
-            ReadOnlySpan<string> span = new ReadOnlySpan<string>(new string[] { "0", "1", "77", "2", "3", "77", "77", "4", "5", "77", "77", "77", "88", "6", "6", "77", "77", "88", "9" });
-            ReadOnlySpan<string> value = new ReadOnlySpan<string>(new string[] { "77", "77", "88" });
-            int index = span.IndexOf(value);
-            Assert.Equal(10, index);
+            var source = new string[] { "0", "1", "77", "2", "3", "77", "77", "4", "5", "77", "77", "77", "88", "6", "6", "77", "77", "88", "9" };
+            var value = new string[] { "77", "77", "88" };
+
+            Assert.Equal(10, source.IndexOf(value));
+            Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(10, source.IndexOf(value, comparer)));
+            Assert.Equal(-1, source.IndexOf(value, GetFalseEqualityComparer<string>()));
         }
 
         [Fact]
         public static void IndexOfSequenceNoMatch_String()
         {
-            ReadOnlySpan<string> span = new ReadOnlySpan<string>(new string[] { "0", "1", "77", "2", "3", "77", "77", "4", "5", "77", "77", "77", "88", "6", "6", "77", "77", "88", "9" });
-            ReadOnlySpan<string> value = new ReadOnlySpan<string>(new string[] { "77", "77", "88", "99" });
-            int index = span.IndexOf(value);
-            Assert.Equal(-1, index);
+            var source = new string[] { "0", "1", "77", "2", "3", "77", "77", "4", "5", "77", "77", "77", "88", "6", "6", "77", "77", "88", "9" };
+            var value = new string[] { "77", "77", "88", "99" };
+
+            Assert.Equal(-1, new ReadOnlySpan<string>(source).IndexOf(value));
+            Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(-1, new ReadOnlySpan<string>(source).IndexOf(value, comparer)));
         }
 
         [Fact]
         public static void IndexOfSequenceNotEvenAHeadMatch_String()
         {
-            ReadOnlySpan<string> span = new ReadOnlySpan<string>(new string[] { "0", "1", "77", "2", "3", "77", "77", "4", "5", "77", "77", "77", "88", "6", "6", "77", "77", "88", "9" });
-            ReadOnlySpan<string> value = new ReadOnlySpan<string>(new string[] { "100", "77", "88", "99" });
-            int index = span.IndexOf(value);
-            Assert.Equal(-1, index);
+            var source = new string[] { "0", "1", "77", "2", "3", "77", "77", "4", "5", "77", "77", "77", "88", "6", "6", "77", "77", "88", "9" };
+            var value = new string[] { "100", "77", "88", "99" };
+
+            Assert.Equal(-1, new ReadOnlySpan<string>(source).IndexOf(value));
+            Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(-1, new ReadOnlySpan<string>(source).IndexOf(value, comparer)));
         }
 
         [Fact]
         public static void IndexOfSequenceMatchAtVeryEnd_String()
         {
-            ReadOnlySpan<string> span = new ReadOnlySpan<string>(new string[] { "0", "1", "2", "3", "4", "5" });
-            ReadOnlySpan<string> value = new ReadOnlySpan<string>(new string[] { "3", "4", "5" });
-            int index = span.IndexOf(value);
-            Assert.Equal(3, index);
+            var source = new string[] { "0", "1", "2", "3", "4", "5" };
+            var value = new string[] { "3", "4", "5" };
+
+            Assert.Equal(3, new ReadOnlySpan<string>(source).IndexOf(value));
+            Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(3, new ReadOnlySpan<string>(source).IndexOf(value, comparer)));
+            Assert.Equal(-1, new ReadOnlySpan<string>(source).IndexOf(value, GetFalseEqualityComparer<string>()));
         }
 
         [Fact]
         public static void IndexOfSequenceJustPastVeryEnd_String()
         {
-            ReadOnlySpan<string> span = new ReadOnlySpan<string>(new string[] { "0", "1", "2", "3", "4", "5" }, 0, 5);
-            ReadOnlySpan<string> value = new ReadOnlySpan<string>(new string[] { "3", "4", "5" });
-            int index = span.IndexOf(value);
-            Assert.Equal(-1, index);
+            var source = new string[] { "0", "1", "2", "3", "4", "5" };
+            var value = new string[] { "3", "4", "5" };
+
+            Assert.Equal(-1, source.AsSpan(0, 5).IndexOf(value));
+            Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(-1, source.AsSpan(0, 5).IndexOf(value, comparer)));
         }
 
         [Fact]
         public static void IndexOfSequenceZeroLengthValue_String()
         {
-            // A zero-length value is always "found" at the start of the span.
-            ReadOnlySpan<string> span = new ReadOnlySpan<string>(new string[] { "0", "1", "77", "2", "3", "77", "77", "4", "5", "77", "77", "77", "88", "6", "6", "77", "77", "88", "9" });
-            ReadOnlySpan<string> value = new ReadOnlySpan<string>(Array.Empty<string>());
-            int index = span.IndexOf(value);
-            Assert.Equal(0, index);
+            // A zero-length value is always "found" at the start of the source.
+            var source = new string[] { "0", "1", "77", "2", "3", "77", "77", "4", "5", "77", "77", "77", "88", "6", "6", "77", "77", "88", "9" };
+            var value = Array.Empty<string>();
+
+            Assert.Equal(0, new ReadOnlySpan<string>(source).IndexOf(value));
+            Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(0, new ReadOnlySpan<string>(source).IndexOf(value, comparer)));
         }
 
         [Fact]
         public static void IndexOfSequenceZeroLengthSpan_String()
         {
-            ReadOnlySpan<string> span = new ReadOnlySpan<string>(Array.Empty<string>());
-            ReadOnlySpan<string> value = new ReadOnlySpan<string>(new string[] { "1", "2", "3" });
-            int index = span.IndexOf(value);
-            Assert.Equal(-1, index);
+            var source = Array.Empty<string>();
+            var value = new string[] { "1", "2", "3" };
+
+            Assert.Equal(-1, new ReadOnlySpan<string>(source).IndexOf(value));
+            Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(-1, new ReadOnlySpan<string>(source).IndexOf(value, comparer)));
         }
 
         [Fact]
         public static void IndexOfSequenceLengthOneValue_String()
         {
-            ReadOnlySpan<string> span = new ReadOnlySpan<string>(new string[] { "0", "1", "2", "3", "4", "5" });
-            ReadOnlySpan<string> value = new ReadOnlySpan<string>(new string[] { "2" });
-            int index = span.IndexOf(value);
-            Assert.Equal(2, index);
+            var source = new string[] { "0", "1", "2", "3", "4", "5" };
+            var value = new string[] { "2" };
+
+            Assert.Equal(2, new ReadOnlySpan<string>(source).IndexOf(value));
+            Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(2, new ReadOnlySpan<string>(source).IndexOf(value, comparer)));
+            Assert.Equal(-1, new ReadOnlySpan<string>(source).IndexOf(value, GetFalseEqualityComparer<string>()));
         }
 
         [Fact]
         public static void IndexOfSequenceLengthOneValueAtVeryEnd_String()
         {
-            ReadOnlySpan<string> span = new ReadOnlySpan<string>(new string[] { "0", "1", "2", "3", "4", "5" });
-            ReadOnlySpan<string> value = new ReadOnlySpan<string>(new string[] { "5" });
-            int index = span.IndexOf(value);
-            Assert.Equal(5, index);
+            var source = new string[] { "0", "1", "2", "3", "4", "5" };
+            var value = new string[] { "5" };
+
+            Assert.Equal(5, new ReadOnlySpan<string>(source).IndexOf(value));
+            Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(5, new ReadOnlySpan<string>(source).IndexOf(value, comparer)));
+            Assert.Equal(-1, new ReadOnlySpan<string>(source).IndexOf(value, GetFalseEqualityComparer<string>()));
         }
 
         [Fact]
         public static void IndexOfSequenceLengthOneValueJustPasttVeryEnd_String()
         {
-            ReadOnlySpan<string> span = new ReadOnlySpan<string>(new string[] { "0", "1", "2", "3", "4", "5" }, 0, 5);
-            ReadOnlySpan<string> value = new ReadOnlySpan<string>(new string[] { "5" });
-            int index = span.IndexOf(value);
-            Assert.Equal(-1, index);
+            var source = new string[] { "0", "1", "2", "3", "4", "5" };
+            var value = new string[] { "5" };
+
+            Assert.Equal(-1, source.AsSpan(0, 5).IndexOf(value));
+            Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(-1, source.AsSpan(0, 5).IndexOf(value, comparer)));
         }
 
         [Theory]
         [MemberData(nameof(TestHelpers.IndexOfNullSequenceData), MemberType = typeof(TestHelpers))]
-        public static void IndexOfNullSequence_String(string[] spanInput, string[] searchInput, int expected)
+        public static void IndexOfNullSequence_String(string[] source, string[] target, int expected)
         {
-            ReadOnlySpan<string> theStrings = spanInput;
-            Assert.Equal(expected, theStrings.IndexOf(searchInput));
-            Assert.Equal(expected, theStrings.IndexOf((ReadOnlySpan<string>)searchInput));
+            Assert.Equal(expected, new ReadOnlySpan<string>(source).IndexOf(target));
+            Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(expected, new ReadOnlySpan<string>(source).IndexOf(target, comparer)));
         }
     }
 }
diff --git a/src/libraries/System.Memory/tests/ReadOnlySpan/LastIndexOf.T.cs b/src/libraries/System.Memory/tests/ReadOnlySpan/LastIndexOf.T.cs
index 30af16699a50ed..ce9e01493f3782 100644
--- a/src/libraries/System.Memory/tests/ReadOnlySpan/LastIndexOf.T.cs
+++ b/src/libraries/System.Memory/tests/ReadOnlySpan/LastIndexOf.T.cs
@@ -10,9 +10,8 @@ public static partial class ReadOnlySpanTests
         [Fact]
         public static void ZeroLengthLastIndexOf()
         {
-            ReadOnlySpan<int> sp = new ReadOnlySpan<int>(Array.Empty<int>());
-            int idx = sp.LastIndexOf(0);
-            Assert.Equal(-1, idx);
+            Assert.Equal(-1, Array.Empty<int>().LastIndexOf(0));
+            Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(-1, Array.Empty<int>().LastIndexOf(0, comparer)));
         }
 
         [Fact]
@@ -25,13 +24,14 @@ public static void TestMatchLastIndexOf()
                 {
                     a[i] = 10 * (i + 1);
                 }
-                ReadOnlySpan<int> span = new ReadOnlySpan<int>(a);
 
                 for (int targetIndex = 0; targetIndex < length; targetIndex++)
                 {
                     int target = a[targetIndex];
-                    int idx = span.LastIndexOf(target);
-                    Assert.Equal(targetIndex, idx);
+
+                    Assert.Equal(targetIndex, new ReadOnlySpan<int>(a).LastIndexOf(target));
+                    Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(targetIndex, new ReadOnlySpan<int>(a).LastIndexOf(target, comparer)));
+                    Assert.Equal(-1, new ReadOnlySpan<int>(a).LastIndexOf(target, GetFalseEqualityComparer<int>()));
                 }
             }
         }
@@ -50,9 +50,9 @@ public static void TestMultipleMatchLastIndexOf()
                 a[length - 1] = 5555;
                 a[length - 2] = 5555;
 
-                ReadOnlySpan<int> span = new ReadOnlySpan<int>(a);
-                int idx = span.LastIndexOf(5555);
-                Assert.Equal(length - 1, idx);
+                Assert.Equal(length - 1, new ReadOnlySpan<int>(a).LastIndexOf(5555));
+                Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(length - 1, new ReadOnlySpan<int>(a).LastIndexOf(5555, comparer)));
+                Assert.Equal(-1, new ReadOnlySpan<int>(a).LastIndexOf(5555, GetFalseEqualityComparer<int>()));
             }
         }
 
@@ -110,18 +110,16 @@ public static void MakeSureNoChecksGoOutOfRangeLastIndexOf()
                     a[GuardLength + i] = new TInt(10 * (i + 1), checkForOutOfRangeAccess);
                 }
 
-                ReadOnlySpan<TInt> span = new ReadOnlySpan<TInt>(a, GuardLength, length);
-                int idx = span.LastIndexOf(new TInt(9999, checkForOutOfRangeAccess));
-                Assert.Equal(-1, idx);
+                Assert.Equal(-1, new ReadOnlySpan<TInt>(a, GuardLength, length).LastIndexOf(new TInt(9999, checkForOutOfRangeAccess)));
+                Assert.All(GetDefaultEqualityComparers<TInt>(), comparer => Assert.Equal(-1, new ReadOnlySpan<TInt>(a, GuardLength, length).LastIndexOf(new TInt(9999, checkForOutOfRangeAccess), comparer)));
             }
         }
 
         [Fact]
         public static void ZeroLengthLastIndexOf_String()
         {
-            ReadOnlySpan<string> sp = new ReadOnlySpan<string>(Array.Empty<string>());
-            int idx = sp.LastIndexOf("a");
-            Assert.Equal(-1, idx);
+            Assert.Equal(-1, new ReadOnlySpan<string>(Array.Empty<string>()).LastIndexOf("a"));
+            Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(-1, new ReadOnlySpan<string>(Array.Empty<string>()).LastIndexOf("a", comparer)));
         }
 
         [Fact]
@@ -134,13 +132,14 @@ public static void TestMatchLastIndexOf_String()
                 {
                     a[i] = (10 * (i + 1)).ToString();
                 }
-                ReadOnlySpan<string> span = new ReadOnlySpan<string>(a);
 
                 for (int targetIndex = 0; targetIndex < length; targetIndex++)
                 {
                     string target = a[targetIndex];
-                    int idx = span.LastIndexOf(target);
-                    Assert.Equal(targetIndex, idx);
+
+                    Assert.Equal(targetIndex, new ReadOnlySpan<string>(a).LastIndexOf(target));
+                    Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(targetIndex, new ReadOnlySpan<string>(a).LastIndexOf(target, comparer)));
+                    Assert.Equal(-1, new ReadOnlySpan<string>(a).LastIndexOf(target, GetFalseEqualityComparer<string>()));
                 }
             }
         }
@@ -158,10 +157,9 @@ public static void TestNoMatchLastIndexOf_String()
                     string val = (i + 1).ToString();
                     a[i] = val == target ? (target + 1) : val;
                 }
-                ReadOnlySpan<string> span = new ReadOnlySpan<string>(a);
 
-                int idx = span.LastIndexOf(target);
-                Assert.Equal(-1, idx);
+                Assert.Equal(-1, new ReadOnlySpan<string>(a).LastIndexOf(target));
+                Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(-1, new ReadOnlySpan<string>(a).LastIndexOf(target, comparer)));
             }
         }
 
@@ -179,9 +177,9 @@ public static void TestMultipleMatchLastIndexOf_String()
                 a[length - 1] = "5555";
                 a[length - 2] = "5555";
 
-                ReadOnlySpan<string> span = new ReadOnlySpan<string>(a);
-                int idx = span.LastIndexOf("5555");
-                Assert.Equal(length - 1, idx);
+                Assert.Equal(length - 1, new ReadOnlySpan<string>(a).LastIndexOf("5555"));
+                Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(length - 1, new ReadOnlySpan<string>(a).LastIndexOf("5555", comparer)));
+                Assert.Equal(-1, new ReadOnlySpan<string>(a).LastIndexOf("5555", GetFalseEqualityComparer<string>()));
             }
         }
 
@@ -189,8 +187,8 @@ public static void TestMultipleMatchLastIndexOf_String()
         [MemberData(nameof(TestHelpers.LastIndexOfNullData), MemberType = typeof(TestHelpers))]
         public static void LastIndexOfNull_String(string[] spanInput, int expected)
         {
-            ReadOnlySpan<string> theStrings = spanInput;
-            Assert.Equal(expected, theStrings.LastIndexOf((string)null));
+            Assert.Equal(expected, new ReadOnlySpan<string>(spanInput).LastIndexOf((string)null));
+            Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(expected, new ReadOnlySpan<string>(spanInput).LastIndexOf((string)null, comparer)));
         }
     }
 }
diff --git a/src/libraries/System.Memory/tests/ReadOnlySpan/LastIndexOfAny.T.cs b/src/libraries/System.Memory/tests/ReadOnlySpan/LastIndexOfAny.T.cs
index aad66673dc6048..0c81bc33840cc0 100644
--- a/src/libraries/System.Memory/tests/ReadOnlySpan/LastIndexOfAny.T.cs
+++ b/src/libraries/System.Memory/tests/ReadOnlySpan/LastIndexOfAny.T.cs
@@ -10,9 +10,8 @@ public static partial class ReadOnlySpanTests
         [Fact]
         public static void ZeroLengthLastIndexOfAny_TwoByte()
         {
-            var sp = new ReadOnlySpan<int>(Array.Empty<int>());
-            int idx = sp.LastIndexOfAny(0, 0);
-            Assert.Equal(-1, idx);
+            Assert.Equal(-1, new ReadOnlySpan<int>(Array.Empty<int>()).LastIndexOfAny(0, 0));
+            Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(-1, new ReadOnlySpan<int>(Array.Empty<int>()).LastIndexOfAny(0, 0, comparer)));
         }
 
         [Fact]
@@ -23,7 +22,6 @@ public static void DefaultFilledLastIndexOfAny_TwoByte()
             for (int length = 0; length < byte.MaxValue; length++)
             {
                 var a = new int[length];
-                var span = new ReadOnlySpan<int>(a);
 
                 int[] targets = { default, 99 };
 
@@ -32,8 +30,10 @@ public static void DefaultFilledLastIndexOfAny_TwoByte()
                     int index = rnd.Next(0, 2) == 0 ? 0 : 1;
                     int target0 = targets[index];
                     int target1 = targets[(index + 1) % 2];
-                    int idx = span.LastIndexOfAny(target0, target1);
-                    Assert.Equal(span.Length - 1, idx);
+
+                    Assert.Equal(a.Length - 1, new ReadOnlySpan<int>(a).LastIndexOfAny(target0, target1));
+                    Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(a.Length - 1, new ReadOnlySpan<int>(a).LastIndexOfAny(target0, target1, comparer)));
+                    Assert.Equal(-1, new ReadOnlySpan<int>(a).LastIndexOfAny(target0, target1, GetFalseEqualityComparer<int>()));
                 }
             }
         }
@@ -48,30 +48,35 @@ public static void TestMatchLastIndexOfAny_TwoByte()
                 {
                     a[i] = i + 1;
                 }
-                var span = new ReadOnlySpan<int>(a);
 
                 for (int targetIndex = 0; targetIndex < length; targetIndex++)
                 {
                     int target0 = a[targetIndex];
                     int target1 = 0;
-                    int idx = span.LastIndexOfAny(target0, target1);
-                    Assert.Equal(targetIndex, idx);
+
+                    Assert.Equal(targetIndex, new ReadOnlySpan<int>(a).LastIndexOfAny(target0, target1));
+                    Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(targetIndex, new ReadOnlySpan<int>(a).LastIndexOfAny(target0, target1, comparer)));
+                    Assert.Equal(-1, new ReadOnlySpan<int>(a).LastIndexOfAny(target0, target1, GetFalseEqualityComparer<int>()));
                 }
 
                 for (int targetIndex = 0; targetIndex < length - 1; targetIndex++)
                 {
                     int target0 = a[targetIndex];
                     int target1 = a[targetIndex + 1];
-                    int idx = span.LastIndexOfAny(target0, target1);
-                    Assert.Equal(targetIndex + 1, idx);
+
+                    Assert.Equal(targetIndex + 1, new ReadOnlySpan<int>(a).LastIndexOfAny(target0, target1));
+                    Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(targetIndex + 1, new ReadOnlySpan<int>(a).LastIndexOfAny(target0, target1, comparer)));
+                    Assert.Equal(-1, new ReadOnlySpan<int>(a).LastIndexOfAny(target0, target1, GetFalseEqualityComparer<int>()));
                 }
 
                 for (int targetIndex = 0; targetIndex < length - 1; targetIndex++)
                 {
                     int target0 = 0;
                     int target1 = a[targetIndex + 1];
-                    int idx = span.LastIndexOfAny(target0, target1);
-                    Assert.Equal(targetIndex + 1, idx);
+
+                    Assert.Equal(targetIndex + 1, new ReadOnlySpan<int>(a).LastIndexOfAny(target0, target1));
+                    Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(targetIndex + 1, new ReadOnlySpan<int>(a).LastIndexOfAny(target0, target1, comparer)));
+                    Assert.Equal(-1, new ReadOnlySpan<int>(a).LastIndexOfAny(target0, target1, GetFalseEqualityComparer<int>()));
                 }
             }
         }
@@ -85,10 +90,9 @@ public static void TestNoMatchLastIndexOfAny_TwoByte()
                 var a = new int[length];
                 int target0 = rnd.Next(1, 256);
                 int target1 = rnd.Next(1, 256);
-                var span = new ReadOnlySpan<int>(a);
 
-                int idx = span.LastIndexOfAny(target0, target1);
-                Assert.Equal(-1, idx);
+                Assert.Equal(-1, new ReadOnlySpan<int>(a).LastIndexOfAny(target0, target1));
+                Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(-1, new ReadOnlySpan<int>(a).LastIndexOfAny(target0, target1, comparer)));
             }
         }
 
@@ -108,9 +112,9 @@ public static void TestMultipleMatchLastIndexOfAny_TwoByte()
                 a[length - 2] = 200;
                 a[length - 3] = 200;
 
-                var span = new ReadOnlySpan<int>(a);
-                int idx = span.LastIndexOfAny(200, 200);
-                Assert.Equal(length - 1, idx);
+                Assert.Equal(length - 1, new ReadOnlySpan<int>(a).LastIndexOfAny(200, 200));
+                Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(length - 1, new ReadOnlySpan<int>(a).LastIndexOfAny(200, 200, comparer)));
+                Assert.Equal(-1, new ReadOnlySpan<int>(a).LastIndexOfAny(200, 200, GetFalseEqualityComparer<int>()));
             }
         }
 
@@ -122,9 +126,9 @@ public static void MakeSureNoChecksGoOutOfRangeLastIndexOfAny_TwoByte()
                 var a = new int[length + 2];
                 a[0] = 99;
                 a[length + 1] = 98;
-                var span = new ReadOnlySpan<int>(a, 1, length - 1);
-                int index = span.LastIndexOfAny(99, 98);
-                Assert.Equal(-1, index);
+
+                Assert.Equal(-1, new ReadOnlySpan<int>(a, 1, length - 1).LastIndexOfAny(99, 98));
+                Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(-1, new ReadOnlySpan<int>(a, 1, length - 1).LastIndexOfAny(99, 98, comparer)));
             }
 
             for (int length = 1; length < byte.MaxValue; length++)
@@ -132,18 +136,17 @@ public static void MakeSureNoChecksGoOutOfRangeLastIndexOfAny_TwoByte()
                 var a = new int[length + 2];
                 a[0] = 99;
                 a[length + 1] = 99;
-                var span = new ReadOnlySpan<int>(a, 1, length - 1);
-                int index = span.LastIndexOfAny(99, 99);
-                Assert.Equal(-1, index);
+
+                Assert.Equal(-1, new ReadOnlySpan<int>(a, 1, length - 1).LastIndexOfAny(99, 99));
+                Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(-1, new ReadOnlySpan<int>(a, 1, length - 1).LastIndexOfAny(99, 99, comparer)));
             }
         }
 
         [Fact]
         public static void ZeroLengthIndexOf_ThreeByte()
         {
-            var sp = new ReadOnlySpan<int>(Array.Empty<int>());
-            int idx = sp.LastIndexOfAny(0, 0, 0);
-            Assert.Equal(-1, idx);
+            Assert.Equal(-1, new ReadOnlySpan<int>(Array.Empty<int>()).LastIndexOfAny(0, 0, 0));
+            Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(-1, new ReadOnlySpan<int>(Array.Empty<int>()).LastIndexOfAny(0, 0, 0, comparer)));
         }
 
         [Fact]
@@ -154,7 +157,6 @@ public static void DefaultFilledLastIndexOfAny_ThreeByte()
             for (int length = 0; length < byte.MaxValue; length++)
             {
                 var a = new int[length];
-                var span = new ReadOnlySpan<int>(a);
 
                 int[] targets = { default, 99, 98 };
 
@@ -164,8 +166,10 @@ public static void DefaultFilledLastIndexOfAny_ThreeByte()
                     int target0 = targets[index];
                     int target1 = targets[(index + 1) % 2];
                     int target2 = targets[(index + 1) % 3];
-                    int idx = span.LastIndexOfAny(target0, target1, target2);
-                    Assert.Equal(span.Length - 1, idx);
+
+                    Assert.Equal(a.Length - 1, new ReadOnlySpan<int>(a).LastIndexOfAny(target0, target1, target2));
+                    Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(a.Length - 1, new ReadOnlySpan<int>(a).LastIndexOfAny(target0, target1, target2, comparer)));
+                    Assert.Equal(-1, new ReadOnlySpan<int>(a).LastIndexOfAny(target0, target1, target2, GetFalseEqualityComparer<int>()));
                 }
             }
         }
@@ -180,15 +184,16 @@ public static void TestMatchLastIndexOfAny_ThreeByte()
                 {
                     a[i] = i + 1;
                 }
-                var span = new ReadOnlySpan<int>(a);
 
                 for (int targetIndex = 0; targetIndex < length; targetIndex++)
                 {
                     int target0 = a[targetIndex];
                     int target1 = 0;
                     int target2 = 0;
-                    int idx = span.LastIndexOfAny(target0, target1, target2);
-                    Assert.Equal(targetIndex, idx);
+
+                    Assert.Equal(targetIndex, new ReadOnlySpan<int>(a).LastIndexOfAny(target0, target1, target2));
+                    Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(targetIndex, new ReadOnlySpan<int>(a).LastIndexOfAny(target0, target1, target2, comparer)));
+                    Assert.Equal(-1, new ReadOnlySpan<int>(a).LastIndexOfAny(target0, target1, target2, GetFalseEqualityComparer<int>()));
                 }
 
                 for (int targetIndex = 0; targetIndex < length - 2; targetIndex++)
@@ -196,8 +201,10 @@ public static void TestMatchLastIndexOfAny_ThreeByte()
                     int target0 = a[targetIndex];
                     int target1 = a[targetIndex + 1];
                     int target2 = a[targetIndex + 2];
-                    int idx = span.LastIndexOfAny(target0, target1, target2);
-                    Assert.Equal(targetIndex + 2, idx);
+
+                    Assert.Equal(targetIndex + 2, new ReadOnlySpan<int>(a).LastIndexOfAny(target0, target1, target2));
+                    Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(targetIndex + 2, new ReadOnlySpan<int>(a).LastIndexOfAny(target0, target1, target2, comparer)));
+                    Assert.Equal(-1, new ReadOnlySpan<int>(a).LastIndexOfAny(target0, target1, target2, GetFalseEqualityComparer<int>()));
                 }
 
                 for (int targetIndex = 0; targetIndex < length - 2; targetIndex++)
@@ -205,8 +212,10 @@ public static void TestMatchLastIndexOfAny_ThreeByte()
                     int target0 = 0;
                     int target1 = 0;
                     int target2 = a[targetIndex + 2];
-                    int idx = span.LastIndexOfAny(target0, target1, target2);
-                    Assert.Equal(targetIndex + 2, idx);
+
+                    Assert.Equal(targetIndex + 2, new ReadOnlySpan<int>(a).LastIndexOfAny(target0, target1, target2));
+                    Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(targetIndex + 2, new ReadOnlySpan<int>(a).LastIndexOfAny(target0, target1, target2, comparer)));
+                    Assert.Equal(-1, new ReadOnlySpan<int>(a).LastIndexOfAny(target0, target1, target2, GetFalseEqualityComparer<int>()));
                 }
             }
         }
@@ -221,10 +230,9 @@ public static void TestNoMatchLastIndexOfAny_ThreeByte()
                 int target0 = rnd.Next(1, 256);
                 int target1 = rnd.Next(1, 256);
                 int target2 = rnd.Next(1, 256);
-                var span = new ReadOnlySpan<int>(a);
 
-                int idx = span.LastIndexOfAny(target0, target1, target2);
-                Assert.Equal(-1, idx);
+                Assert.Equal(-1, new ReadOnlySpan<int>(a).LastIndexOfAny(target0, target1, target2));
+                Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(-1, new ReadOnlySpan<int>(a).LastIndexOfAny(target0, target1, target2, comparer)));
             }
         }
 
@@ -245,9 +253,9 @@ public static void TestMultipleMatchLastIndexOfAny_ThreeByte()
                 a[length - 3] = 200;
                 a[length - 4] = 200;
 
-                var span = new ReadOnlySpan<int>(a);
-                int idx = span.LastIndexOfAny(200, 200, 200);
-                Assert.Equal(length - 1, idx);
+                Assert.Equal(length - 1, new ReadOnlySpan<int>(a).LastIndexOfAny(200, 200, 200));
+                Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(length - 1, new ReadOnlySpan<int>(a).LastIndexOfAny(200, 200, 200, comparer)));
+                Assert.Equal(-1, new ReadOnlySpan<int>(a).LastIndexOfAny(200, 200, 200, GetFalseEqualityComparer<int>()));
             }
         }
 
@@ -259,9 +267,9 @@ public static void MakeSureNoChecksGoOutOfRangeLastIndexOfAny_ThreeByte()
                 var a = new int[length + 2];
                 a[0] = 99;
                 a[length + 1] = 98;
-                var span = new ReadOnlySpan<int>(a, 1, length - 1);
-                int index = span.LastIndexOfAny(99, 98, 99);
-                Assert.Equal(-1, index);
+
+                Assert.Equal(-1, new ReadOnlySpan<int>(a, 1, length - 1).LastIndexOfAny(99, 98, 99));
+                Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(-1, new ReadOnlySpan<int>(a, 1, length - 1).LastIndexOfAny(99, 98, 99, comparer)));
             }
 
             for (int length = 1; length < byte.MaxValue; length++)
@@ -269,23 +277,22 @@ public static void MakeSureNoChecksGoOutOfRangeLastIndexOfAny_ThreeByte()
                 var a = new int[length + 2];
                 a[0] = 99;
                 a[length + 1] = 99;
-                var span = new ReadOnlySpan<int>(a, 1, length - 1);
-                int index = span.LastIndexOfAny(99, 99, 99);
-                Assert.Equal(-1, index);
+
+                Assert.Equal(-1, new ReadOnlySpan<int>(a, 1, length - 1).LastIndexOfAny(99, 99, 99));
+                Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(-1, new ReadOnlySpan<int>(a, 1, length - 1).LastIndexOfAny(99, 99, 99, comparer)));
             }
         }
 
         [Fact]
         public static void ZeroLengthLastIndexOfAny_ManyByte()
         {
-            var sp = new ReadOnlySpan<int>(Array.Empty<int>());
-            var values = new ReadOnlySpan<int>(new int[] { 0, 0, 0, 0 });
-            int idx = sp.LastIndexOfAny(values);
-            Assert.Equal(-1, idx);
+            var values = new int[] { 0, 0, 0, 0 };
+            Assert.Equal(-1, new ReadOnlySpan<int>(Array.Empty<int>()).LastIndexOfAny(values));
+            Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(-1, new ReadOnlySpan<int>(Array.Empty<int>()).LastIndexOfAny(values, comparer)));
 
-            values = new ReadOnlySpan<int>(new int[] { });
-            idx = sp.LastIndexOfAny(values);
-            Assert.Equal(-1, idx);
+            values = new int[] { };
+            Assert.Equal(-1, new ReadOnlySpan<int>(Array.Empty<int>()).LastIndexOfAny(values));
+            Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(-1, new ReadOnlySpan<int>(Array.Empty<int>()).LastIndexOfAny(values, comparer)));
         }
 
         [Fact]
@@ -294,14 +301,14 @@ public static void DefaultFilledLastIndexOfAny_ManyByte()
             for (int length = 0; length < byte.MaxValue; length++)
             {
                 var a = new int[length];
-                var span = new ReadOnlySpan<int>(a);
 
-                var values = new ReadOnlySpan<int>(new int[] { default, 99, 98, 0 });
+                var values = new int[] { default, 99, 98, 0 };
 
                 for (int i = 0; i < length; i++)
                 {
-                    int idx = span.LastIndexOfAny(values);
-                    Assert.Equal(span.Length - 1, idx);
+                    Assert.Equal(a.Length - 1, new ReadOnlySpan<int>(a).LastIndexOfAny(values));
+                    Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(a.Length - 1, new ReadOnlySpan<int>(a).LastIndexOfAny(values, comparer)));
+                    Assert.Equal(-1, new ReadOnlySpan<int>(a).LastIndexOfAny(values, GetFalseEqualityComparer<int>()));
                 }
             }
         }
@@ -316,27 +323,32 @@ public static void TestMatchLastIndexOfAny_ManyByte()
                 {
                     a[i] = i + 1;
                 }
-                var span = new ReadOnlySpan<int>(a);
 
                 for (int targetIndex = 0; targetIndex < length; targetIndex++)
                 {
-                    var values = new ReadOnlySpan<int>(new int[] { a[targetIndex], 0, 0, 0 });
-                    int idx = span.LastIndexOfAny(values);
-                    Assert.Equal(targetIndex, idx);
+                    var values = new int[] { a[targetIndex], 0, 0, 0 };
+
+                    Assert.Equal(targetIndex, new ReadOnlySpan<int>(a).LastIndexOfAny(values));
+                    Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(targetIndex, new ReadOnlySpan<int>(a).LastIndexOfAny(values, comparer)));
+                    Assert.Equal(-1, new ReadOnlySpan<int>(a).LastIndexOfAny(values, GetFalseEqualityComparer<int>()));
                 }
 
                 for (int targetIndex = 0; targetIndex < length - 3; targetIndex++)
                 {
-                    var values = new ReadOnlySpan<int>(new int[] { a[targetIndex], a[targetIndex + 1], a[targetIndex + 2], a[targetIndex + 3] });
-                    int idx = span.LastIndexOfAny(values);
-                    Assert.Equal(targetIndex + 3, idx);
+                    var values = new int[] { a[targetIndex], a[targetIndex + 1], a[targetIndex + 2], a[targetIndex + 3] };
+
+                    Assert.Equal(targetIndex + 3, new ReadOnlySpan<int>(a).LastIndexOfAny(values));
+                    Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(targetIndex + 3, new ReadOnlySpan<int>(a).LastIndexOfAny(values, comparer)));
+                    Assert.Equal(-1, new ReadOnlySpan<int>(a).LastIndexOfAny(values, GetFalseEqualityComparer<int>()));
                 }
 
                 for (int targetIndex = 0; targetIndex < length - 3; targetIndex++)
                 {
-                    var values = new ReadOnlySpan<int>(new int[] { 0, 0, 0, a[targetIndex + 3] });
-                    int idx = span.LastIndexOfAny(values);
-                    Assert.Equal(targetIndex + 3, idx);
+                    var values = new int[] { 0, 0, 0, a[targetIndex + 3] };
+
+                    Assert.Equal(targetIndex + 3, new ReadOnlySpan<int>(a).LastIndexOfAny(values));
+                    Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(targetIndex + 3, new ReadOnlySpan<int>(a).LastIndexOfAny(values, comparer)));
+                    Assert.Equal(-1, new ReadOnlySpan<int>(a).LastIndexOfAny(values, GetFalseEqualityComparer<int>()));
                 }
             }
         }
@@ -357,7 +369,6 @@ public static void TestMatchValuesLargerLastIndexOfAny_ManyByte()
                     }
                     a[i] = 255;
                 }
-                var span = new ReadOnlySpan<int>(a);
 
                 var targets = new int[length * 2];
                 for (int i = 0; i < targets.Length; i++)
@@ -369,9 +380,9 @@ public static void TestMatchValuesLargerLastIndexOfAny_ManyByte()
                     targets[i] = rnd.Next(1, 255);
                 }
 
-                var values = new ReadOnlySpan<int>(targets);
-                int idx = span.LastIndexOfAny(values);
-                Assert.Equal(expectedIndex, idx);
+                Assert.Equal(expectedIndex, new ReadOnlySpan<int>(a).LastIndexOfAny(targets));
+                Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(expectedIndex, new ReadOnlySpan<int>(a).LastIndexOfAny(targets, comparer)));
+                Assert.Equal(-1, new ReadOnlySpan<int>(a).LastIndexOfAny(targets, GetFalseEqualityComparer<int>()));
             }
         }
 
@@ -387,11 +398,9 @@ public static void TestNoMatchLastIndexOfAny_ManyByte()
                 {
                     targets[i] = rnd.Next(1, 256);
                 }
-                var span = new ReadOnlySpan<int>(a);
-                var values = new ReadOnlySpan<int>(targets);
 
-                int idx = span.LastIndexOfAny(values);
-                Assert.Equal(-1, idx);
+                Assert.Equal(-1, new ReadOnlySpan<int>(a).LastIndexOfAny(targets));
+                Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(-1, new ReadOnlySpan<int>(a).LastIndexOfAny(targets, comparer)));
             }
         }
 
@@ -407,11 +416,9 @@ public static void TestNoMatchValuesLargerLastIndexOfAny_ManyByte()
                 {
                     targets[i] = rnd.Next(1, 256);
                 }
-                var span = new ReadOnlySpan<int>(a);
-                var values = new ReadOnlySpan<int>(targets);
 
-                int idx = span.LastIndexOfAny(values);
-                Assert.Equal(-1, idx);
+                Assert.Equal(-1, new ReadOnlySpan<int>(a).LastIndexOfAny(targets));
+                Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(-1, new ReadOnlySpan<int>(a).LastIndexOfAny(targets, comparer)));
             }
         }
 
@@ -433,10 +440,11 @@ public static void TestMultipleMatchLastIndexOfAny_ManyByte()
                 a[length - 4] = 200;
                 a[length - 5] = 200;
 
-                var span = new ReadOnlySpan<int>(a);
-                var values = new ReadOnlySpan<int>(new int[] { 200, 200, 200, 200, 200, 200, 200, 200, 200 });
-                int idx = span.LastIndexOfAny(values);
-                Assert.Equal(length - 1, idx);
+                var values = new int[] { 200, 200, 200, 200, 200, 200, 200, 200, 200 };
+
+                Assert.Equal(length - 1, new ReadOnlySpan<int>(a).LastIndexOfAny(values));
+                Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(length - 1, new ReadOnlySpan<int>(a).LastIndexOfAny(values, comparer)));
+                Assert.Equal(-1, new ReadOnlySpan<int>(a).LastIndexOfAny(values, GetFalseEqualityComparer<int>()));
             }
         }
 
@@ -448,10 +456,10 @@ public static void MakeSureNoChecksGoOutOfRangeLastIndexOfAny_ManyByte()
                 var a = new int[length + 2];
                 a[0] = 99;
                 a[length + 1] = 98;
-                var span = new ReadOnlySpan<int>(a, 1, length - 1);
-                var values = new ReadOnlySpan<int>(new int[] { 99, 98, 99, 98, 99, 98 });
-                int index = span.LastIndexOfAny(values);
-                Assert.Equal(-1, index);
+                var values = new int[] { 99, 98, 99, 98, 99, 98 };
+
+                Assert.Equal(-1, new ReadOnlySpan<int>(a, 1, length - 1).LastIndexOfAny(values));
+                Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(-1, new ReadOnlySpan<int>(a, 1, length - 1).LastIndexOfAny(values, comparer)));
             }
 
             for (int length = 1; length < byte.MaxValue; length++)
@@ -459,19 +467,18 @@ public static void MakeSureNoChecksGoOutOfRangeLastIndexOfAny_ManyByte()
                 var a = new int[length + 2];
                 a[0] = 99;
                 a[length + 1] = 99;
-                var span = new ReadOnlySpan<int>(a, 1, length - 1);
-                var values = new ReadOnlySpan<int>(new int[] { 99, 99, 99, 99, 99, 99 });
-                int index = span.LastIndexOfAny(values);
-                Assert.Equal(-1, index);
+                var values = new int[] { 99, 99, 99, 99, 99, 99 };
+
+                Assert.Equal(-1, new ReadOnlySpan<int>(a, 1, length - 1).LastIndexOfAny(values));
+                Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(-1, new ReadOnlySpan<int>(a, 1, length - 1).LastIndexOfAny(values, comparer)));
             }
         }
 
         [Fact]
         public static void ZeroLengthLastIndexOfAny_String_TwoByte()
         {
-            var sp = new ReadOnlySpan<string>(Array.Empty<string>());
-            int idx = sp.LastIndexOfAny("0", "0");
-            Assert.Equal(-1, idx);
+            Assert.Equal(-1, new ReadOnlySpan<string>(Array.Empty<string>()).LastIndexOfAny("0", "0"));
+            Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(-1, new ReadOnlySpan<string>(Array.Empty<string>()).LastIndexOfAny("0", "0", comparer)));
         }
 
         [Fact]
@@ -482,9 +489,7 @@ public static void DefaultFilledLastIndexOfAny_String_TwoByte()
             for (int length = 0; length < byte.MaxValue; length++)
             {
                 var a = new string[length];
-                var tempSpan = new Span<string>(a);
-                tempSpan.Fill("");
-                ReadOnlySpan<string> span = tempSpan;
+                Array.Fill(a, "");
 
                 string[] targets = { "", "99" };
 
@@ -493,8 +498,10 @@ public static void DefaultFilledLastIndexOfAny_String_TwoByte()
                     int index = rnd.Next(0, 2) == 0 ? 0 : 1;
                     string target0 = targets[index];
                     string target1 = targets[(index + 1) % 2];
-                    int idx = span.LastIndexOfAny(target0, target1);
-                    Assert.Equal(span.Length - 1, idx);
+
+                    Assert.Equal(a.Length - 1, new ReadOnlySpan<string>(a).LastIndexOfAny(target0, target1));
+                    Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(a.Length - 1, new ReadOnlySpan<string>(a).LastIndexOfAny(target0, target1, comparer)));
+                    Assert.Equal(-1, new ReadOnlySpan<string>(a).LastIndexOfAny(target0, target1, GetFalseEqualityComparer<string>()));
                 }
             }
         }
@@ -509,30 +516,35 @@ public static void TestMatchLastIndexOfAny_String_TwoByte()
                 {
                     a[i] = (i + 1).ToString();
                 }
-                var span = new ReadOnlySpan<string>(a);
 
                 for (int targetIndex = 0; targetIndex < length; targetIndex++)
                 {
                     string target0 = a[targetIndex];
                     string target1 = "0";
-                    int idx = span.LastIndexOfAny(target0, target1);
-                    Assert.Equal(targetIndex, idx);
+
+                    Assert.Equal(targetIndex, new ReadOnlySpan<string>(a).LastIndexOfAny(target0, target1));
+                    Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(targetIndex, new ReadOnlySpan<string>(a).LastIndexOfAny(target0, target1, comparer)));
+                    Assert.Equal(-1, new ReadOnlySpan<string>(a).LastIndexOfAny(target0, target1, GetFalseEqualityComparer<string>()));
                 }
 
                 for (int targetIndex = 0; targetIndex < length - 1; targetIndex++)
                 {
                     string target0 = a[targetIndex];
                     string target1 = a[targetIndex + 1];
-                    int idx = span.LastIndexOfAny(target0, target1);
-                    Assert.Equal(targetIndex + 1, idx);
+
+                    Assert.Equal(targetIndex + 1, new ReadOnlySpan<string>(a).LastIndexOfAny(target0, target1));
+                    Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(targetIndex + 1, new ReadOnlySpan<string>(a).LastIndexOfAny(target0, target1, comparer)));
+                    Assert.Equal(-1, new ReadOnlySpan<string>(a).LastIndexOfAny(target0, target1, GetFalseEqualityComparer<string>()));
                 }
 
                 for (int targetIndex = 0; targetIndex < length - 1; targetIndex++)
                 {
                     string target0 = "0";
                     string target1 = a[targetIndex + 1];
-                    int idx = span.LastIndexOfAny(target0, target1);
-                    Assert.Equal(targetIndex + 1, idx);
+
+                    Assert.Equal(targetIndex + 1, new ReadOnlySpan<string>(a).LastIndexOfAny(target0, target1));
+                    Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(targetIndex + 1, new ReadOnlySpan<string>(a).LastIndexOfAny(target0, target1, comparer)));
+                    Assert.Equal(-1, new ReadOnlySpan<string>(a).LastIndexOfAny(target0, target1, GetFalseEqualityComparer<string>()));
                 }
             }
         }
@@ -546,10 +558,9 @@ public static void TestNoMatchLastIndexOfAny_String_TwoByte()
                 var a = new string[length];
                 string target0 = rnd.Next(1, 256).ToString();
                 string target1 = rnd.Next(1, 256).ToString();
-                var span = new ReadOnlySpan<string>(a);
 
-                int idx = span.LastIndexOfAny(target0, target1);
-                Assert.Equal(-1, idx);
+                Assert.Equal(-1, new ReadOnlySpan<string>(a).LastIndexOfAny(target0, target1));
+                Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(-1, new ReadOnlySpan<string>(a).LastIndexOfAny(target0, target1, comparer)));
             }
         }
 
@@ -569,9 +580,9 @@ public static void TestMultipleMatchLastIndexOfAny_String_TwoByte()
                 a[length - 2] = "200";
                 a[length - 3] = "200";
 
-                var span = new ReadOnlySpan<string>(a);
-                int idx = span.LastIndexOfAny("200", "200");
-                Assert.Equal(length - 1, idx);
+                Assert.Equal(length - 1, new ReadOnlySpan<string>(a).LastIndexOfAny("200", "200"));
+                Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(length - 1, new ReadOnlySpan<string>(a).LastIndexOfAny("200", "200", comparer)));
+                Assert.Equal(-1, new ReadOnlySpan<string>(a).LastIndexOfAny("200", "200", GetFalseEqualityComparer<string>()));
             }
         }
 
@@ -583,9 +594,9 @@ public static void MakeSureNoChecksGoOutOfRangeLastIndexOfAny_String_TwoByte()
                 var a = new string[length + 2];
                 a[0] = "99";
                 a[length + 1] = "98";
-                var span = new ReadOnlySpan<string>(a, 1, length - 1);
-                int index = span.LastIndexOfAny("99", "98");
-                Assert.Equal(-1, index);
+
+                Assert.Equal(-1, new ReadOnlySpan<string>(a, 1, length - 1).LastIndexOfAny("99", "98"));
+                Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(-1, new ReadOnlySpan<string>(a, 1, length - 1).LastIndexOfAny("99", "98", comparer)));
             }
 
             for (int length = 1; length < byte.MaxValue; length++)
@@ -593,18 +604,17 @@ public static void MakeSureNoChecksGoOutOfRangeLastIndexOfAny_String_TwoByte()
                 var a = new string[length + 2];
                 a[0] = "99";
                 a[length + 1] = "99";
-                var span = new ReadOnlySpan<string>(a, 1, length - 1);
-                int index = span.LastIndexOfAny("99", "99");
-                Assert.Equal(-1, index);
+
+                Assert.Equal(-1, new ReadOnlySpan<string>(a, 1, length - 1).LastIndexOfAny("99", "99"));
+                Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(-1, new ReadOnlySpan<string>(a, 1, length - 1).LastIndexOfAny("99", "99", comparer)));
             }
         }
 
         [Fact]
         public static void ZeroLengthIndexOf_String_ThreeByte()
         {
-            var sp = new ReadOnlySpan<string>(Array.Empty<string>());
-            int idx = sp.LastIndexOfAny("0", "0", "0");
-            Assert.Equal(-1, idx);
+            Assert.Equal(-1, new ReadOnlySpan<string>(Array.Empty<string>()).LastIndexOfAny("0", "0", "0"));
+            Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(-1, new ReadOnlySpan<string>(Array.Empty<string>()).LastIndexOfAny("0", "0", "0", comparer)));
         }
 
         [Fact]
@@ -615,9 +625,7 @@ public static void DefaultFilledLastIndexOfAny_String_ThreeByte()
             for (int length = 0; length < byte.MaxValue; length++)
             {
                 var a = new string[length];
-                var tempSpan = new Span<string>(a);
-                tempSpan.Fill("");
-                ReadOnlySpan<string> span = tempSpan;
+                Array.Fill(a, "");
 
                 string[] targets = { "", "99", "98" };
 
@@ -627,8 +635,10 @@ public static void DefaultFilledLastIndexOfAny_String_ThreeByte()
                     string target0 = targets[index];
                     string target1 = targets[(index + 1) % 2];
                     string target2 = targets[(index + 1) % 3];
-                    int idx = span.LastIndexOfAny(target0, target1, target2);
-                    Assert.Equal(span.Length - 1, idx);
+
+                    Assert.Equal(a.Length - 1, new ReadOnlySpan<string>(a).LastIndexOfAny(target0, target1, target2));
+                    Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(a.Length - 1, new ReadOnlySpan<string>(a).LastIndexOfAny(target0, target1, target2, comparer)));
+                    Assert.Equal(-1, new ReadOnlySpan<string>(a).LastIndexOfAny(target0, target1, target2, GetFalseEqualityComparer<string>()));
                 }
             }
         }
@@ -643,15 +653,16 @@ public static void TestMatchLastIndexOfAny_String_ThreeByte()
                 {
                     a[i] = (i + 1).ToString();
                 }
-                var span = new ReadOnlySpan<string>(a);
 
                 for (int targetIndex = 0; targetIndex < length; targetIndex++)
                 {
                     string target0 = a[targetIndex];
                     string target1 = "0";
                     string target2 = "0";
-                    int idx = span.LastIndexOfAny(target0, target1, target2);
-                    Assert.Equal(targetIndex, idx);
+
+                    Assert.Equal(targetIndex, new ReadOnlySpan<string>(a).LastIndexOfAny(target0, target1, target2));
+                    Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(targetIndex, new ReadOnlySpan<string>(a).LastIndexOfAny(target0, target1, target2, comparer)));
+                    Assert.Equal(-1, new ReadOnlySpan<string>(a).LastIndexOfAny(target0, target1, target2, GetFalseEqualityComparer<string>()));
                 }
 
                 for (int targetIndex = 0; targetIndex < length - 2; targetIndex++)
@@ -659,8 +670,10 @@ public static void TestMatchLastIndexOfAny_String_ThreeByte()
                     string target0 = a[targetIndex];
                     string target1 = a[targetIndex + 1];
                     string target2 = a[targetIndex + 2];
-                    int idx = span.LastIndexOfAny(target0, target1, target2);
-                    Assert.Equal(targetIndex + 2, idx);
+
+                    Assert.Equal(targetIndex + 2, new ReadOnlySpan<string>(a).LastIndexOfAny(target0, target1, target2));
+                    Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(targetIndex + 2, new ReadOnlySpan<string>(a).LastIndexOfAny(target0, target1, target2, comparer)));
+                    Assert.Equal(-1, new ReadOnlySpan<string>(a).LastIndexOfAny(target0, target1, target2, GetFalseEqualityComparer<string>()));
                 }
 
                 for (int targetIndex = 0; targetIndex < length - 2; targetIndex++)
@@ -668,8 +681,10 @@ public static void TestMatchLastIndexOfAny_String_ThreeByte()
                     string target0 = "0";
                     string target1 = "0";
                     string target2 = a[targetIndex + 2];
-                    int idx = span.LastIndexOfAny(target0, target1, target2);
-                    Assert.Equal(targetIndex + 2, idx);
+
+                    Assert.Equal(targetIndex + 2, new ReadOnlySpan<string>(a).LastIndexOfAny(target0, target1, target2));
+                    Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(targetIndex + 2, new ReadOnlySpan<string>(a).LastIndexOfAny(target0, target1, target2, comparer)));
+                    Assert.Equal(-1, new ReadOnlySpan<string>(a).LastIndexOfAny(target0, target1, target2, GetFalseEqualityComparer<string>()));
                 }
             }
         }
@@ -684,10 +699,9 @@ public static void TestNoMatchLastIndexOfAny_String_ThreeByte()
                 string target0 = rnd.Next(1, 256).ToString();
                 string target1 = rnd.Next(1, 256).ToString();
                 string target2 = rnd.Next(1, 256).ToString();
-                var span = new ReadOnlySpan<string>(a);
 
-                int idx = span.LastIndexOfAny(target0, target1, target2);
-                Assert.Equal(-1, idx);
+                Assert.Equal(-1, new ReadOnlySpan<string>(a).LastIndexOfAny(target0, target1, target2));
+                Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(-1, new ReadOnlySpan<string>(a).LastIndexOfAny(target0, target1, target2, comparer)));
             }
         }
 
@@ -708,9 +722,9 @@ public static void TestMultipleMatchLastIndexOfAny_String_ThreeByte()
                 a[length - 3] = "200";
                 a[length - 4] = "200";
 
-                var span = new ReadOnlySpan<string>(a);
-                int idx = span.LastIndexOfAny("200", "200", "200");
-                Assert.Equal(length - 1, idx);
+                Assert.Equal(length - 1, new ReadOnlySpan<string>(a).LastIndexOfAny("200", "200", "200"));
+                Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(length - 1, new ReadOnlySpan<string>(a).LastIndexOfAny("200", "200", "200", comparer)));
+                Assert.Equal(-1, new ReadOnlySpan<string>(a).LastIndexOfAny("200", "200", "200", GetFalseEqualityComparer<string>()));
             }
         }
 
@@ -722,9 +736,9 @@ public static void MakeSureNoChecksGoOutOfRangeLastIndexOfAny_String_ThreeByte()
                 var a = new string[length + 2];
                 a[0] = "99";
                 a[length + 1] = "98";
-                var span = new ReadOnlySpan<string>(a, 1, length - 1);
-                int index = span.LastIndexOfAny("99", "98", "99");
-                Assert.Equal(-1, index);
+
+                Assert.Equal(-1, new ReadOnlySpan<string>(a, 1, length - 1).LastIndexOfAny("99", "98", "99"));
+                Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(-1, new ReadOnlySpan<string>(a, 1, length - 1).LastIndexOfAny("99", "98", "99", comparer)));
             }
 
             for (int length = 1; length < byte.MaxValue; length++)
@@ -732,23 +746,22 @@ public static void MakeSureNoChecksGoOutOfRangeLastIndexOfAny_String_ThreeByte()
                 var a = new string[length + 2];
                 a[0] = "99";
                 a[length + 1] = "99";
-                var span = new ReadOnlySpan<string>(a, 1, length - 1);
-                int index = span.LastIndexOfAny("99", "99", "99");
-                Assert.Equal(-1, index);
+
+                Assert.Equal(-1, new ReadOnlySpan<string>(a, 1, length - 1).LastIndexOfAny("99", "99", "99"));
+                Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(-1, new ReadOnlySpan<string>(a, 1, length - 1).LastIndexOfAny("99", "99", "99", comparer)));
             }
         }
 
         [Fact]
         public static void ZeroLengthLastIndexOfAny_String_ManyByte()
         {
-            var sp = new ReadOnlySpan<string>(Array.Empty<string>());
-            var values = new ReadOnlySpan<string>(new string[] { "0", "0", "0", "0" });
-            int idx = sp.LastIndexOfAny(values);
-            Assert.Equal(-1, idx);
+            var values = new string[] { "0", "0", "0", "0" };
+
+            Assert.Equal(-1, new ReadOnlySpan<string>(Array.Empty<string>()).LastIndexOfAny(values));
+            Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(-1, new ReadOnlySpan<string>(Array.Empty<string>()).LastIndexOfAny(values, comparer)));
 
-            values = new ReadOnlySpan<string>(new string[] { });
-            idx = sp.LastIndexOfAny(values);
-            Assert.Equal(-1, idx);
+            Assert.Equal(-1, new ReadOnlySpan<string>(new string[] { }).LastIndexOfAny(values));
+            Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(-1, new ReadOnlySpan<string>(new string[] { }).LastIndexOfAny(values, comparer)));
         }
 
         [Fact]
@@ -757,16 +770,15 @@ public static void DefaultFilledLastIndexOfAny_String_ManyByte()
             for (int length = 0; length < byte.MaxValue; length++)
             {
                 var a = new string[length];
-                var tempSpan = new Span<string>(a);
-                tempSpan.Fill("");
-                ReadOnlySpan<string> span = tempSpan;
+                Array.Fill(a, "");
 
-                var values = new ReadOnlySpan<string>(new string[] { "", "99", "98", "0" });
+                var values = new string[] { "", "99", "98", "0" };
 
                 for (int i = 0; i < length; i++)
                 {
-                    int idx = span.LastIndexOfAny(values);
-                    Assert.Equal(span.Length - 1, idx);
+                    Assert.Equal(a.Length - 1, new ReadOnlySpan<string>(a).LastIndexOfAny(values));
+                    Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(a.Length - 1, new ReadOnlySpan<string>(a).LastIndexOfAny(values, comparer)));
+                    Assert.Equal(-1, new ReadOnlySpan<string>(a).LastIndexOfAny(values, GetFalseEqualityComparer<string>()));
                 }
             }
         }
@@ -781,27 +793,32 @@ public static void TestMatchLastIndexOfAny_String_ManyByte()
                 {
                     a[i] = (i + 1).ToString();
                 }
-                var span = new ReadOnlySpan<string>(a);
 
                 for (int targetIndex = 0; targetIndex < length; targetIndex++)
                 {
-                    var values = new ReadOnlySpan<string>(new string[] { a[targetIndex], "0", "0", "0" });
-                    int idx = span.LastIndexOfAny(values);
-                    Assert.Equal(targetIndex, idx);
+                    var values = new string[] { a[targetIndex], "0", "0", "0" };
+
+                    Assert.Equal(targetIndex, new ReadOnlySpan<string>(a).LastIndexOfAny(values));
+                    Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(targetIndex, new ReadOnlySpan<string>(a).LastIndexOfAny(values, comparer)));
+                    Assert.Equal(-1, new ReadOnlySpan<string>(a).LastIndexOfAny(values, GetFalseEqualityComparer<string>()));
                 }
 
                 for (int targetIndex = 0; targetIndex < length - 3; targetIndex++)
                 {
-                    var values = new ReadOnlySpan<string>(new string[] { a[targetIndex], a[targetIndex + 1], a[targetIndex + 2], a[targetIndex + 3] });
-                    int idx = span.LastIndexOfAny(values);
-                    Assert.Equal(targetIndex + 3, idx);
+                    var values = new string[] { a[targetIndex], a[targetIndex + 1], a[targetIndex + 2], a[targetIndex + 3] };
+
+                    Assert.Equal(targetIndex + 3, new ReadOnlySpan<string>(a).LastIndexOfAny(values));
+                    Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(targetIndex + 3, new ReadOnlySpan<string>(a).LastIndexOfAny(values, comparer)));
+                    Assert.Equal(-1, new ReadOnlySpan<string>(a).LastIndexOfAny(values, GetFalseEqualityComparer<string>()));
                 }
 
                 for (int targetIndex = 0; targetIndex < length - 3; targetIndex++)
                 {
-                    var values = new ReadOnlySpan<string>(new string[] { "0", "0", "0", a[targetIndex + 3] });
-                    int idx = span.LastIndexOfAny(values);
-                    Assert.Equal(targetIndex + 3, idx);
+                    var values = new string[] { "0", "0", "0", a[targetIndex + 3] };
+
+                    Assert.Equal(targetIndex + 3, new ReadOnlySpan<string>(a).LastIndexOfAny(values));
+                    Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(targetIndex + 3, new ReadOnlySpan<string>(a).LastIndexOfAny(values, comparer)));
+                    Assert.Equal(-1, new ReadOnlySpan<string>(a).LastIndexOfAny(values, GetFalseEqualityComparer<string>()));
                 }
             }
         }
@@ -823,7 +840,6 @@ public static void TestMatchValuesLargerLastIndexOfAny_String_ManyByte()
                     }
                     a[i] = "255";
                 }
-                var span = new ReadOnlySpan<string>(a);
 
                 var targets = new string[length * 2];
                 for (int i = 0; i < targets.Length; i++)
@@ -836,9 +852,9 @@ public static void TestMatchValuesLargerLastIndexOfAny_String_ManyByte()
                     targets[i] = rnd.Next(1, 255).ToString();
                 }
 
-                var values = new ReadOnlySpan<string>(targets);
-                int idx = span.LastIndexOfAny(values);
-                Assert.Equal(expectedIndex, idx);
+                Assert.Equal(expectedIndex, new ReadOnlySpan<string>(a).LastIndexOfAny(targets));
+                Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(expectedIndex, new ReadOnlySpan<string>(a).LastIndexOfAny(targets, comparer)));
+                Assert.Equal(-1, new ReadOnlySpan<string>(a).LastIndexOfAny(targets, GetFalseEqualityComparer<string>()));
             }
         }
 
@@ -854,11 +870,9 @@ public static void TestNoMatchLastIndexOfAny_String_ManyByte()
                 {
                     targets[i] = rnd.Next(1, 256).ToString();
                 }
-                var span = new ReadOnlySpan<string>(a);
-                var values = new ReadOnlySpan<string>(targets);
 
-                int idx = span.LastIndexOfAny(values);
-                Assert.Equal(-1, idx);
+                Assert.Equal(-1, new ReadOnlySpan<string>(a).LastIndexOfAny(targets));
+                Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(-1, new ReadOnlySpan<string>(a).LastIndexOfAny(targets, comparer)));
             }
         }
 
@@ -874,11 +888,9 @@ public static void TestNoMatchValuesLargerLastIndexOfAny_String_ManyByte()
                 {
                     targets[i] = rnd.Next(1, 256).ToString();
                 }
-                var span = new ReadOnlySpan<string>(a);
-                var values = new ReadOnlySpan<string>(targets);
 
-                int idx = span.LastIndexOfAny(values);
-                Assert.Equal(-1, idx);
+                Assert.Equal(-1, new ReadOnlySpan<string>(a).LastIndexOfAny(targets));
+                Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(-1, new ReadOnlySpan<string>(a).LastIndexOfAny(targets, comparer)));
             }
         }
 
@@ -900,10 +912,11 @@ public static void TestMultipleMatchLastIndexOfAny_String_ManyByte()
                 a[length - 4] = "200";
                 a[length - 5] = "200";
 
-                var span = new ReadOnlySpan<string>(a);
-                var values = new ReadOnlySpan<string>(new string[] { "200", "200", "200", "200", "200", "200", "200", "200", "200" });
-                int idx = span.LastIndexOfAny(values);
-                Assert.Equal(length - 1, idx);
+                var values = new string[] { "200", "200", "200", "200", "200", "200", "200", "200", "200" };
+
+                Assert.Equal(length - 1, new ReadOnlySpan<string>(a).LastIndexOfAny(values));
+                Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(length - 1, new ReadOnlySpan<string>(a).LastIndexOfAny(values, comparer)));
+                Assert.Equal(-1, new ReadOnlySpan<string>(a).LastIndexOfAny(values, GetFalseEqualityComparer<string>()));
             }
         }
 
@@ -915,10 +928,11 @@ public static void MakeSureNoChecksGoOutOfRangeLastIndexOfAny_String_ManyByte()
                 var a = new string[length + 2];
                 a[0] = "99";
                 a[length + 1] = "98";
-                var span = new ReadOnlySpan<string>(a, 1, length - 1);
-                var values = new ReadOnlySpan<string>(new string[] { "99", "98", "99", "98", "99", "98" });
-                int index = span.LastIndexOfAny(values);
-                Assert.Equal(-1, index);
+
+                var values = new string[] { "99", "98", "99", "98", "99", "98" };
+
+                Assert.Equal(-1, new ReadOnlySpan<string>(a, 1, length - 1).LastIndexOfAny(values));
+                Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(-1, new ReadOnlySpan<string>(a, 1, length - 1).LastIndexOfAny(values, comparer)));
             }
 
             for (int length = 1; length < byte.MaxValue; length++)
@@ -926,10 +940,11 @@ public static void MakeSureNoChecksGoOutOfRangeLastIndexOfAny_String_ManyByte()
                 var a = new string[length + 2];
                 a[0] = "99";
                 a[length + 1] = "99";
-                var span = new ReadOnlySpan<string>(a, 1, length - 1);
-                var values = new ReadOnlySpan<string>(new string[] { "99", "99", "99", "99", "99", "99" });
-                int index = span.LastIndexOfAny(values);
-                Assert.Equal(-1, index);
+
+                var values = new string[] { "99", "99", "99", "99", "99", "99" };
+
+                Assert.Equal(-1, new ReadOnlySpan<string>(a, 1, length - 1).LastIndexOfAny(values));
+                Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(-1, new ReadOnlySpan<string>(a, 1, length - 1).LastIndexOfAny(values, comparer)));
             }
         }
 
@@ -937,20 +952,27 @@ public static void MakeSureNoChecksGoOutOfRangeLastIndexOfAny_String_ManyByte()
         [MemberData(nameof(TestHelpers.LastIndexOfAnyNullSequenceData), MemberType = typeof(TestHelpers))]
         public static void LastIndexOfAnyNullSequence_String(string[] spanInput, string[] searchInput, int expected)
         {
-            ReadOnlySpan<string> theStrings = spanInput;
-            Assert.Equal(expected, theStrings.LastIndexOfAny(searchInput));
-            Assert.Equal(expected, theStrings.LastIndexOfAny((ReadOnlySpan<string>)searchInput));
+            Assert.Equal(expected, new ReadOnlySpan<string>(spanInput).LastIndexOfAny(searchInput));
+            Assert.Equal(expected, new ReadOnlySpan<string>(spanInput).LastIndexOfAny((ReadOnlySpan<string>)searchInput));
+
+            Assert.All(GetDefaultEqualityComparers<string>(), comparer =>
+            {
+                Assert.Equal(expected, new ReadOnlySpan<string>(spanInput).LastIndexOfAny(searchInput, comparer));
+                Assert.Equal(expected, new ReadOnlySpan<string>(spanInput).LastIndexOfAny((ReadOnlySpan<string>)searchInput, comparer));
+            });
 
             if (searchInput != null)
             {
                 if (searchInput.Length >= 3)
                 {
-                    Assert.Equal(expected, theStrings.LastIndexOfAny(searchInput[0], searchInput[1], searchInput[2]));
+                    Assert.Equal(expected, new ReadOnlySpan<string>(spanInput).LastIndexOfAny(searchInput[0], searchInput[1], searchInput[2]));
+                    Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(expected, new ReadOnlySpan<string>(spanInput).LastIndexOfAny(searchInput[0], searchInput[1], searchInput[2], comparer)));
                 }
 
                 if (searchInput.Length >= 2)
                 {
-                    Assert.Equal(expected, theStrings.LastIndexOfAny(searchInput[0], searchInput[1]));
+                    Assert.Equal(expected, new ReadOnlySpan<string>(spanInput).LastIndexOfAny(searchInput[0], searchInput[1]));
+                    Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(expected, new ReadOnlySpan<string>(spanInput).LastIndexOfAny(searchInput[0], searchInput[1], comparer)));
                 }
             }
         }
diff --git a/src/libraries/System.Memory/tests/ReadOnlySpan/LastIndexOfSequence.T.cs b/src/libraries/System.Memory/tests/ReadOnlySpan/LastIndexOfSequence.T.cs
index 1e5938ddc41503..73d0ae27cb394b 100644
--- a/src/libraries/System.Memory/tests/ReadOnlySpan/LastIndexOfSequence.T.cs
+++ b/src/libraries/System.Memory/tests/ReadOnlySpan/LastIndexOfSequence.T.cs
@@ -10,237 +10,274 @@ public static partial class ReadOnlySpanTests
         [Fact]
         public static void LastIndexOfSequenceMatchAtStart()
         {
-            ReadOnlySpan<int> span = new ReadOnlySpan<int>(new int[] { 5, 1, 77, 2, 3, 77, 77, 4, 5, 77, 77, 77, 88, 6, 6, 77, 77, 88, 9 });
-            ReadOnlySpan<int> value = new ReadOnlySpan<int>(new int[] { 5, 1, 77 });
-            int index = span.LastIndexOf(value);
-            Assert.Equal(0, index);
+            var source = new int[] { 5, 1, 77, 2, 3, 77, 77, 4, 5, 77, 77, 77, 88, 6, 6, 77, 77, 88, 9 };
+            var value = new int[] { 5, 1, 77 };
+
+            Assert.Equal(0, new ReadOnlySpan<int>(source).LastIndexOf(value));
+            Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(0, new ReadOnlySpan<int>(source).LastIndexOf(value, comparer)));
+            Assert.Equal(-1, new ReadOnlySpan<int>(source).LastIndexOf(value, GetFalseEqualityComparer<int>()));
         }
 
         [Fact]
         public static void LastIndexOfSequenceMultipleMatch()
         {
-            ReadOnlySpan<int> span = new ReadOnlySpan<int>(new int[] { 1, 2, 3, 1, 2, 3, 1, 2, 3, 1 });
-            ReadOnlySpan<int> value = new ReadOnlySpan<int>(new int[] { 2, 3 });
-            int index = span.LastIndexOf(value);
-            Assert.Equal(7, index);
+            var source = new int[] { 1, 2, 3, 1, 2, 3, 1, 2, 3, 1 };
+            var value = new int[] { 2, 3 };
+
+            Assert.Equal(7, new ReadOnlySpan<int>(source).LastIndexOf(value));
+            Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(7, new ReadOnlySpan<int>(source).LastIndexOf(value, comparer)));
+            Assert.Equal(-1, new ReadOnlySpan<int>(source).LastIndexOf(value, GetFalseEqualityComparer<int>()));
         }
 
         [Fact]
         public static void LastIndexOfSequenceRestart()
         {
-            ReadOnlySpan<int> span = new ReadOnlySpan<int>(new int[] { 0, 1, 77, 2, 3, 77, 77, 4, 5, 77, 77, 77, 88, 6, 6, 77, 77, 8, 9, 77, 0, 1 });
-            ReadOnlySpan<int> value = new ReadOnlySpan<int>(new int[] { 77, 77, 88 });
-            int index = span.LastIndexOf(value);
-            Assert.Equal(10, index);
+            var source = new int[] { 0, 1, 77, 2, 3, 77, 77, 4, 5, 77, 77, 77, 88, 6, 6, 77, 77, 8, 9, 77, 0, 1 };
+            var value = new int[] { 77, 77, 88 };
+
+            Assert.Equal(10, new ReadOnlySpan<int>(source).LastIndexOf(value));
+            Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(10, new ReadOnlySpan<int>(source).LastIndexOf(value, comparer)));
+            Assert.Equal(-1, new ReadOnlySpan<int>(source).LastIndexOf(value, GetFalseEqualityComparer<int>()));
         }
 
         [Fact]
         public static void LastIndexOfSequenceNoMatch()
         {
-            ReadOnlySpan<int> span = new ReadOnlySpan<int>(new int[] { 0, 1, 77, 2, 3, 77, 77, 4, 5, 77, 77, 77, 88, 6, 6, 77, 77, 88, 9 });
-            ReadOnlySpan<int> value = new ReadOnlySpan<int>(new int[] { 77, 77, 88, 99 });
-            int index = span.LastIndexOf(value);
-            Assert.Equal(-1, index);
+            var source = new int[] { 0, 1, 77, 2, 3, 77, 77, 4, 5, 77, 77, 77, 88, 6, 6, 77, 77, 88, 9 };
+            var value = new int[] { 77, 77, 88, 99 };
+
+            Assert.Equal(-1, new ReadOnlySpan<int>(source).LastIndexOf(value));
+            Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(-1, new ReadOnlySpan<int>(source).LastIndexOf(value, comparer)));
         }
 
         [Fact]
         public static void LastIndexOfSequenceNotEvenAHeadMatch()
         {
-            ReadOnlySpan<int> span = new ReadOnlySpan<int>(new int[] { 0, 1, 77, 2, 3, 77, 77, 4, 5, 77, 77, 77, 88, 6, 6, 77, 77, 88, 9 });
-            ReadOnlySpan<int> value = new ReadOnlySpan<int>(new int[] { 100, 77, 88, 99 });
-            int index = span.LastIndexOf(value);
-            Assert.Equal(-1, index);
+            var source = new int[] { 0, 1, 77, 2, 3, 77, 77, 4, 5, 77, 77, 77, 88, 6, 6, 77, 77, 88, 9 };
+            var value = new int[] { 100, 77, 88, 99 };
+
+            Assert.Equal(-1, new ReadOnlySpan<int>(source).LastIndexOf(value));
+            Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(-1, new ReadOnlySpan<int>(source).LastIndexOf(value, comparer)));
         }
 
         [Fact]
         public static void LastIndexOfSequenceMatchAtVeryEnd()
         {
-            ReadOnlySpan<int> span = new ReadOnlySpan<int>(new int[] { 0, 1, 2, 3, 4, 5 });
-            ReadOnlySpan<int> value = new ReadOnlySpan<int>(new int[] { 3, 4, 5 });
-            int index = span.LastIndexOf(value);
-            Assert.Equal(3, index);
+            var source = new int[] { 0, 1, 2, 3, 4, 5 };
+            var value = new int[] { 3, 4, 5 };
+
+            Assert.Equal(3, new ReadOnlySpan<int>(source).LastIndexOf(value));
+            Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(3, new ReadOnlySpan<int>(source).LastIndexOf(value, comparer)));
+            Assert.Equal(-1, new ReadOnlySpan<int>(source).LastIndexOf(value, GetFalseEqualityComparer<int>()));
         }
 
         [Fact]
         public static void LastIndexOfSequenceJustPastVeryEnd()
         {
-            ReadOnlySpan<int> span = new ReadOnlySpan<int>(new int[] { 0, 1, 2, 3, 4, 5 }, 0, 5);
-            ReadOnlySpan<int> value = new ReadOnlySpan<int>(new int[] { 3, 4, 5 });
-            int index = span.LastIndexOf(value);
-            Assert.Equal(-1, index);
+            var source = new int[] { 0, 1, 2, 3, 4, 5 };
+            var value = new int[] { 3, 4, 5 };
+
+            Assert.Equal(-1, new ReadOnlySpan<int>(source, 0, 5).LastIndexOf(value));
+            Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(-1, new ReadOnlySpan<int>(source, 0, 5).LastIndexOf(value, comparer)));
         }
 
         [Fact]
         public static void LastIndexOfSequenceZeroLengthValue()
         {
-            // A zero-length value is always "found" at the end of the span.
-            ReadOnlySpan<int> span = new ReadOnlySpan<int>(new int[] { 0, 1, 77, 2, 3, 77, 77, 4, 5, 77, 77, 77, 88, 6, 6, 77, 77, 88, 9 });
-            ReadOnlySpan<int> value = new ReadOnlySpan<int>(Array.Empty<int>());
-            int index = span.LastIndexOf(value);
-            Assert.Equal(span.Length, index);
+            // A zero-length value is always "found" at the end of the source.
+            var source = new int[] { 0, 1, 77, 2, 3, 77, 77, 4, 5, 77, 77, 77, 88, 6, 6, 77, 77, 88, 9 };
+            var value = Array.Empty<int>();
+
+            Assert.Equal(source.Length, new ReadOnlySpan<int>(source).LastIndexOf(value));
+            Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(source.Length, new ReadOnlySpan<int>(source).LastIndexOf(value, comparer)));
         }
 
         [Fact]
         public static void LastIndexOfSequenceZeroLengthSpan()
         {
-            ReadOnlySpan<int> span = new ReadOnlySpan<int>(Array.Empty<int>());
-            ReadOnlySpan<int> value = new ReadOnlySpan<int>(new int[] { 1, 2, 3 });
-            int index = span.LastIndexOf(value);
-            Assert.Equal(-1, index);
+            var source = Array.Empty<int>();
+            var value = new int[] { 1, 2, 3 };
+
+            Assert.Equal(-1, new ReadOnlySpan<int>(source).LastIndexOf(value));
+            Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(-1, new ReadOnlySpan<int>(source).LastIndexOf(value, comparer)));
         }
 
         [Fact]
         public static void LastIndexOfSequenceLengthOneValue()
         {
-            ReadOnlySpan<int> span = new ReadOnlySpan<int>(new int[] { 0, 1, 2, 3, 4, 5 });
-            ReadOnlySpan<int> value = new ReadOnlySpan<int>(new int[] { 2 });
-            int index = span.LastIndexOf(value);
-            Assert.Equal(2, index);
+            var source = new int[] { 0, 1, 2, 3, 4, 5 };
+            var value = new int[] { 2 };
+
+            Assert.Equal(2, new ReadOnlySpan<int>(source).LastIndexOf(value));
+            Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(2, new ReadOnlySpan<int>(source).LastIndexOf(value, comparer)));
+            Assert.Equal(-1, new ReadOnlySpan<int>(source).LastIndexOf(value, GetFalseEqualityComparer<int>()));
         }
 
         [Fact]
         public static void LastIndexOfSequenceLengthOneValueAtVeryEnd()
         {
-            ReadOnlySpan<int> span = new ReadOnlySpan<int>(new int[] { 0, 1, 2, 3, 4, 5 });
-            ReadOnlySpan<int> value = new ReadOnlySpan<int>(new int[] { 5 });
-            int index = span.LastIndexOf(value);
-            Assert.Equal(5, index);
+            var source = new int[] { 0, 1, 2, 3, 4, 5 };
+            var value = new int[] { 5 };
+
+            Assert.Equal(5, new ReadOnlySpan<int>(source).LastIndexOf(value));
+            Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(5, new ReadOnlySpan<int>(source).LastIndexOf(value, comparer)));
+            Assert.Equal(-1, new ReadOnlySpan<int>(source).LastIndexOf(value, GetFalseEqualityComparer<int>()));
         }
 
         [Fact]
         public static void LastIndexOfSequenceLengthOneValueMultipleTimes()
         {
-            ReadOnlySpan<int> span = new ReadOnlySpan<int>(new int[] { 0, 1, 5, 3, 4, 5 });
-            ReadOnlySpan<int> value = new ReadOnlySpan<int>(new int[] { 5 });
-            int index = span.LastIndexOf(value);
-            Assert.Equal(5, index);
+            var source = new int[] { 0, 1, 5, 3, 4, 5 };
+            var value = new int[] { 5 };
+
+            Assert.Equal(5, new ReadOnlySpan<int>(source).LastIndexOf(value));
+            Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(5, new ReadOnlySpan<int>(source).LastIndexOf(value, comparer)));
+            Assert.Equal(-1, new ReadOnlySpan<int>(source).LastIndexOf(value, GetFalseEqualityComparer<int>()));
         }
 
         [Fact]
         public static void LastIndexOfSequenceLengthOneValueJustPasttVeryEnd()
         {
-            ReadOnlySpan<int> span = new ReadOnlySpan<int>(new int[] { 0, 1, 2, 3, 4, 5 }, 0, 5);
-            ReadOnlySpan<int> value = new ReadOnlySpan<int>(new int[] { 5 });
-            int index = span.LastIndexOf(value);
-            Assert.Equal(-1, index);
+            var source = new int[] { 0, 1, 2, 3, 4, 5 };
+            var value = new int[] { 5 };
+
+            Assert.Equal(-1, new ReadOnlySpan<int>(source, 0, 5).LastIndexOf(value));
+            Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.Equal(-1, new ReadOnlySpan<int>(source, 0, 5).LastIndexOf(value, comparer)));
         }
 
         [Fact]
         public static void LastIndexOfSequenceMatchAtStart_String()
         {
-            ReadOnlySpan<string> span = new ReadOnlySpan<string>(new string[] { "5", "1", "77", "2", "3", "77", "77", "4", "5", "77", "77", "77", "88", "6", "6", "77", "77", "88", "9" });
-            ReadOnlySpan<string> value = new ReadOnlySpan<string>(new string[] { "5", "1", "77" });
-            int index = span.LastIndexOf(value);
-            Assert.Equal(0, index);
+            var source = new string[] { "5", "1", "77", "2", "3", "77", "77", "4", "5", "77", "77", "77", "88", "6", "6", "77", "77", "88", "9" };
+            var value = new string[] { "5", "1", "77" };
+
+            Assert.Equal(0, new ReadOnlySpan<string>(source).LastIndexOf(value));
+            Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(0, new ReadOnlySpan<string>(source).LastIndexOf(value, comparer)));
+            Assert.Equal(-1, new ReadOnlySpan<string>(source).LastIndexOf(value, GetFalseEqualityComparer<string>()));
         }
 
         [Fact]
         public static void LastIndexOfSequenceMultipleMatch_String()
         {
-            ReadOnlySpan<string> span = new ReadOnlySpan<string>(new string[] { "1", "2", "3", "1", "2", "3", "1", "2", "3" });
-            ReadOnlySpan<string> value = new ReadOnlySpan<string>(new string[] { "2", "3" });
-            int index = span.LastIndexOf(value);
-            Assert.Equal(7, index);
+            var source = new string[] { "1", "2", "3", "1", "2", "3", "1", "2", "3" };
+            var value = new string[] { "2", "3" };
+
+            Assert.Equal(7, new ReadOnlySpan<string>(source).LastIndexOf(value));
+            Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(7, new ReadOnlySpan<string>(source).LastIndexOf(value, comparer)));
+            Assert.Equal(-1, new ReadOnlySpan<string>(source).LastIndexOf(value, GetFalseEqualityComparer<string>()));
         }
 
         [Fact]
         public static void LastIndexOfSequenceRestart_String()
         {
-            ReadOnlySpan<string> span = new ReadOnlySpan<string>(new string[] { "0", "1", "77", "2", "3", "77", "77", "4", "5", "77", "77", "77", "88", "6", "6", "77", "77", "8", "9", "77", "0", "1" });
-            ReadOnlySpan<string> value = new ReadOnlySpan<string>(new string[] { "77", "77", "88" });
-            int index = span.LastIndexOf(value);
-            Assert.Equal(10, index);
+            var source = new string[] { "0", "1", "77", "2", "3", "77", "77", "4", "5", "77", "77", "77", "88", "6", "6", "77", "77", "8", "9", "77", "0", "1" };
+            var value = new string[] { "77", "77", "88" };
+
+            Assert.Equal(10, new ReadOnlySpan<string>(source).LastIndexOf(value));
+            Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(10, new ReadOnlySpan<string>(source).LastIndexOf(value, comparer)));
+            Assert.Equal(-1, new ReadOnlySpan<string>(source).LastIndexOf(value, GetFalseEqualityComparer<string>()));
         }
 
         [Fact]
         public static void LastIndexOfSequenceNoMatch_String()
         {
-            ReadOnlySpan<string> span = new ReadOnlySpan<string>(new string[] { "0", "1", "77", "2", "3", "77", "77", "4", "5", "77", "77", "77", "88", "6", "6", "77", "77", "88", "9" });
-            ReadOnlySpan<string> value = new ReadOnlySpan<string>(new string[] { "77", "77", "88", "99" });
-            int index = span.LastIndexOf(value);
-            Assert.Equal(-1, index);
+            var source = new string[] { "0", "1", "77", "2", "3", "77", "77", "4", "5", "77", "77", "77", "88", "6", "6", "77", "77", "88", "9" };
+            var value = new string[] { "77", "77", "88", "99" };
+
+            Assert.Equal(-1, new ReadOnlySpan<string>(source).LastIndexOf(value));
+            Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(-1, new ReadOnlySpan<string>(source).LastIndexOf(value, comparer)));
         }
 
         [Fact]
         public static void LastIndexOfSequenceNotEvenAHeadMatch_String()
         {
-            ReadOnlySpan<string> span = new ReadOnlySpan<string>(new string[] { "0", "1", "77", "2", "3", "77", "77", "4", "5", "77", "77", "77", "88", "6", "6", "77", "77", "88", "9" });
-            ReadOnlySpan<string> value = new ReadOnlySpan<string>(new string[] { "100", "77", "88", "99" });
-            int index = span.LastIndexOf(value);
-            Assert.Equal(-1, index);
+            var source = new string[] { "0", "1", "77", "2", "3", "77", "77", "4", "5", "77", "77", "77", "88", "6", "6", "77", "77", "88", "9" };
+            var value = new string[] { "100", "77", "88", "99" };
+
+            Assert.Equal(-1, new ReadOnlySpan<string>(source).LastIndexOf(value));
+            Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(-1, new ReadOnlySpan<string>(source).LastIndexOf(value, comparer)));
         }
 
         [Fact]
         public static void LastIndexOfSequenceMatchAtVeryEnd_String()
         {
-            ReadOnlySpan<string> span = new ReadOnlySpan<string>(new string[] { "0", "1", "2", "3", "4", "5" });
-            ReadOnlySpan<string> value = new ReadOnlySpan<string>(new string[] { "3", "4", "5" });
-            int index = span.LastIndexOf(value);
-            Assert.Equal(3, index);
+            var source = new string[] { "0", "1", "2", "3", "4", "5" };
+            var value = new string[] { "3", "4", "5" };
+
+            Assert.Equal(3, new ReadOnlySpan<string>(source).LastIndexOf(value));
+            Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(3, new ReadOnlySpan<string>(source).LastIndexOf(value, comparer)));
+            Assert.Equal(-1, new ReadOnlySpan<string>(source).LastIndexOf(value, GetFalseEqualityComparer<string>()));
         }
 
         [Fact]
         public static void LastIndexOfSequenceJustPastVeryEnd_String()
         {
-            ReadOnlySpan<string> span = new ReadOnlySpan<string>(new string[] { "0", "1", "2", "3", "4", "5" }, 0, 5);
-            ReadOnlySpan<string> value = new ReadOnlySpan<string>(new string[] { "3", "4", "5" });
-            int index = span.LastIndexOf(value);
-            Assert.Equal(-1, index);
+            var source = new string[] { "0", "1", "2", "3", "4", "5" };
+            var value = new string[] { "3", "4", "5" };
+
+            Assert.Equal(-1, new ReadOnlySpan<string>(source, 0, 5).LastIndexOf(value));
+            Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(-1, new ReadOnlySpan<string>(source, 0, 5).LastIndexOf(value, comparer)));
         }
 
         [Fact]
         public static void LastIndexOfSequenceZeroLengthValue_String()
         {
-            // A zero-length value is always "found" at the end of the span.
-            ReadOnlySpan<string> span = new ReadOnlySpan<string>(new string[] { "0", "1", "77", "2", "3", "77", "77", "4", "5", "77", "77", "77", "88", "6", "6", "77", "77", "88", "9" });
-            ReadOnlySpan<string> value = new ReadOnlySpan<string>(Array.Empty<string>());
-            int index = span.LastIndexOf(value);
-            Assert.Equal(span.Length, index);
+            // A zero-length value is always "found" at the end of the source.
+            var source = new string[] { "0", "1", "77", "2", "3", "77", "77", "4", "5", "77", "77", "77", "88", "6", "6", "77", "77", "88", "9" };
+            var value = Array.Empty<string>();
+
+            Assert.Equal(source.Length, new ReadOnlySpan<string>(source).LastIndexOf(value));
+            Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(source.Length, new ReadOnlySpan<string>(source).LastIndexOf(value, comparer)));
         }
 
         [Fact]
         public static void LastIndexOfSequenceZeroLengthSpan_String()
         {
-            ReadOnlySpan<string> span = new ReadOnlySpan<string>(Array.Empty<string>());
-            ReadOnlySpan<string> value = new ReadOnlySpan<string>(new string[] { "1", "2", "3" });
-            int index = span.LastIndexOf(value);
-            Assert.Equal(-1, index);
+            var source = Array.Empty<string>();
+            var value = new string[] { "1", "2", "3" };
+
+            Assert.Equal(-1, new ReadOnlySpan<string>(source).LastIndexOf(value));
+            Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(-1, new ReadOnlySpan<string>(source).LastIndexOf(value, comparer)));
         }
 
         [Fact]
         public static void LastIndexOfSequenceLengthOneValue_String()
         {
-            ReadOnlySpan<string> span = new ReadOnlySpan<string>(new string[] { "0", "1", "2", "3", "4", "5" });
-            ReadOnlySpan<string> value = new ReadOnlySpan<string>(new string[] { "2" });
-            int index = span.LastIndexOf(value);
-            Assert.Equal(2, index);
+            var source = new string[] { "0", "1", "2", "3", "4", "5" };
+            var value = new string[] { "2" };
+
+            Assert.Equal(2, new ReadOnlySpan<string>(source).LastIndexOf(value));
+            Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(2, new ReadOnlySpan<string>(source).LastIndexOf(value, comparer)));
+            Assert.Equal(-1, new ReadOnlySpan<string>(source).LastIndexOf(value, GetFalseEqualityComparer<string>()));
         }
 
         [Fact]
         public static void LastIndexOfSequenceLengthOneValueAtVeryEnd_String()
         {
-            ReadOnlySpan<string> span = new ReadOnlySpan<string>(new string[] { "0", "1", "2", "3", "4", "5" });
-            ReadOnlySpan<string> value = new ReadOnlySpan<string>(new string[] { "5" });
-            int index = span.LastIndexOf(value);
-            Assert.Equal(5, index);
+            var source = new string[] { "0", "1", "2", "3", "4", "5" };
+            var value = new string[] { "5" };
+
+            Assert.Equal(5, new ReadOnlySpan<string>(source).LastIndexOf(value));
+            Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(5, new ReadOnlySpan<string>(source).LastIndexOf(value, comparer)));
+            Assert.Equal(-1, new ReadOnlySpan<string>(source).LastIndexOf(value, GetFalseEqualityComparer<string>()));
         }
 
         [Fact]
         public static void LastIndexOfSequenceLengthOneValueJustPasttVeryEnd_String()
         {
-            ReadOnlySpan<string> span = new ReadOnlySpan<string>(new string[] { "0", "1", "2", "3", "4", "5" }, 0, 5);
-            ReadOnlySpan<string> value = new ReadOnlySpan<string>(new string[] { "5" });
-            int index = span.LastIndexOf(value);
-            Assert.Equal(-1, index);
+            var source = new string[] { "0", "1", "2", "3", "4", "5" };
+            var value = new string[] { "5" };
+
+            Assert.Equal(-1, new ReadOnlySpan<string>(source, 0, 5).LastIndexOf(value));
+            Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(-1, new ReadOnlySpan<string>(source, 0, 5).LastIndexOf(value, comparer)));
         }
 
         [Theory]
         [MemberData(nameof(TestHelpers.LastIndexOfNullSequenceData), MemberType = typeof(TestHelpers))]
-        public static void LastIndexOfNullSequence_String(string[] spanInput, string[] searchInput, int expected)
+        public static void LastIndexOfNullSequence_String(string[] source, string[] target, int expected)
         {
-            ReadOnlySpan<string> theStrings = spanInput;
-            Assert.Equal(expected, theStrings.LastIndexOf(searchInput));
-            Assert.Equal(expected, theStrings.LastIndexOf((ReadOnlySpan<string>)searchInput));
+            Assert.Equal(expected, new ReadOnlySpan<string>(source).LastIndexOf(target));
+            Assert.All(GetDefaultEqualityComparers<string>(), comparer => Assert.Equal(expected, new ReadOnlySpan<string>(source).LastIndexOf(target, comparer)));
         }
     }
 }
diff --git a/src/libraries/System.Memory/tests/ReadOnlySpan/SequenceCompareTo.T.cs b/src/libraries/System.Memory/tests/ReadOnlySpan/SequenceCompareTo.T.cs
index c6f37293b656dc..ec4a4691aa714b 100644
--- a/src/libraries/System.Memory/tests/ReadOnlySpan/SequenceCompareTo.T.cs
+++ b/src/libraries/System.Memory/tests/ReadOnlySpan/SequenceCompareTo.T.cs
@@ -136,28 +136,26 @@ public static void ZeroLengthSequenceCompareTo_String()
         {
             var a = new string[3];
 
-            var first = new ReadOnlySpan<string>(a, 1, 0);
-            var second = new ReadOnlySpan<string>(a, 2, 0);
-            int result = first.SequenceCompareTo<string>(second);
-            Assert.Equal(0, result);
+            Assert.Equal(0, new ReadOnlySpan<string>(a, 1, 0).SequenceCompareTo<string>(new ReadOnlySpan<string>(a, 2, 0)));
+            Assert.All(GetDefaultComparers<string>(), comparer => Assert.Equal(0, new ReadOnlySpan<string>(a, 1, 0).SequenceCompareTo<string>(new ReadOnlySpan<string>(a, 2, 0), comparer)));
         }
 
         [Fact]
         public static void SameSpanSequenceCompareTo_String()
         {
             string[] a = { "fourth", "fifth", "sixth" };
-            var span = new ReadOnlySpan<string>(a);
-            int result = span.SequenceCompareTo<string>(span);
-            Assert.Equal(0, result);
+
+            Assert.Equal(0, new ReadOnlySpan<string>(a).SequenceCompareTo<string>(a));
+            Assert.All(GetDefaultComparers<string>(), comparer => Assert.Equal(0, new ReadOnlySpan<string>(a).SequenceCompareTo<string>(a, comparer)));
         }
 
         [Fact]
         public static void SequenceCompareToArrayImplicit_String()
         {
             string[] a = { "fourth", "fifth", "sixth" };
-            var first = new ReadOnlySpan<string>(a, 0, 3);
-            int result = first.SequenceCompareTo<string>(a);
-            Assert.Equal(0, result);
+
+            Assert.Equal(0, new ReadOnlySpan<string>(a, 0, 3).SequenceCompareTo<string>(a));
+            Assert.All(GetDefaultComparers<string>(), comparer => Assert.Equal(0, new ReadOnlySpan<string>(a, 0, 3).SequenceCompareTo<string>(a, comparer)));
         }
 
         [Fact]
@@ -167,31 +165,29 @@ public static void SequenceCompareToArraySegmentImplicit_String()
             string[] dst = { "fifth", "first", "second", "third", "tenth" };
             var segment = new ArraySegment<string>(dst, 1, 3);
 
-            var first = new ReadOnlySpan<string>(src, 0, 3);
-            int result = first.SequenceCompareTo<string>(segment);
-            Assert.Equal(0, result);
+            Assert.Equal(0, new ReadOnlySpan<string>(src, 0, 3).SequenceCompareTo<string>(segment));
+            Assert.All(GetDefaultComparers<string>(), comparer => Assert.Equal(0, new ReadOnlySpan<string>(src, 0, 3).SequenceCompareTo<string>(segment, comparer)));
         }
 
         [Fact]
         public static void LengthMismatchSequenceCompareTo_String()
         {
             string[] a = { "fourth", "fifth", "sixth" };
-            var first = new ReadOnlySpan<string>(a, 0, 2);
-            var second = new ReadOnlySpan<string>(a, 0, 3);
-            int result = first.SequenceCompareTo<string>(second);
-            Assert.True(result < 0);
 
-            result = second.SequenceCompareTo<string>(first);
-            Assert.True(result > 0);
+            Assert.True(new ReadOnlySpan<string>(a, 0, 2).SequenceCompareTo<string>(new ReadOnlySpan<string>(a, 0, 3)) < 0);
+            Assert.True(new ReadOnlySpan<string>(a, 0, 3).SequenceCompareTo<string>(new ReadOnlySpan<string>(a, 0, 2)) > 0);
 
-            // one sequence is empty
-            first = new Span<string>(a, 1, 0);
+            Assert.True(new Span<string>(a, 1, 0).SequenceCompareTo<string>(new ReadOnlySpan<string>(a, 0, 3)) < 0);
+            Assert.True(new ReadOnlySpan<string>(a, 0, 3).SequenceCompareTo<string>(new Span<string>(a, 1, 0)) > 0);
 
-            result = first.SequenceCompareTo<string>(second);
-            Assert.True(result < 0);
+            Assert.All(GetDefaultComparers<string>(), comparer =>
+            {
+                Assert.True(new ReadOnlySpan<string>(a, 0, 2).SequenceCompareTo<string>(new ReadOnlySpan<string>(a, 0, 3), comparer) < 0);
+                Assert.True(new ReadOnlySpan<string>(a, 0, 3).SequenceCompareTo<string>(new ReadOnlySpan<string>(a, 0, 2), comparer) > 0);
 
-            result = second.SequenceCompareTo<string>(first);
-            Assert.True(result > 0);
+                Assert.True(new Span<string>(a, 1, 0).SequenceCompareTo<string>(new ReadOnlySpan<string>(a, 0, 3), comparer) < 0);
+                Assert.True(new ReadOnlySpan<string>(a, 0, 3).SequenceCompareTo<string>(new Span<string>(a, 1, 0), comparer) > 0);
+            });
         }
 
         [Fact]
@@ -210,13 +206,14 @@ public static void SequenceCompareToWithSingleMismatch_String()
 
                     second[mismatchIndex] = (string)(second[mismatchIndex] + 1);
 
-                    var firstSpan = new ReadOnlySpan<string>(first);
-                    var secondSpan = new ReadOnlySpan<string>(second);
-                    int result = firstSpan.SequenceCompareTo<string>(secondSpan);
-                    Assert.True(result < 0);
+                    Assert.True(new ReadOnlySpan<string>(first).SequenceCompareTo<string>(second) < 0);
+                    Assert.True(new ReadOnlySpan<string>(second).SequenceCompareTo<string>(first) > 0);
 
-                    result = secondSpan.SequenceCompareTo<string>(firstSpan);
-                    Assert.True(result > 0);
+                    Assert.All(GetDefaultComparers<string>(), comparer =>
+                    {
+                        Assert.True(new ReadOnlySpan<string>(first).SequenceCompareTo<string>(second, comparer) < 0);
+                        Assert.True(new ReadOnlySpan<string>(second).SequenceCompareTo<string>(first, comparer) > 0);
+                    });
                 }
             }
         }
@@ -235,13 +232,14 @@ public static void SequenceCompareToNoMatch_string()
                     second[i] = $"item {int.MaxValue - i}";
                 }
 
-                var firstSpan = new ReadOnlySpan<string>(first);
-                var secondSpan = new ReadOnlySpan<string>(second);
-                int result = firstSpan.SequenceCompareTo<string>(secondSpan);
-                Assert.True(result < 0);
+                Assert.True(new ReadOnlySpan<string>(first).SequenceCompareTo<string>(new ReadOnlySpan<string>(second)) < 0);
+                Assert.True(new ReadOnlySpan<string>(second).SequenceCompareTo<string>(new ReadOnlySpan<string>(first)) > 0);
 
-                result = secondSpan.SequenceCompareTo<string>(firstSpan);
-                Assert.True(result > 0);
+                Assert.All(GetDefaultComparers<string>(), comparer =>
+                {
+                    Assert.True(new ReadOnlySpan<string>(first).SequenceCompareTo<string>(new ReadOnlySpan<string>(second), comparer) < 0);
+                    Assert.True(new ReadOnlySpan<string>(second).SequenceCompareTo<string>(new ReadOnlySpan<string>(first), comparer) > 0);
+                });
             }
         }
 
@@ -262,10 +260,8 @@ public static void MakeSureNoSequenceCompareToChecksGoOutOfRange_string()
                     second[k] = string.Empty;
                 second[length + 1] = "100";
 
-                var span1 = new ReadOnlySpan<string>(first, 1, length);
-                var span2 = new ReadOnlySpan<string>(second, 1, length);
-                int result = span1.SequenceCompareTo<string>(span2);
-                Assert.Equal(0, result);
+                Assert.Equal(0, new ReadOnlySpan<string>(first, 1, length).SequenceCompareTo<string>(new ReadOnlySpan<string>(second, 1, length)));
+                Assert.All(GetDefaultComparers<string>(), comparer => Assert.Equal(0, new ReadOnlySpan<string>(first, 1, length).SequenceCompareTo<string>(new ReadOnlySpan<string>(second, 1, length), comparer)));
             }
         }
     }
diff --git a/src/libraries/System.Memory/tests/ReadOnlySpan/StartsWith.T.cs b/src/libraries/System.Memory/tests/ReadOnlySpan/StartsWith.T.cs
index dea9f22e9c7eb8..de06c16f1ee247 100644
--- a/src/libraries/System.Memory/tests/ReadOnlySpan/StartsWith.T.cs
+++ b/src/libraries/System.Memory/tests/ReadOnlySpan/StartsWith.T.cs
@@ -12,39 +12,37 @@ public static void ZeroLengthStartsWith()
         {
             int[] a = new int[3];
 
-            ReadOnlySpan<int> first = new ReadOnlySpan<int>(a, 1, 0);
-            ReadOnlySpan<int> second = new ReadOnlySpan<int>(a, 2, 0);
-            bool b = first.StartsWith(second);
-            Assert.True(b);
+            Assert.True(new ReadOnlySpan<int>(a, 1, 0).StartsWith(new ReadOnlySpan<int>(a, 2, 0)));
+            Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.True(new ReadOnlySpan<int>(a, 1, 0).StartsWith(new ReadOnlySpan<int>(a, 2, 0), comparer)));
+            Assert.True(new ReadOnlySpan<int>(a, 1, 0).StartsWith(new ReadOnlySpan<int>(a, 2, 0), GetFalseEqualityComparer<int>()));
         }
 
         [Fact]
         public static void SameSpanStartsWith()
         {
             int[] a = { 4, 5, 6 };
-            ReadOnlySpan<int> span = new ReadOnlySpan<int>(a);
-            bool b = span.StartsWith(span);
-            Assert.True(b);
+            Assert.True(new ReadOnlySpan<int>(a).StartsWith(a));
+            Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.True(new ReadOnlySpan<int>(a).StartsWith(a, comparer)));
+            Assert.False(new ReadOnlySpan<int>(a).StartsWith(a, GetFalseEqualityComparer<int>()));
         }
 
         [Fact]
         public static void LengthMismatchStartsWith()
         {
             int[] a = { 4, 5, 6 };
-            ReadOnlySpan<int> first = new ReadOnlySpan<int>(a, 0, 2);
-            ReadOnlySpan<int> second = new ReadOnlySpan<int>(a, 0, 3);
-            bool b = first.StartsWith(second);
-            Assert.False(b);
+
+            Assert.False(new ReadOnlySpan<int>(a, 0, 2).StartsWith(new ReadOnlySpan<int>(a, 0, 3)));
+            Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.False(new ReadOnlySpan<int>(a, 0, 2).StartsWith(new ReadOnlySpan<int>(a, 0, 3), comparer)));
         }
 
         [Fact]
         public static void StartsWithMatch()
         {
             int[] a = { 4, 5, 6 };
-            ReadOnlySpan<int> span = new ReadOnlySpan<int>(a, 0, 3);
-            ReadOnlySpan<int> slice = new ReadOnlySpan<int>(a, 0, 2);
-            bool b = span.StartsWith(slice);
-            Assert.True(b);
+
+            Assert.True(new ReadOnlySpan<int>(a, 0, 3).StartsWith(new ReadOnlySpan<int>(a, 0, 2)));
+            Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.True(new ReadOnlySpan<int>(a, 0, 3).StartsWith(new ReadOnlySpan<int>(a, 0, 2), comparer)));
+            Assert.False(new ReadOnlySpan<int>(a, 0, 3).StartsWith(new ReadOnlySpan<int>(a, 0, 2), GetFalseEqualityComparer<int>()));
         }
 
         [Fact]
@@ -52,10 +50,10 @@ public static void StartsWithMatchDifferentSpans()
         {
             int[] a = { 4, 5, 6 };
             int[] b = { 4, 5, 6 };
-            ReadOnlySpan<int> span = new ReadOnlySpan<int>(a, 0, 3);
-            ReadOnlySpan<int> slice = new ReadOnlySpan<int>(b, 0, 3);
-            bool c = span.StartsWith(slice);
-            Assert.True(c);
+
+            Assert.True(new ReadOnlySpan<int>(a, 0, 3).StartsWith(new ReadOnlySpan<int>(b, 0, 3)));
+            Assert.All(GetDefaultEqualityComparers<int>(), comparer => Assert.True(new ReadOnlySpan<int>(a, 0, 3).StartsWith(new ReadOnlySpan<int>(b, 0, 3), comparer)));
+            Assert.False(new ReadOnlySpan<int>(a, 0, 3).StartsWith(new ReadOnlySpan<int>(b, 0, 3), GetFalseEqualityComparer<int>()));
         }
 
         [Fact]
@@ -144,10 +142,8 @@ public static void MakeSureNoStartsWithChecksGoOutOfRange()
                     first[GuardLength + i] = second[GuardLength + i] = new TInt(10 * (i + 1), checkForOutOfRangeAccess);
                 }
 
-                ReadOnlySpan<TInt> firstSpan = new ReadOnlySpan<TInt>(first, GuardLength, length);
-                ReadOnlySpan<TInt> secondSpan = new ReadOnlySpan<TInt>(second, GuardLength, length);
-                bool b = firstSpan.StartsWith(secondSpan);
-                Assert.True(b);
+                Assert.True(new ReadOnlySpan<TInt>(first, GuardLength, length).StartsWith(new ReadOnlySpan<TInt>(second, GuardLength, length)));
+                Assert.All(GetDefaultEqualityComparers<TInt>(), comparer => Assert.True(new ReadOnlySpan<TInt>(first, GuardLength, length).StartsWith(new ReadOnlySpan<TInt>(second, GuardLength, length), comparer)));
             }
         }
     }
diff --git a/src/libraries/System.Memory/tests/System.Memory.Tests.csproj b/src/libraries/System.Memory/tests/System.Memory.Tests.csproj
index 38b40b284d1b25..63c2d9088f7153 100644
--- a/src/libraries/System.Memory/tests/System.Memory.Tests.csproj
+++ b/src/libraries/System.Memory/tests/System.Memory.Tests.csproj
@@ -27,6 +27,7 @@
     <Compile Include="ParsersAndFormatters\Formatter\RealFormatterTests.cs" />
     <Compile Include="$(CommonPath)..\tests\System\RealParserTestsBase.cs" Link="ParsersAndFormatters\Parser\RealParserTestsBase.cs" />
     <Compile Include="ParsersAndFormatters\Parser\RealParserTests.cs" />
+    <Compile Include="ReadOnlySpan\Comparers.cs" />
     <Compile Include="ReadOnlySpan\Contains.byte.cs" />
     <Compile Include="ReadOnlySpan\Contains.T.cs" />
     <Compile Include="ReadOnlySpan\CastUp.cs" />
diff --git a/src/libraries/System.Private.CoreLib/src/System/MemoryExtensions.cs b/src/libraries/System.Private.CoreLib/src/System/MemoryExtensions.cs
index 174fac083981be..86b27c206f8584 100644
--- a/src/libraries/System.Private.CoreLib/src/System/MemoryExtensions.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/MemoryExtensions.cs
@@ -361,6 +361,17 @@ ref Unsafe.As<T, long>(ref MemoryMarshal.GetReference(span)),
             return SpanHelpers.Contains(ref MemoryMarshal.GetReference(span), value, span.Length);
         }
 
+        /// <summary>
+        /// Searches for the specified value and returns true if found. If not found, returns false.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="span">The span to search.</param>
+        /// <param name="value">The value to search for.</param>
+        /// <param name="comparer">The <see cref="IEqualityComparer{T}"/> implementation to use when comparing elements, or <see langword="null"/> to use the default <see cref="IEqualityComparer{T}"/> for the type of an element.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool Contains<T>(this ReadOnlySpan<T> span, T value, IEqualityComparer<T>? comparer = null) =>
+            IndexOf(span, value, comparer) >= 0;
+
         /// <inheritdoc cref="ContainsAny{T}(ReadOnlySpan{T}, T, T)"/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [OverloadResolutionPriority(-1)]
@@ -443,6 +454,17 @@ public static bool ContainsAnyExceptInRange<T>(this Span<T> span, T lowInclusive
         public static bool ContainsAny<T>(this ReadOnlySpan<T> span, T value0, T value1) where T : IEquatable<T>? =>
             IndexOfAny(span, value0, value1) >= 0;
 
+        /// <summary>
+        /// Searches for any occurrence of the specified <paramref name="value0"/> or <paramref name="value1"/>, and returns true if found. If not found, returns false.
+        /// </summary>
+        /// <param name="span">The span to search.</param>
+        /// <param name="value0">One of the values to search for.</param>
+        /// <param name="value1">One of the values to search for.</param>
+        /// <param name="comparer">The <see cref="IEqualityComparer{T}"/> implementation to use when comparing elements, or <see langword="null"/> to use the default <see cref="IEqualityComparer{T}"/> for the type of an element.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool ContainsAny<T>(this ReadOnlySpan<T> span, T value0, T value1, IEqualityComparer<T>? comparer = null) =>
+            IndexOfAny(span, value0, value1, comparer) >= 0;
+
         /// <summary>
         /// Searches for any occurrence of the specified <paramref name="value0"/>, <paramref name="value1"/>, or <paramref name="value2"/>, and returns true if found. If not found, returns false.
         /// </summary>
@@ -454,6 +476,18 @@ public static bool ContainsAny<T>(this ReadOnlySpan<T> span, T value0, T value1)
         public static bool ContainsAny<T>(this ReadOnlySpan<T> span, T value0, T value1, T value2) where T : IEquatable<T>? =>
             IndexOfAny(span, value0, value1, value2) >= 0;
 
+        /// <summary>
+        /// Searches for any occurrence of the specified <paramref name="value0"/>, <paramref name="value1"/>, or <paramref name="value2"/>, and returns true if found. If not found, returns false.
+        /// </summary>
+        /// <param name="span">The span to search.</param>
+        /// <param name="value0">One of the values to search for.</param>
+        /// <param name="value1">One of the values to search for.</param>
+        /// <param name="value2">One of the values to search for.</param>
+        /// <param name="comparer">The <see cref="IEqualityComparer{T}"/> implementation to use when comparing elements, or <see langword="null"/> to use the default <see cref="IEqualityComparer{T}"/> for the type of an element.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool ContainsAny<T>(this ReadOnlySpan<T> span, T value0, T value1, T value2, IEqualityComparer<T>? comparer = null) =>
+            IndexOfAny(span, value0, value1, value2, comparer) >= 0;
+
         /// <summary>
         /// Searches for any occurrence of any of the specified <paramref name="values"/> and returns true if found. If not found, returns false.
         /// </summary>
@@ -463,6 +497,16 @@ public static bool ContainsAny<T>(this ReadOnlySpan<T> span, T value0, T value1,
         public static bool ContainsAny<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> values) where T : IEquatable<T>? =>
             IndexOfAny(span, values) >= 0;
 
+        /// <summary>
+        /// Searches for any occurrence of any of the specified <paramref name="values"/> and returns true if found. If not found, returns false.
+        /// </summary>
+        /// <param name="span">The span to search.</param>
+        /// <param name="values">The set of values to search for.</param>
+        /// <param name="comparer">The comparer to use. If <see langword="null"/>, <see cref="EqualityComparer{T}.Default"/> is used.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool ContainsAny<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> values, IEqualityComparer<T>? comparer = null) =>
+            IndexOfAny(span, values, comparer) >= 0;
+
         /// <summary>
         /// Searches for any occurrence of any of the specified <paramref name="values"/> and returns true if found. If not found, returns false.
         /// </summary>
@@ -501,6 +545,20 @@ public static bool ContainsAny(this ReadOnlySpan<char> span, SearchValues<string
         public static bool ContainsAnyExcept<T>(this ReadOnlySpan<T> span, T value) where T : IEquatable<T>? =>
             IndexOfAnyExcept(span, value) >= 0;
 
+        /// <summary>
+        /// Searches for any value other than the specified <paramref name="value"/>.
+        /// </summary>
+        /// <param name="span">The span to search.</param>
+        /// <param name="value">A value to avoid.</param>
+        /// <param name="comparer">The <see cref="IEqualityComparer{T}"/> implementation to use when comparing elements, or <see langword="null"/> to use the default <see cref="IEqualityComparer{T}"/> for the type of an element.</param>
+        /// <returns>
+        /// True if any value other than <paramref name="value"/> is present in the span.
+        /// If all of the values are <paramref name="value"/>, returns false.
+        /// </returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool ContainsAnyExcept<T>(this ReadOnlySpan<T> span, T value, IEqualityComparer<T>? comparer = null) =>
+            IndexOfAnyExcept(span, value, comparer) >= 0;
+
         /// <summary>
         /// Searches for any value other than the specified <paramref name="value0"/> or <paramref name="value1"/>.
         /// </summary>
@@ -515,6 +573,21 @@ public static bool ContainsAnyExcept<T>(this ReadOnlySpan<T> span, T value) wher
         public static bool ContainsAnyExcept<T>(this ReadOnlySpan<T> span, T value0, T value1) where T : IEquatable<T>? =>
             IndexOfAnyExcept(span, value0, value1) >= 0;
 
+        /// <summary>
+        /// Searches for any value other than the specified <paramref name="value0"/> or <paramref name="value1"/>.
+        /// </summary>
+        /// <param name="span">The span to search.</param>
+        /// <param name="value0">A value to avoid.</param>
+        /// <param name="value1">A value to avoid.</param>
+        /// <param name="comparer">The <see cref="IEqualityComparer{T}"/> implementation to use when comparing elements, or <see langword="null"/> to use the default <see cref="IEqualityComparer{T}"/> for the type of an element.</param>
+        /// <returns>
+        /// True if any value other than <paramref name="value0"/> and <paramref name="value1"/> is present in the span.
+        /// If all of the values are <paramref name="value0"/> or <paramref name="value1"/>, returns false.
+        /// </returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool ContainsAnyExcept<T>(this ReadOnlySpan<T> span, T value0, T value1, IEqualityComparer<T>? comparer = null) =>
+            IndexOfAnyExcept(span, value0, value1, comparer) >= 0;
+
         /// <summary>
         /// Searches for any value other than the specified <paramref name="value0"/>, <paramref name="value1"/>, or <paramref name="value2"/>.
         /// </summary>
@@ -530,6 +603,22 @@ public static bool ContainsAnyExcept<T>(this ReadOnlySpan<T> span, T value0, T v
         public static bool ContainsAnyExcept<T>(this ReadOnlySpan<T> span, T value0, T value1, T value2) where T : IEquatable<T>? =>
             IndexOfAnyExcept(span, value0, value1, value2) >= 0;
 
+        /// <summary>
+        /// Searches for any value other than the specified <paramref name="value0"/>, <paramref name="value1"/>, or <paramref name="value2"/>.
+        /// </summary>
+        /// <param name="span">The span to search.</param>
+        /// <param name="value0">A value to avoid.</param>
+        /// <param name="value1">A value to avoid.</param>
+        /// <param name="value2">A value to avoid.</param>
+        /// <param name="comparer">The <see cref="IEqualityComparer{T}"/> implementation to use when comparing elements, or <see langword="null"/> to use the default <see cref="IEqualityComparer{T}"/> for the type of an element.</param>
+        /// <returns>
+        /// True if any value other than <paramref name="value0"/>, <paramref name="value1"/>, and <paramref name="value2"/> is present in the span.
+        /// If all of the values are <paramref name="value0"/>, <paramref name="value1"/>, or <paramref name="value2"/>, returns false.
+        /// </returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool ContainsAnyExcept<T>(this ReadOnlySpan<T> span, T value0, T value1, T value2, IEqualityComparer<T>? comparer = null) =>
+            IndexOfAnyExcept(span, value0, value1, value2, comparer) >= 0;
+
         /// <summary>
         /// Searches for any value other than the specified <paramref name="values"/>.
         /// </summary>
@@ -543,6 +632,20 @@ public static bool ContainsAnyExcept<T>(this ReadOnlySpan<T> span, T value0, T v
         public static bool ContainsAnyExcept<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> values) where T : IEquatable<T>? =>
             IndexOfAnyExcept(span, values) >= 0;
 
+        /// <summary>
+        /// Searches for any value other than the specified <paramref name="values"/>.
+        /// </summary>
+        /// <param name="span">The span to search.</param>
+        /// <param name="values">The values to avoid.</param>
+        /// <param name="comparer">The <see cref="IEqualityComparer{T}"/> implementation to use when comparing elements, or <see langword="null"/> to use the default <see cref="IEqualityComparer{T}"/> for the type of an element.</param>
+        /// <returns>
+        /// True if any value other than those in <paramref name="values"/> is present in the span.
+        /// If all of the values are in <paramref name="values"/>, returns false.
+        /// </returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool ContainsAnyExcept<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> values, IEqualityComparer<T>? comparer = null) =>
+            IndexOfAnyExcept(span, values, comparer) >= 0;
+
         /// <summary>
         /// Searches for any value other than the specified <paramref name="values"/>.
         /// </summary>
@@ -737,6 +840,86 @@ ref Unsafe.As<T, long>(ref MemoryMarshal.GetReference(span)),
             return SpanHelpers.IndexOfAnyExcept(ref MemoryMarshal.GetReference(span), value, span.Length);
         }
 
+        /// <summary>Searches for the first index of any value other than the specified <paramref name="value"/>.</summary>
+        /// <typeparam name="T">The type of the span and values.</typeparam>
+        /// <param name="span">The span to search.</param>
+        /// <param name="value">A value to avoid.</param>
+        /// <param name="comparer">The <see cref="IEqualityComparer{T}"/> implementation to use when comparing elements, or <see langword="null"/> to use the default <see cref="IEqualityComparer{T}"/> for the type of an element.</param>
+        /// <returns>
+        /// The index in the span of the first occurrence of any value other than <paramref name="value"/>.
+        /// If all of the values are <paramref name="value"/>, returns -1.
+        /// </returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe int IndexOfAnyExcept<T>(this ReadOnlySpan<T> span, T value, IEqualityComparer<T>? comparer = null)
+        {
+            if (typeof(T).IsValueType && (comparer is null || comparer == EqualityComparer<T>.Default))
+            {
+                if (RuntimeHelpers.IsBitwiseEquatable<T>())
+                {
+                    if (sizeof(T) == sizeof(byte))
+                    {
+                        return SpanHelpers.IndexOfAnyExceptValueType(
+                            ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
+                            Unsafe.BitCast<T, byte>(value),
+                            span.Length);
+                    }
+                    else if (sizeof(T) == sizeof(short))
+                    {
+                        return SpanHelpers.IndexOfAnyExceptValueType(
+                            ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span)),
+                            Unsafe.BitCast<T, short>(value),
+                            span.Length);
+                    }
+                    else if (sizeof(T) == sizeof(int))
+                    {
+                        return SpanHelpers.IndexOfAnyExceptValueType(
+                            ref Unsafe.As<T, int>(ref MemoryMarshal.GetReference(span)),
+                            Unsafe.BitCast<T, int>(value),
+                            span.Length);
+                    }
+                    else if (sizeof(T) == sizeof(long))
+                    {
+                        return SpanHelpers.IndexOfAnyExceptValueType(
+                            ref Unsafe.As<T, long>(ref MemoryMarshal.GetReference(span)),
+                            Unsafe.BitCast<T, long>(value),
+                            span.Length);
+                    }
+                }
+
+                return IndexOfAnyExceptDefaultComparer(span, value);
+                static int IndexOfAnyExceptDefaultComparer(ReadOnlySpan<T> span, T value)
+                {
+                    for (int i = 0; i < span.Length; i++)
+                    {
+                        if (!EqualityComparer<T>.Default.Equals(span[i], value))
+                        {
+                            return i;
+                        }
+                    }
+
+                    return -1;
+                }
+            }
+            else
+            {
+                return IndexOfAnyExceptComparer(span, value, comparer);
+                static int IndexOfAnyExceptComparer(ReadOnlySpan<T> span, T value, IEqualityComparer<T>? comparer)
+                {
+                    comparer ??= EqualityComparer<T>.Default;
+
+                    for (int i = 0; i < span.Length; i++)
+                    {
+                        if (!comparer.Equals(span[i], value))
+                        {
+                            return i;
+                        }
+                    }
+
+                    return -1;
+                }
+            }
+        }
+
         /// <summary>Searches for the first index of any value other than the specified <paramref name="value0"/> or <paramref name="value1"/>.</summary>
         /// <typeparam name="T">The type of the span and values.</typeparam>
         /// <param name="span">The span to search.</param>
@@ -772,6 +955,77 @@ ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span)),
             return SpanHelpers.IndexOfAnyExcept(ref MemoryMarshal.GetReference(span), value0, value1, span.Length);
         }
 
+        /// <summary>Searches for the first index of any value other than the specified <paramref name="value0"/> or <paramref name="value1"/>.</summary>
+        /// <typeparam name="T">The type of the span and values.</typeparam>
+        /// <param name="span">The span to search.</param>
+        /// <param name="value0">A value to avoid.</param>
+        /// <param name="value1">A value to avoid</param>
+        /// <param name="comparer">The <see cref="IEqualityComparer{T}"/> implementation to use when comparing elements, or <see langword="null"/> to use the default <see cref="IEqualityComparer{T}"/> for the type of an element.</param>
+        /// <returns>
+        /// The index in the span of the first occurrence of any value other than <paramref name="value0"/> and <paramref name="value1"/>.
+        /// If all of the values are <paramref name="value0"/> or <paramref name="value1"/>, returns -1.
+        /// </returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe int IndexOfAnyExcept<T>(this ReadOnlySpan<T> span, T value0, T value1, IEqualityComparer<T>? comparer = null)
+        {
+            if (typeof(T).IsValueType && (comparer is null || comparer == EqualityComparer<T>.Default))
+            {
+                if (RuntimeHelpers.IsBitwiseEquatable<T>())
+                {
+                    if (sizeof(T) == sizeof(byte))
+                    {
+                        return SpanHelpers.IndexOfAnyExceptValueType(
+                            ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
+                            Unsafe.BitCast<T, byte>(value0),
+                            Unsafe.BitCast<T, byte>(value1),
+                            span.Length);
+                    }
+                    else if (sizeof(T) == sizeof(short))
+                    {
+                        return SpanHelpers.IndexOfAnyExceptValueType(
+                            ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span)),
+                            Unsafe.BitCast<T, short>(value0),
+                            Unsafe.BitCast<T, short>(value1),
+                            span.Length);
+                    }
+                }
+
+                return IndexOfAnyExceptDefaultComparer(span, value0, value1);
+                static int IndexOfAnyExceptDefaultComparer(ReadOnlySpan<T> span, T value0, T value1)
+                {
+                    for (int i = 0; i < span.Length; i++)
+                    {
+                        if (!EqualityComparer<T>.Default.Equals(span[i], value0) &&
+                            !EqualityComparer<T>.Default.Equals(span[i], value1))
+                        {
+                            return i;
+                        }
+                    }
+
+                    return -1;
+                }
+            }
+            else
+            {
+                return IndexOfAnyExceptComparer(span, value0, value1, comparer);
+                static int IndexOfAnyExceptComparer(ReadOnlySpan<T> span, T value0, T value1, IEqualityComparer<T>? comparer)
+                {
+                    comparer ??= EqualityComparer<T>.Default;
+
+                    for (int i = 0; i < span.Length; i++)
+                    {
+                        if (!comparer.Equals(span[i], value0) &&
+                            !comparer.Equals(span[i], value1))
+                        {
+                            return i;
+                        }
+                    }
+
+                    return -1;
+                }
+            }
+        }
+
         /// <summary>Searches for the first index of any value other than the specified <paramref name="value0"/>, <paramref name="value1"/>, or <paramref name="value2"/>.</summary>
         /// <typeparam name="T">The type of the span and values.</typeparam>
         /// <param name="span">The span to search.</param>
@@ -810,6 +1064,81 @@ ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span)),
             return SpanHelpers.IndexOfAnyExcept(ref MemoryMarshal.GetReference(span), value0, value1, value2, span.Length);
         }
 
+        /// <summary>Searches for the first index of any value other than the specified <paramref name="value0"/>, <paramref name="value1"/>, or <paramref name="value2"/>.</summary>
+        /// <typeparam name="T">The type of the span and values.</typeparam>
+        /// <param name="span">The span to search.</param>
+        /// <param name="value0">A value to avoid.</param>
+        /// <param name="value1">A value to avoid</param>
+        /// <param name="value2">A value to avoid</param>
+        /// <param name="comparer">The <see cref="IEqualityComparer{T}"/> implementation to use when comparing elements, or <see langword="null"/> to use the default <see cref="IEqualityComparer{T}"/> for the type of an element.</param>
+        /// <returns>
+        /// The index in the span of the first occurrence of any value other than <paramref name="value0"/>, <paramref name="value1"/>, and <paramref name="value2"/>.
+        /// If all of the values are <paramref name="value0"/>, <paramref name="value1"/>, and <paramref name="value2"/>, returns -1.
+        /// </returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe int IndexOfAnyExcept<T>(this ReadOnlySpan<T> span, T value0, T value1, T value2, IEqualityComparer<T>? comparer = null)
+        {
+            if (typeof(T).IsValueType && (comparer is null || comparer == EqualityComparer<T>.Default))
+            {
+                if (RuntimeHelpers.IsBitwiseEquatable<T>())
+                {
+                    if (sizeof(T) == sizeof(byte))
+                    {
+                        return SpanHelpers.IndexOfAnyExceptValueType(
+                            ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
+                            Unsafe.BitCast<T, byte>(value0),
+                            Unsafe.BitCast<T, byte>(value1),
+                            Unsafe.BitCast<T, byte>(value2),
+                            span.Length);
+                    }
+                    else if (sizeof(T) == sizeof(short))
+                    {
+                        return SpanHelpers.IndexOfAnyExceptValueType(
+                            ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span)),
+                            Unsafe.BitCast<T, short>(value0),
+                            Unsafe.BitCast<T, short>(value1),
+                            Unsafe.BitCast<T, short>(value2),
+                            span.Length);
+                    }
+                }
+
+                return IndexOfAnyExceptDefaultComparer(span, value0, value1, value2);
+                static int IndexOfAnyExceptDefaultComparer(ReadOnlySpan<T> span, T value0, T value1, T value2)
+                {
+                    for (int i = 0; i < span.Length; i++)
+                    {
+                        if (!EqualityComparer<T>.Default.Equals(span[i], value0) &&
+                            !EqualityComparer<T>.Default.Equals(span[i], value1) &&
+                            !EqualityComparer<T>.Default.Equals(span[i], value2))
+                        {
+                            return i;
+                        }
+                    }
+
+                    return -1;
+                }
+            }
+            else
+            {
+                return IndexOfAnyExceptComparer(span, value0, value1, value2, comparer);
+                static int IndexOfAnyExceptComparer(ReadOnlySpan<T> span, T value0, T value1, T value2, IEqualityComparer<T>? comparer)
+                {
+                    comparer ??= EqualityComparer<T>.Default;
+                    for (int i = 0; i < span.Length; i++)
+                    {
+                        if (!comparer.Equals(span[i], value0) &&
+                            !comparer.Equals(span[i], value1) &&
+                            !comparer.Equals(span[i], value2))
+                        {
+                            return i;
+                        }
+                    }
+
+                    return -1;
+                }
+            }
+        }
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private static unsafe int IndexOfAnyExcept<T>(this ReadOnlySpan<T> span, T value0, T value1, T value2, T value3) where T : IEquatable<T>?
         {
@@ -926,28 +1255,66 @@ ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(values)),
         /// <typeparam name="T">The type of the span and values.</typeparam>
         /// <param name="span">The span to search.</param>
         /// <param name="values">The values to avoid.</param>
+        /// <param name="comparer">The <see cref="IEqualityComparer{T}"/> implementation to use when comparing elements, or <see langword="null"/> to use the default <see cref="IEqualityComparer{T}"/> for the type of an element.</param>
         /// <returns>
         /// The index in the span of the first occurrence of any value other than those in <paramref name="values"/>.
         /// If all of the values are in <paramref name="values"/>, returns -1.
         /// </returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int IndexOfAnyExcept<T>(this ReadOnlySpan<T> span, SearchValues<T> values) where T : IEquatable<T>?
+        public static unsafe int IndexOfAnyExcept<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> values, IEqualityComparer<T>? comparer = null)
         {
-            if (values is null)
+            switch (values.Length)
             {
-                ThrowHelper.ThrowArgumentNullException(ExceptionArgument.values);
-            }
+                case 0:
+                    return span.IsEmpty ? -1 : 0;
 
-            return values.IndexOfAnyExcept(span);
+                case 1:
+                    return IndexOfAnyExcept(span, values[0], comparer);
+
+                case 2:
+                    return IndexOfAnyExcept(span, values[0], values[1], comparer);
+
+                case 3:
+                    return IndexOfAnyExcept(span, values[0], values[1], values[2], comparer);
+
+                default:
+                    for (int i = 0; i < span.Length; i++)
+                    {
+                        if (!values.Contains(span[i], comparer))
+                        {
+                            return i;
+                        }
+                    }
+
+                    return -1;
+            }
         }
 
-        /// <summary>Searches for the last index of any value other than the specified <paramref name="value"/>.</summary>
+        /// <summary>Searches for the first index of any value other than the specified <paramref name="values"/>.</summary>
         /// <typeparam name="T">The type of the span and values.</typeparam>
         /// <param name="span">The span to search.</param>
-        /// <param name="value">A value to avoid.</param>
+        /// <param name="values">The values to avoid.</param>
         /// <returns>
-        /// The index in the span of the last occurrence of any value other than <paramref name="value"/>.
-        /// If all of the values are <paramref name="value"/>, returns -1.
+        /// The index in the span of the first occurrence of any value other than those in <paramref name="values"/>.
+        /// If all of the values are in <paramref name="values"/>, returns -1.
+        /// </returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static int IndexOfAnyExcept<T>(this ReadOnlySpan<T> span, SearchValues<T> values) where T : IEquatable<T>?
+        {
+            if (values is null)
+            {
+                ThrowHelper.ThrowArgumentNullException(ExceptionArgument.values);
+            }
+
+            return values.IndexOfAnyExcept(span);
+        }
+
+        /// <summary>Searches for the last index of any value other than the specified <paramref name="value"/>.</summary>
+        /// <typeparam name="T">The type of the span and values.</typeparam>
+        /// <param name="span">The span to search.</param>
+        /// <param name="value">A value to avoid.</param>
+        /// <returns>
+        /// The index in the span of the last occurrence of any value other than <paramref name="value"/>.
+        /// If all of the values are <paramref name="value"/>, returns -1.
         /// </returns>
         [OverloadResolutionPriority(-1)]
         public static int LastIndexOfAnyExcept<T>(this Span<T> span, T value) where T : IEquatable<T>? =>
@@ -1051,6 +1418,86 @@ ref Unsafe.As<T, long>(ref MemoryMarshal.GetReference(span)),
             return SpanHelpers.LastIndexOfAnyExcept(ref MemoryMarshal.GetReference(span), value, span.Length);
         }
 
+        /// <summary>Searches for the last index of any value other than the specified <paramref name="value"/>.</summary>
+        /// <typeparam name="T">The type of the span and values.</typeparam>
+        /// <param name="span">The span to search.</param>
+        /// <param name="value">A value to avoid.</param>
+        /// <param name="comparer">The <see cref="IEqualityComparer{T}"/> implementation to use when comparing elements, or <see langword="null"/> to use the default <see cref="IEqualityComparer{T}"/> for the type of an element.</param>
+        /// <returns>
+        /// The index in the span of the last occurrence of any value other than <paramref name="value"/>.
+        /// If all of the values are <paramref name="value"/>, returns -1.
+        /// </returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe int LastIndexOfAnyExcept<T>(this ReadOnlySpan<T> span, T value, IEqualityComparer<T>? comparer = null)
+        {
+            if (typeof(T).IsValueType && (comparer is null || comparer == EqualityComparer<T>.Default))
+            {
+                if (RuntimeHelpers.IsBitwiseEquatable<T>())
+                {
+                    if (sizeof(T) == sizeof(byte))
+                    {
+                        return SpanHelpers.LastIndexOfAnyExceptValueType(
+                            ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
+                            Unsafe.BitCast<T, byte>(value),
+                            span.Length);
+                    }
+                    else if (sizeof(T) == sizeof(short))
+                    {
+                        return SpanHelpers.LastIndexOfAnyExceptValueType(
+                            ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span)),
+                            Unsafe.BitCast<T, short>(value),
+                            span.Length);
+                    }
+                    else if (sizeof(T) == sizeof(int))
+                    {
+                        return SpanHelpers.LastIndexOfAnyExceptValueType(
+                            ref Unsafe.As<T, int>(ref MemoryMarshal.GetReference(span)),
+                            Unsafe.BitCast<T, int>(value),
+                            span.Length);
+                    }
+                    else if (sizeof(T) == sizeof(long))
+                    {
+                        return SpanHelpers.LastIndexOfAnyExceptValueType(
+                            ref Unsafe.As<T, long>(ref MemoryMarshal.GetReference(span)),
+                            Unsafe.BitCast<T, long>(value),
+                            span.Length);
+                    }
+                }
+
+                return LastIndexOfAnyExceptDefaultComparer(span, value);
+                static int LastIndexOfAnyExceptDefaultComparer(ReadOnlySpan<T> span, T value)
+                {
+                    for (int i = span.Length - 1; i >= 0; i--)
+                    {
+                        if (!EqualityComparer<T>.Default.Equals(span[i], value))
+                        {
+                            return i;
+                        }
+                    }
+
+                    return -1;
+                }
+            }
+            else
+            {
+                return LastIndexOfAnyExceptComparer(span, value, comparer);
+                static int LastIndexOfAnyExceptComparer(ReadOnlySpan<T> span, T value, IEqualityComparer<T>? comparer)
+                {
+                    comparer ??= EqualityComparer<T>.Default;
+
+                    for (int i = span.Length - 1; i >= 0; i--)
+                    {
+                        if (!comparer.Equals(span[i], value))
+                        {
+                            return i;
+                        }
+                    }
+
+                    return -1;
+                }
+            }
+        }
+
         /// <summary>Searches for the last index of any value other than the specified <paramref name="value0"/> or <paramref name="value1"/>.</summary>
         /// <typeparam name="T">The type of the span and values.</typeparam>
         /// <param name="span">The span to search.</param>
@@ -1086,6 +1533,77 @@ ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span)),
             return SpanHelpers.LastIndexOfAnyExcept(ref MemoryMarshal.GetReference(span), value0, value1, span.Length);
         }
 
+        /// <summary>Searches for the last index of any value other than the specified <paramref name="value0"/> or <paramref name="value1"/>.</summary>
+        /// <typeparam name="T">The type of the span and values.</typeparam>
+        /// <param name="span">The span to search.</param>
+        /// <param name="value0">A value to avoid.</param>
+        /// <param name="value1">A value to avoid</param>
+        /// <param name="comparer">The <see cref="IEqualityComparer{T}"/> implementation to use when comparing elements, or <see langword="null"/> to use the default <see cref="IEqualityComparer{T}"/> for the type of an element.</param>
+        /// <returns>
+        /// The index in the span of the last occurrence of any value other than <paramref name="value0"/> and <paramref name="value1"/>.
+        /// If all of the values are <paramref name="value0"/> or <paramref name="value1"/>, returns -1.
+        /// </returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe int LastIndexOfAnyExcept<T>(this ReadOnlySpan<T> span, T value0, T value1, IEqualityComparer<T>? comparer = null)
+        {
+            if (typeof(T).IsValueType && (comparer is null || comparer == EqualityComparer<T>.Default))
+            {
+                if (RuntimeHelpers.IsBitwiseEquatable<T>())
+                {
+                    if (sizeof(T) == sizeof(byte))
+                    {
+                        return SpanHelpers.LastIndexOfAnyExceptValueType(
+                            ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
+                            Unsafe.BitCast<T, byte>(value0),
+                            Unsafe.BitCast<T, byte>(value1),
+                            span.Length);
+                    }
+                    else if (sizeof(T) == sizeof(short))
+                    {
+                        return SpanHelpers.LastIndexOfAnyExceptValueType(
+                            ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span)),
+                            Unsafe.BitCast<T, short>(value0),
+                            Unsafe.BitCast<T, short>(value1),
+                            span.Length);
+                    }
+                }
+
+                return LastIndexOfAnyExceptDefaultComparer(span, value0, value1);
+                static int LastIndexOfAnyExceptDefaultComparer(ReadOnlySpan<T> span, T value0, T value1)
+                {
+                    for (int i = span.Length - 1; i >= 0; i--)
+                    {
+                        if (!EqualityComparer<T>.Default.Equals(span[i], value0) &&
+                            !EqualityComparer<T>.Default.Equals(span[i], value1))
+                        {
+                            return i;
+                        }
+                    }
+
+                    return -1;
+                }
+            }
+            else
+            {
+                return LastIndexOfAnyExceptComparer(span, value0, value1, comparer);
+                static int LastIndexOfAnyExceptComparer(ReadOnlySpan<T> span, T value0, T value1, IEqualityComparer<T>? comparer)
+                {
+                    comparer ??= EqualityComparer<T>.Default;
+
+                    for (int i = span.Length - 1; i >= 0; i--)
+                    {
+                        if (!comparer.Equals(span[i], value0) &&
+                            !comparer.Equals(span[i], value1))
+                        {
+                            return i;
+                        }
+                    }
+
+                    return -1;
+                }
+            }
+        }
+
         /// <summary>Searches for the last index of any value other than the specified <paramref name="value0"/>, <paramref name="value1"/>, or <paramref name="value2"/>.</summary>
         /// <typeparam name="T">The type of the span and values.</typeparam>
         /// <param name="span">The span to search.</param>
@@ -1124,6 +1642,82 @@ ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span)),
             return SpanHelpers.LastIndexOfAnyExcept(ref MemoryMarshal.GetReference(span), value0, value1, value2, span.Length);
         }
 
+        /// <summary>Searches for the last index of any value other than the specified <paramref name="value0"/>, <paramref name="value1"/>, or <paramref name="value2"/>.</summary>
+        /// <typeparam name="T">The type of the span and values.</typeparam>
+        /// <param name="span">The span to search.</param>
+        /// <param name="value0">A value to avoid.</param>
+        /// <param name="value1">A value to avoid</param>
+        /// <param name="value2">A value to avoid</param>
+        /// <param name="comparer">The <see cref="IEqualityComparer{T}"/> implementation to use when comparing elements, or <see langword="null"/> to use the default <see cref="IEqualityComparer{T}"/> for the type of an element.</param>
+        /// <returns>
+        /// The index in the span of the last occurrence of any value other than <paramref name="value0"/>, <paramref name="value1"/>, and <paramref name="value2"/>.
+        /// If all of the values are <paramref name="value0"/>, <paramref name="value1"/>, and <paramref name="value2"/>, returns -1.
+        /// </returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe int LastIndexOfAnyExcept<T>(this ReadOnlySpan<T> span, T value0, T value1, T value2, IEqualityComparer<T>? comparer = null)
+        {
+            if (typeof(T).IsValueType && (comparer is null || comparer == EqualityComparer<T>.Default))
+            {
+                if (RuntimeHelpers.IsBitwiseEquatable<T>())
+                {
+                    if (sizeof(T) == sizeof(byte))
+                    {
+                        return SpanHelpers.LastIndexOfAnyExceptValueType(
+                            ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
+                            Unsafe.BitCast<T, byte>(value0),
+                            Unsafe.BitCast<T, byte>(value1),
+                            Unsafe.BitCast<T, byte>(value2),
+                            span.Length);
+                    }
+                    else if (sizeof(T) == sizeof(short))
+                    {
+                        return SpanHelpers.LastIndexOfAnyExceptValueType(
+                            ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span)),
+                            Unsafe.BitCast<T, short>(value0),
+                            Unsafe.BitCast<T, short>(value1),
+                            Unsafe.BitCast<T, short>(value2),
+                            span.Length);
+                    }
+                }
+
+                return LastIndexOfAnyExceptDefaultComparer(span, value0, value1, value2);
+                static int LastIndexOfAnyExceptDefaultComparer(ReadOnlySpan<T> span, T value0, T value1, T value2)
+                {
+                    for (int i = span.Length - 1; i >= 0; i--)
+                    {
+                        if (!EqualityComparer<T>.Default.Equals(span[i], value0) &&
+                            !EqualityComparer<T>.Default.Equals(span[i], value1) &&
+                            !EqualityComparer<T>.Default.Equals(span[i], value2))
+                        {
+                            return i;
+                        }
+                    }
+
+                    return -1;
+                }
+            }
+            else
+            {
+                return LastIndexOfAnyExceptComparer(span, value0, value1, value2, comparer);
+                static int LastIndexOfAnyExceptComparer(ReadOnlySpan<T> span, T value0, T value1, T value2, IEqualityComparer<T>? comparer)
+                {
+                    comparer ??= EqualityComparer<T>.Default;
+
+                    for (int i = span.Length - 1; i >= 0; i--)
+                    {
+                        if (!comparer.Equals(span[i], value0) &&
+                            !comparer.Equals(span[i], value1) &&
+                            !comparer.Equals(span[i], value2))
+                        {
+                            return i;
+                        }
+                    }
+
+                    return -1;
+                }
+            }
+        }
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private static unsafe int LastIndexOfAnyExcept<T>(this ReadOnlySpan<T> span, T value0, T value1, T value2, T value3) where T : IEquatable<T>?
         {
@@ -1237,6 +1831,44 @@ ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(values)),
             }
         }
 
+        /// <summary>Searches for the last index of any value other than the specified <paramref name="values"/>.</summary>
+        /// <typeparam name="T">The type of the span and values.</typeparam>
+        /// <param name="span">The span to search.</param>
+        /// <param name="values">The values to avoid.</param>
+        /// <param name="comparer">The <see cref="IEqualityComparer{T}"/> implementation to use when comparing elements, or <see langword="null"/> to use the default <see cref="IEqualityComparer{T}"/> for the type of an element.</param>
+        /// <returns>
+        /// The index in the span of the first occurrence of any value other than those in <paramref name="values"/>.
+        /// If all of the values are in <paramref name="values"/>, returns -1.
+        /// </returns>
+        public static unsafe int LastIndexOfAnyExcept<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> values, IEqualityComparer<T>? comparer = null)
+        {
+            switch (values.Length)
+            {
+                case 0:
+                    return span.Length - 1;
+
+                case 1:
+                    return LastIndexOfAnyExcept(span, values[0], comparer);
+
+                case 2:
+                    return LastIndexOfAnyExcept(span, values[0], values[1], comparer);
+
+                case 3:
+                    return LastIndexOfAnyExcept(span, values[0], values[1], values[2], comparer);
+
+                default:
+                    for (int i = span.Length - 1; i >= 0; i--)
+                    {
+                        if (!values.Contains(span[i], comparer))
+                        {
+                            return i;
+                        }
+                    }
+
+                    return -1;
+            }
+        }
+
         /// <summary>Searches for the last index of any value other than the specified <paramref name="values"/>.</summary>
         /// <typeparam name="T">The type of the span and values.</typeparam>
         /// <param name="span">The span to search.</param>
@@ -1578,6 +2210,77 @@ ref Unsafe.As<T, long>(ref MemoryMarshal.GetReference(span)),
             return SpanHelpers.IndexOf(ref MemoryMarshal.GetReference(span), value, span.Length);
         }
 
+        /// <summary>
+        /// Searches for the specified value and returns the index of its first occurrence. If not found, returns -1. Values are compared using IEquatable{T}.Equals(T).
+        /// </summary>
+        /// <param name="span">The span to search.</param>
+        /// <param name="value">The value to search for.</param>
+        /// <param name="comparer">The <see cref="IEqualityComparer{T}"/> implementation to use when comparing elements, or <see langword="null"/> to use the default <see cref="IEqualityComparer{T}"/> for the type of an element.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe int IndexOf<T>(this ReadOnlySpan<T> span, T value, IEqualityComparer<T>? comparer = null)
+        {
+            if (typeof(T).IsValueType && (comparer is null || comparer == EqualityComparer<T>.Default))
+            {
+                if (RuntimeHelpers.IsBitwiseEquatable<T>())
+                {
+                    if (sizeof(T) == sizeof(byte))
+                        return SpanHelpers.IndexOfValueType(
+                            ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
+                            Unsafe.BitCast<T, byte>(value),
+                            span.Length);
+
+                    if (sizeof(T) == sizeof(short))
+                        return SpanHelpers.IndexOfValueType(
+                            ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span)),
+                            Unsafe.BitCast<T, short>(value),
+                            span.Length);
+
+                    if (sizeof(T) == sizeof(int))
+                        return SpanHelpers.IndexOfValueType(
+                            ref Unsafe.As<T, int>(ref MemoryMarshal.GetReference(span)),
+                            Unsafe.BitCast<T, int>(value),
+                            span.Length);
+
+                    if (sizeof(T) == sizeof(long))
+                        return SpanHelpers.IndexOfValueType(
+                            ref Unsafe.As<T, long>(ref MemoryMarshal.GetReference(span)),
+                            Unsafe.BitCast<T, long>(value),
+                            span.Length);
+                }
+
+                return IndexOfDefaultComparer(span, value);
+                static int IndexOfDefaultComparer(ReadOnlySpan<T> span, T value)
+                {
+                    for (int i = 0; i < span.Length; i++)
+                    {
+                        if (EqualityComparer<T>.Default.Equals(span[i], value))
+                        {
+                            return i;
+                        }
+                    }
+
+                    return -1;
+                }
+            }
+            else
+            {
+                return IndexOfComparer(span, value, comparer);
+                static int IndexOfComparer(ReadOnlySpan<T> span, T value, IEqualityComparer<T>? comparer)
+                {
+                    comparer ??= EqualityComparer<T>.Default;
+                    for (int i = 0; i < span.Length; i++)
+                    {
+                        if (comparer.Equals(span[i], value))
+                        {
+                            return i;
+                        }
+                    }
+
+                    return -1;
+                }
+            }
+        }
+
         /// <summary>
         /// Searches for the specified sequence and returns the index of its first occurrence. If not found, returns -1. Values are compared using IEquatable{T}.Equals(T).
         /// </summary>
@@ -1607,26 +2310,84 @@ ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(value)),
         }
 
         /// <summary>
-        /// Searches for the specified value and returns the index of its last occurrence. If not found, returns -1. Values are compared using IEquatable{T}.Equals(T).
+        /// Searches for the specified sequence and returns the index of its first occurrence. If not found, returns -1. Values are compared using IEquatable{T}.Equals(T).
         /// </summary>
         /// <param name="span">The span to search.</param>
-        /// <param name="value">The value to search for.</param>
+        /// <param name="value">The sequence to search for.</param>
+        /// <param name="comparer">The <see cref="IEqualityComparer{T}"/> implementation to use when comparing elements, or <see langword="null"/> to use the default <see cref="IEqualityComparer{T}"/> for the type of an element.</param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static unsafe int LastIndexOf<T>(this ReadOnlySpan<T> span, T value) where T : IEquatable<T>?
+        public static unsafe int IndexOf<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> value, IEqualityComparer<T>? comparer = null)
         {
-            if (RuntimeHelpers.IsBitwiseEquatable<T>())
+            if (RuntimeHelpers.IsBitwiseEquatable<T>() && (comparer is null || comparer == EqualityComparer<T>.Default))
             {
                 if (sizeof(T) == sizeof(byte))
-                {
-                    return SpanHelpers.LastIndexOfValueType(
+                    return SpanHelpers.IndexOf(
                         ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
-                        Unsafe.BitCast<T, byte>(value),
-                        span.Length);
-                }
-                else if (sizeof(T) == sizeof(short))
-                {
-                    return SpanHelpers.LastIndexOfValueType(
-                        ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span)),
+                        span.Length,
+                        ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(value)),
+                        value.Length);
+
+                if (sizeof(T) == sizeof(char))
+                    return SpanHelpers.IndexOf(
+                        ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(span)),
+                        span.Length,
+                        ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(value)),
+                        value.Length);
+            }
+
+            return IndexOfComparer(span, value, comparer);
+            static int IndexOfComparer(ReadOnlySpan<T> span, ReadOnlySpan<T> value, IEqualityComparer<T>? comparer)
+            {
+                if (value.Length == 0)
+                {
+                    return 0;
+                }
+
+                comparer ??= EqualityComparer<T>.Default;
+
+                int total = 0;
+                while (!span.IsEmpty)
+                {
+                    int pos = span.IndexOf(value[0], comparer);
+                    if (pos < 0)
+                    {
+                        break;
+                    }
+
+                    if (span.Slice(pos + 1).StartsWith(value.Slice(1), comparer))
+                    {
+                        return total + pos;
+                    }
+
+                    total += pos + 1;
+                    span = span.Slice(pos + 1);
+                }
+
+                return -1;
+            }
+        }
+
+        /// <summary>
+        /// Searches for the specified value and returns the index of its last occurrence. If not found, returns -1. Values are compared using IEquatable{T}.Equals(T).
+        /// </summary>
+        /// <param name="span">The span to search.</param>
+        /// <param name="value">The value to search for.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe int LastIndexOf<T>(this ReadOnlySpan<T> span, T value) where T : IEquatable<T>?
+        {
+            if (RuntimeHelpers.IsBitwiseEquatable<T>())
+            {
+                if (sizeof(T) == sizeof(byte))
+                {
+                    return SpanHelpers.LastIndexOfValueType(
+                        ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
+                        Unsafe.BitCast<T, byte>(value),
+                        span.Length);
+                }
+                else if (sizeof(T) == sizeof(short))
+                {
+                    return SpanHelpers.LastIndexOfValueType(
+                        ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span)),
                         Unsafe.BitCast<T, short>(value),
                         span.Length);
                 }
@@ -1649,6 +2410,83 @@ ref Unsafe.As<T, long>(ref MemoryMarshal.GetReference(span)),
             return SpanHelpers.LastIndexOf(ref MemoryMarshal.GetReference(span), value, span.Length);
         }
 
+        /// <summary>
+        /// Searches for the specified value and returns the index of its last occurrence. If not found, returns -1. Values are compared using IEquatable{T}.Equals(T).
+        /// </summary>
+        /// <param name="span">The span to search.</param>
+        /// <param name="value">The value to search for.</param>
+        /// <param name="comparer">The <see cref="IEqualityComparer{T}"/> implementation to use when comparing elements, or <see langword="null"/> to use the default <see cref="IEqualityComparer{T}"/> for the type of an element.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe int LastIndexOf<T>(this ReadOnlySpan<T> span, T value, IEqualityComparer<T>? comparer = null)
+        {
+            if (typeof(T).IsValueType && (comparer is null || comparer == EqualityComparer<T>.Default))
+            {
+                if (RuntimeHelpers.IsBitwiseEquatable<T>())
+                {
+                    if (sizeof(T) == sizeof(byte))
+                    {
+                        return SpanHelpers.LastIndexOfValueType(
+                            ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
+                            Unsafe.BitCast<T, byte>(value),
+                            span.Length);
+                    }
+                    else if (sizeof(T) == sizeof(short))
+                    {
+                        return SpanHelpers.LastIndexOfValueType(
+                            ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span)),
+                            Unsafe.BitCast<T, short>(value),
+                            span.Length);
+                    }
+                    else if (sizeof(T) == sizeof(int))
+                    {
+                        return SpanHelpers.LastIndexOfValueType(
+                            ref Unsafe.As<T, int>(ref MemoryMarshal.GetReference(span)),
+                            Unsafe.BitCast<T, int>(value),
+                            span.Length);
+                    }
+                    else if (sizeof(T) == sizeof(long))
+                    {
+                        return SpanHelpers.LastIndexOfValueType(
+                            ref Unsafe.As<T, long>(ref MemoryMarshal.GetReference(span)),
+                            Unsafe.BitCast<T, long>(value),
+                            span.Length);
+                    }
+                }
+
+                return LastIndexOfDefaultComparer(span, value);
+                static int LastIndexOfDefaultComparer(ReadOnlySpan<T> span, T value)
+                {
+                    for (int i = span.Length - 1; i >= 0; i--)
+                    {
+                        if (EqualityComparer<T>.Default.Equals(span[i], value))
+                        {
+                            return i;
+                        }
+                    }
+
+                    return -1;
+                }
+            }
+            else
+            {
+                return LastIndexOfComparer(span, value, comparer);
+                static int LastIndexOfComparer(ReadOnlySpan<T> span, T value, IEqualityComparer<T>? comparer)
+                {
+                    comparer ??= EqualityComparer<T>.Default;
+
+                    for (int i = span.Length - 1; i >= 0; i--)
+                    {
+                        if (comparer.Equals(span[i], value))
+                        {
+                            return i;
+                        }
+                    }
+
+                    return -1;
+                }
+            }
+        }
+
         /// <summary>
         /// Searches for the specified sequence and returns the index of its last occurrence. If not found, returns -1. Values are compared using IEquatable{T}.Equals(T).
         /// </summary>
@@ -1680,6 +2518,64 @@ ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(value)),
             return SpanHelpers.LastIndexOf(ref MemoryMarshal.GetReference(span), span.Length, ref MemoryMarshal.GetReference(value), value.Length);
         }
 
+        /// <summary>
+        /// Searches for the specified sequence and returns the index of its last occurrence. If not found, returns -1. Values are compared using IEquatable{T}.Equals(T).
+        /// </summary>
+        /// <param name="span">The span to search.</param>
+        /// <param name="value">The sequence to search for.</param>
+        /// <param name="comparer">The <see cref="IEqualityComparer{T}"/> implementation to use when comparing elements, or <see langword="null"/> to use the default <see cref="IEqualityComparer{T}"/> for the type of an element.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe int LastIndexOf<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> value, IEqualityComparer<T>? comparer = null)
+        {
+            if (RuntimeHelpers.IsBitwiseEquatable<T>())
+            {
+                if (sizeof(T) == sizeof(byte))
+                {
+                    return SpanHelpers.LastIndexOf(
+                        ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
+                        span.Length,
+                        ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(value)),
+                        value.Length);
+                }
+                if (sizeof(T) == sizeof(char))
+                {
+                    return SpanHelpers.LastIndexOf(
+                        ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(span)),
+                        span.Length,
+                        ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(value)),
+                        value.Length);
+                }
+            }
+
+            return LastIndexOfComparer(span, value, comparer);
+            static int LastIndexOfComparer(ReadOnlySpan<T> span, ReadOnlySpan<T> value, IEqualityComparer<T>? comparer)
+            {
+                if (value.Length == 0)
+                {
+                    return span.Length;
+                }
+
+                comparer ??= EqualityComparer<T>.Default;
+
+                int pos = span.Length;
+                while (true)
+                {
+                    pos = span.Slice(0, pos).LastIndexOf(value[0], comparer);
+                    if (pos < 0)
+                    {
+                        break;
+                    }
+
+                    if (span.Slice(pos + 1).StartsWith(value.Slice(1), comparer))
+                    {
+                        return pos;
+                    }
+                }
+
+                return -1;
+            }
+        }
+
         /// <summary>
         /// Searches for the first index of any of the specified values similar to calling IndexOf several times with the logical OR operator. If not found, returns -1.
         /// </summary>
@@ -1765,6 +2661,73 @@ ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span)),
             return SpanHelpers.IndexOfAny(ref MemoryMarshal.GetReference(span), value0, value1, span.Length);
         }
 
+        /// <summary>
+        /// Searches for the first index of any of the specified values similar to calling IndexOf several times with the logical OR operator. If not found, returns -1.
+        /// </summary>
+        /// <param name="span">The span to search.</param>
+        /// <param name="value0">One of the values to search for.</param>
+        /// <param name="value1">One of the values to search for.</param>
+        /// <param name="comparer">The <see cref="IEqualityComparer{T}"/> implementation to use when comparing elements, or <see langword="null"/> to use the default <see cref="IEqualityComparer{T}"/> for the type of an element.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe int IndexOfAny<T>(this ReadOnlySpan<T> span, T value0, T value1, IEqualityComparer<T>? comparer = null)
+        {
+            if (typeof(T).IsValueType && (comparer is null || comparer == EqualityComparer<T>.Default))
+            {
+                if (RuntimeHelpers.IsBitwiseEquatable<T>())
+                {
+                    if (sizeof(T) == sizeof(byte))
+                    {
+                        return SpanHelpers.IndexOfAnyValueType(
+                            ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
+                            Unsafe.BitCast<T, byte>(value0),
+                            Unsafe.BitCast<T, byte>(value1),
+                            span.Length);
+                    }
+                    else if (sizeof(T) == sizeof(short))
+                    {
+                        return SpanHelpers.IndexOfAnyValueType(
+                            ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span)),
+                            Unsafe.BitCast<T, short>(value0),
+                            Unsafe.BitCast<T, short>(value1),
+                            span.Length);
+                    }
+                }
+
+                return IndexOfAnyDefaultComparer(span, value0, value1);
+                static int IndexOfAnyDefaultComparer(ReadOnlySpan<T> span, T value0, T value1)
+                {
+                    for (int i = 0; i < span.Length; i++)
+                    {
+                        if (EqualityComparer<T>.Default.Equals(span[i], value0) ||
+                            EqualityComparer<T>.Default.Equals(span[i], value1))
+                        {
+                            return i;
+                        }
+                    }
+
+                    return -1;
+                }
+            }
+            else
+            {
+                return IndexOfAnyComparer(span, value0, value1, comparer);
+                static int IndexOfAnyComparer(ReadOnlySpan<T> span, T value0, T value1, IEqualityComparer<T>? comparer)
+                {
+                    comparer ??= EqualityComparer<T>.Default;
+                    for (int i = 0; i < span.Length; i++)
+                    {
+                        if (comparer.Equals(span[i], value0) ||
+                            comparer.Equals(span[i], value1))
+                        {
+                            return i;
+                        }
+                    }
+
+                    return -1;
+                }
+            }
+        }
+
         /// <summary>
         /// Searches for the first index of any of the specified values similar to calling IndexOf several times with the logical OR operator. If not found, returns -1.
         /// </summary>
@@ -1800,6 +2763,78 @@ ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span)),
             return SpanHelpers.IndexOfAny(ref MemoryMarshal.GetReference(span), value0, value1, value2, span.Length);
         }
 
+        /// <summary>
+        /// Searches for the first index of any of the specified values similar to calling IndexOf several times with the logical OR operator. If not found, returns -1.
+        /// </summary>
+        /// <param name="span">The span to search.</param>
+        /// <param name="value0">One of the values to search for.</param>
+        /// <param name="value1">One of the values to search for.</param>
+        /// <param name="value2">One of the values to search for.</param>
+        /// <param name="comparer">The <see cref="IEqualityComparer{T}"/> implementation to use when comparing elements, or <see langword="null"/> to use the default <see cref="IEqualityComparer{T}"/> for the type of an element.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe int IndexOfAny<T>(this ReadOnlySpan<T> span, T value0, T value1, T value2, IEqualityComparer<T>? comparer = null)
+        {
+            if (typeof(T).IsValueType && (comparer is null || comparer == EqualityComparer<T>.Default))
+            {
+                if (RuntimeHelpers.IsBitwiseEquatable<T>())
+                {
+                    if (sizeof(T) == sizeof(byte))
+                    {
+                        return SpanHelpers.IndexOfAnyValueType(
+                            ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
+                            Unsafe.BitCast<T, byte>(value0),
+                            Unsafe.BitCast<T, byte>(value1),
+                            Unsafe.BitCast<T, byte>(value2),
+                            span.Length);
+                    }
+                    else if (sizeof(T) == sizeof(short))
+                    {
+                        return SpanHelpers.IndexOfAnyValueType(
+                            ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span)),
+                            Unsafe.BitCast<T, short>(value0),
+                            Unsafe.BitCast<T, short>(value1),
+                            Unsafe.BitCast<T, short>(value2),
+                            span.Length);
+                    }
+                }
+
+                return IndexOfAnyDefaultComparer(span, value0, value1, value2);
+                static int IndexOfAnyDefaultComparer(ReadOnlySpan<T> span, T value0, T value1, T value2)
+                {
+                    for (int i = 0; i < span.Length; i++)
+                    {
+                        if (EqualityComparer<T>.Default.Equals(span[i], value0) ||
+                            EqualityComparer<T>.Default.Equals(span[i], value1) ||
+                            EqualityComparer<T>.Default.Equals(span[i], value2))
+                        {
+                            return i;
+                        }
+                    }
+
+                    return -1;
+                }
+            }
+            else
+            {
+                return IndexOfAnyComparer(span, value0, value1, value2, comparer);
+                static int IndexOfAnyComparer(ReadOnlySpan<T> span, T value0, T value1, T value2, IEqualityComparer<T>? comparer)
+                {
+                    comparer ??= EqualityComparer<T>.Default;
+                    for (int i = 0; i < span.Length; i++)
+                    {
+                        if (comparer.Equals(span[i], value0) ||
+                            comparer.Equals(span[i], value1) ||
+                            comparer.Equals(span[i], value2))
+                        {
+                            return i;
+                        }
+                    }
+
+                    return -1;
+                }
+            }
+        }
+
         /// <summary>
         /// Searches for the first index of any of the specified values similar to calling IndexOf several times with the logical OR operator. If not found, returns -1.
         /// </summary>
@@ -1900,6 +2935,43 @@ public static unsafe int IndexOfAny<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T
             return SpanHelpers.IndexOfAny(ref MemoryMarshal.GetReference(span), span.Length, ref MemoryMarshal.GetReference(values), values.Length);
         }
 
+        /// <summary>
+        /// Searches for the first index of any of the specified values similar to calling IndexOf several times with the logical OR operator. If not found, returns -1.
+        /// </summary>
+        /// <param name="span">The span to search.</param>
+        /// <param name="values">The set of values to search for.</param>
+        /// <param name="comparer">The <see cref="IEqualityComparer{T}"/> implementation to use when comparing elements, or <see langword="null"/> to use the default <see cref="IEqualityComparer{T}"/> for the type of an element.</param>
+        public static int IndexOfAny<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> values, IEqualityComparer<T>? comparer = null)
+        {
+            switch (values.Length)
+            {
+                case 0:
+                    return -1;
+
+                case 1:
+                    return IndexOf(span, values[0], comparer);
+
+                case 2:
+                    return IndexOfAny(span, values[0], values[1], comparer);
+
+                case 3:
+                    return IndexOfAny(span, values[0], values[1], values[2], comparer);
+
+                default:
+                    comparer ??= EqualityComparer<T>.Default;
+
+                    for (int i = 0; i < span.Length; i++)
+                    {
+                        if (values.Contains(span[i], comparer))
+                        {
+                            return i;
+                        }
+                    }
+
+                    return -1;
+            }
+        }
+
         /// <summary>
         /// Searches for the first index of any of the specified values similar to calling IndexOf several times with the logical OR operator. If not found, returns -1.
         /// </summary>
@@ -2009,6 +3081,74 @@ ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span)),
             return SpanHelpers.LastIndexOfAny(ref MemoryMarshal.GetReference(span), value0, value1, span.Length);
         }
 
+        /// <summary>
+        /// Searches for the last index of any of the specified values similar to calling LastIndexOf several times with the logical OR operator. If not found, returns -1.
+        /// </summary>
+        /// <param name="span">The span to search.</param>
+        /// <param name="value0">One of the values to search for.</param>
+        /// <param name="value1">One of the values to search for.</param>
+        /// <param name="comparer">The <see cref="IEqualityComparer{T}"/> implementation to use when comparing elements, or <see langword="null"/> to use the default <see cref="IEqualityComparer{T}"/> for the type of an element.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe int LastIndexOfAny<T>(this ReadOnlySpan<T> span, T value0, T value1, IEqualityComparer<T>? comparer = null)
+        {
+            if (typeof(T).IsValueType && (comparer is null || comparer == EqualityComparer<T>.Default))
+            {
+                if (RuntimeHelpers.IsBitwiseEquatable<T>())
+                {
+                    if (sizeof(T) == sizeof(byte))
+                    {
+                        return SpanHelpers.LastIndexOfAnyValueType(
+                            ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
+                            Unsafe.BitCast<T, byte>(value0),
+                            Unsafe.BitCast<T, byte>(value1),
+                            span.Length);
+                    }
+                    else if (sizeof(T) == sizeof(short))
+                    {
+                        return SpanHelpers.LastIndexOfAnyValueType(
+                            ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span)),
+                            Unsafe.BitCast<T, short>(value0),
+                            Unsafe.BitCast<T, short>(value1),
+                            span.Length);
+                    }
+                }
+
+                return LastIndexOfAnyDefaultComparer(span, value0, value1);
+                static int LastIndexOfAnyDefaultComparer(ReadOnlySpan<T> span, T value0, T value1)
+                {
+                    for (int i = span.Length - 1; i >= 0; i--)
+                    {
+                        if (EqualityComparer<T>.Default.Equals(span[i], value0) ||
+                            EqualityComparer<T>.Default.Equals(span[i], value1))
+                        {
+                            return i;
+                        }
+                    }
+
+                    return -1;
+                }
+            }
+            else
+            {
+                return LastIndexOfAnyComparer(span, value0, value1, comparer);
+                static int LastIndexOfAnyComparer(ReadOnlySpan<T> span, T value0, T value1, IEqualityComparer<T>? comparer)
+                {
+                    comparer ??= EqualityComparer<T>.Default;
+
+                    for (int i = span.Length - 1; i >= 0; i--)
+                    {
+                        if (comparer.Equals(span[i], value0) ||
+                            comparer.Equals(span[i], value1))
+                        {
+                            return i;
+                        }
+                    }
+
+                    return -1;
+                }
+            }
+        }
+
         /// <summary>
         /// Searches for the last index of any of the specified values similar to calling LastIndexOf several times with the logical OR operator. If not found, returns -1.
         /// </summary>
@@ -2040,8 +3180,81 @@ ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span)),
                         span.Length);
                 }
             }
-
-            return SpanHelpers.LastIndexOfAny(ref MemoryMarshal.GetReference(span), value0, value1, value2, span.Length);
+
+            return SpanHelpers.LastIndexOfAny(ref MemoryMarshal.GetReference(span), value0, value1, value2, span.Length);
+        }
+
+        /// <summary>
+        /// Searches for the last index of any of the specified values similar to calling LastIndexOf several times with the logical OR operator. If not found, returns -1.
+        /// </summary>
+        /// <param name="span">The span to search.</param>
+        /// <param name="value0">One of the values to search for.</param>
+        /// <param name="value1">One of the values to search for.</param>
+        /// <param name="value2">One of the values to search for.</param>
+        /// <param name="comparer">The <see cref="IEqualityComparer{T}"/> implementation to use when comparing elements, or <see langword="null"/> to use the default <see cref="IEqualityComparer{T}"/> for the type of an element.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe int LastIndexOfAny<T>(this ReadOnlySpan<T> span, T value0, T value1, T value2, IEqualityComparer<T>? comparer = null)
+        {
+            if (typeof(T).IsValueType && (comparer is null || comparer == EqualityComparer<T>.Default))
+            {
+                if (RuntimeHelpers.IsBitwiseEquatable<T>())
+                {
+                    if (sizeof(T) == sizeof(byte))
+                    {
+                        return SpanHelpers.LastIndexOfAnyValueType(
+                            ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
+                            Unsafe.BitCast<T, byte>(value0),
+                            Unsafe.BitCast<T, byte>(value1),
+                            Unsafe.BitCast<T, byte>(value2),
+                            span.Length);
+                    }
+                    else if (sizeof(T) == sizeof(short))
+                    {
+                        return SpanHelpers.LastIndexOfAnyValueType(
+                            ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span)),
+                            Unsafe.BitCast<T, short>(value0),
+                            Unsafe.BitCast<T, short>(value1),
+                            Unsafe.BitCast<T, short>(value2),
+                            span.Length);
+                    }
+                }
+
+                return LastIndexOfAnyDefaultComparer(span, value0, value1, value2);
+                static int LastIndexOfAnyDefaultComparer(ReadOnlySpan<T> span, T value0, T value1, T value2)
+                {
+                    for (int i = span.Length - 1; i >= 0; i--)
+                    {
+                        if (EqualityComparer<T>.Default.Equals(span[i], value0) ||
+                            EqualityComparer<T>.Default.Equals(span[i], value1) ||
+                            EqualityComparer<T>.Default.Equals(span[i], value2))
+                        {
+                            return i;
+                        }
+                    }
+
+                    return -1;
+                }
+            }
+            else
+            {
+                return LastIndexOfAnyComparer(span, value0, value1, value2, comparer);
+                static int LastIndexOfAnyComparer(ReadOnlySpan<T> span, T value0, T value1, T value2, IEqualityComparer<T>? comparer)
+                {
+                    comparer ??= EqualityComparer<T>.Default;
+
+                    for (int i = span.Length - 1; i >= 0; i--)
+                    {
+                        if (comparer.Equals(span[i], value0) ||
+                            comparer.Equals(span[i], value1) ||
+                            comparer.Equals(span[i], value2))
+                        {
+                            return i;
+                        }
+                    }
+
+                    return -1;
+                }
+            }
         }
 
         /// <summary>
@@ -2144,6 +3357,43 @@ public static unsafe int LastIndexOfAny<T>(this ReadOnlySpan<T> span, ReadOnlySp
             return SpanHelpers.LastIndexOfAny(ref MemoryMarshal.GetReference(span), span.Length, ref MemoryMarshal.GetReference(values), values.Length);
         }
 
+        /// <summary>
+        /// Searches for the last index of any of the specified values similar to calling LastIndexOf several times with the logical OR operator. If not found, returns -1.
+        /// </summary>
+        /// <param name="span">The span to search.</param>
+        /// <param name="values">The set of values to search for.</param>
+        /// <param name="comparer">The <see cref="IEqualityComparer{T}"/> implementation to use when comparing elements, or <see langword="null"/> to use the default <see cref="IEqualityComparer{T}"/> for the type of an element.</param>
+        public static unsafe int LastIndexOfAny<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> values, IEqualityComparer<T>? comparer = null)
+        {
+            switch (values.Length)
+            {
+                case 0:
+                    return -1;
+
+                case 1:
+                    return LastIndexOf(span, values[0], comparer);
+
+                case 2:
+                    return LastIndexOfAny(span, values[0], values[1], comparer);
+
+                case 3:
+                    return LastIndexOfAny(span, values[0], values[1], values[2], comparer);
+
+                default:
+                    comparer ??= EqualityComparer<T>.Default;
+
+                    for (int i = span.Length - 1; i >= 0; i--)
+                    {
+                        if (values.Contains(span[i], comparer))
+                        {
+                            return i;
+                        }
+                    }
+
+                    return -1;
+            }
+        }
+
         /// <summary>
         /// Searches for the last index of any of the specified values similar to calling LastIndexOf several times with the logical OR operator. If not found, returns -1.
         /// </summary>
@@ -2187,7 +3437,7 @@ ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(other)),
         /// </summary>
         /// <param name="span">The first sequence to compare.</param>
         /// <param name="other">The second sequence to compare.</param>
-        /// <param name="comparer">The <see cref="IEqualityComparer{T}"/> implementation to use when comparing elements, or null to use the default <see cref="IEqualityComparer{T}"/> for the type of an element.</param>
+        /// <param name="comparer">The <see cref="IEqualityComparer{T}"/> implementation to use when comparing elements, or <see langword="null"/> to use the default <see cref="IEqualityComparer{T}"/> for the type of an element.</param>
         /// <returns>true if the two sequences are equal; otherwise, false.</returns>
         [OverloadResolutionPriority(-1)]
         public static bool SequenceEqual<T>(this Span<T> span, ReadOnlySpan<T> other, IEqualityComparer<T>? comparer = null) =>
@@ -2198,7 +3448,7 @@ public static bool SequenceEqual<T>(this Span<T> span, ReadOnlySpan<T> other, IE
         /// </summary>
         /// <param name="span">The first sequence to compare.</param>
         /// <param name="other">The second sequence to compare.</param>
-        /// <param name="comparer">The <see cref="IEqualityComparer{T}"/> implementation to use when comparing elements, or null to use the default <see cref="IEqualityComparer{T}"/> for the type of an element.</param>
+        /// <param name="comparer">The <see cref="IEqualityComparer{T}"/> implementation to use when comparing elements, or <see langword="null"/> to use the default <see cref="IEqualityComparer{T}"/> for the type of an element.</param>
         /// <returns>true if the two sequences are equal; otherwise, false.</returns>
         public static unsafe bool SequenceEqual<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> other, IEqualityComparer<T>? comparer = null)
         {
@@ -2273,6 +3523,26 @@ ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(other)),
             return SpanHelpers.SequenceCompareTo(ref MemoryMarshal.GetReference(span), span.Length, ref MemoryMarshal.GetReference(other), other.Length);
         }
 
+        /// <summary>
+        /// Determines the relative order of the sequences being compared by comparing the elements using IComparable{T}.CompareTo(T).
+        /// </summary>
+        public static unsafe int SequenceCompareTo<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> other, IComparer<T>? comparer = null)
+        {
+            int minLength = Math.Min(span.Length, other.Length);
+            comparer ??= Comparer<T>.Default;
+
+            for (int i = 0; i < minLength; i++)
+            {
+                int c = comparer.Compare(span[i], other[i]);
+                if (c != 0)
+                {
+                    return c;
+                }
+            }
+
+            return span.Length.CompareTo(other.Length);
+        }
+
         /// <summary>
         /// Determines whether the specified sequence appears at the start of the span.
         /// </summary>
@@ -2302,6 +3572,17 @@ ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(value)),
             return valueLength <= span.Length && SpanHelpers.SequenceEqual(ref MemoryMarshal.GetReference(span), ref MemoryMarshal.GetReference(value), valueLength);
         }
 
+        /// <summary>
+        /// Determines whether a specified sequence appears at the start of a read-only span.
+        /// </summary>
+        /// <param name="span">The source span.</param>
+        /// <param name="value">The sequence to compare to the start of <paramref name="span"/>.</param>
+        /// <param name="comparer">The <see cref="IEqualityComparer{T}"/> implementation to use when comparing elements, or <see langword="null"/> to use the default <see cref="IEqualityComparer{T}"/> for the type of an element.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe bool StartsWith<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> value, IEqualityComparer<T>? comparer = null) =>
+            value.Length <= span.Length &&
+            SequenceEqual(span.Slice(0, value.Length), value, comparer);
+
         /// <summary>
         /// Determines whether the specified sequence appears at the end of the span.
         /// </summary>
@@ -2336,6 +3617,17 @@ ref MemoryMarshal.GetReference(value),
                     valueLength);
         }
 
+        /// <summary>
+        /// Determines whether the specified sequence appears at the end of the read-only span.
+        /// </summary>
+        /// <param name="span">The source span.</param>
+        /// <param name="value">The sequence to compare to the end of <paramref name="span"/>.</param>
+        /// <param name="comparer">The <see cref="IEqualityComparer{T}"/> implementation to use when comparing elements, or <see langword="null"/> to use the default <see cref="IEqualityComparer{T}"/> for the type of an element.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe bool EndsWith<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> value, IEqualityComparer<T>? comparer = null) =>
+            value.Length <= span.Length &&
+            SequenceEqual(span.Slice(span.Length - value.Length), value, comparer);
+
         /// <summary>
         /// Determines whether the specified value appears at the start of the span.
         /// </summary>
@@ -2347,6 +3639,19 @@ ref MemoryMarshal.GetReference(value),
         public static bool StartsWith<T>(this ReadOnlySpan<T> span, T value) where T : IEquatable<T>? =>
             span.Length != 0 && (span[0]?.Equals(value) ?? (object?)value is null);
 
+        /// <summary>
+        /// Determines whether the specified value appears at the start of the span.
+        /// </summary>
+        /// <typeparam name="T">The type of elements in the span.</typeparam>
+        /// <param name="span">The span to search.</param>
+        /// <param name="value">The value to compare.</param>
+        /// <param name="comparer">The <see cref="IEqualityComparer{T}"/> implementation to use when comparing elements, or <see langword="null"/> to use the default <see cref="IEqualityComparer{T}"/> for the type of an element.</param>
+        /// <returns><see langword="true" /> if <paramref name="value" /> matches the beginning of <paramref name="span" />; otherwise, <see langword="false" />.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool StartsWith<T>(this ReadOnlySpan<T> span, T value, IEqualityComparer<T>? comparer = null) =>
+            span.Length != 0 &&
+            (comparer is null ? EqualityComparer<T>.Default.Equals(span[0], value) : comparer.Equals(span[0], value));
+
         /// <summary>
         /// Determines whether the specified value appears at the end of the span.
         /// </summary>
@@ -2358,6 +3663,19 @@ public static bool StartsWith<T>(this ReadOnlySpan<T> span, T value) where T : I
         public static bool EndsWith<T>(this ReadOnlySpan<T> span, T value) where T : IEquatable<T>? =>
             span.Length != 0 && (span[^1]?.Equals(value) ?? (object?)value is null);
 
+        /// <summary>
+        /// Determines whether the specified value appears at the end of the span.
+        /// </summary>
+        /// <typeparam name="T">The type of the elements in the span.</typeparam>
+        /// <param name="span">The span to search.</param>
+        /// <param name="value">The value to compare.</param>
+        /// <param name="comparer">The <see cref="IEqualityComparer{T}"/> implementation to use when comparing elements, or <see langword="null"/> to use the default <see cref="IEqualityComparer{T}"/> for the type of an element.</param>
+        /// <returns><see langword="true" /> if <paramref name="value" /> matches the end of <paramref name="span" />; otherwise, <see langword="false" />.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool EndsWith<T>(this ReadOnlySpan<T> span, T value, IEqualityComparer<T>? comparer = null) =>
+            span.Length != 0 &&
+            (comparer is null ? EqualityComparer<T>.Default.Equals(span[^1], value) : comparer.Equals(span[^1], value));
+
         /// <summary>
         /// Reverses the sequence of the elements in the entire span.
         /// </summary>
@@ -2953,7 +4271,7 @@ public static int BinarySearch<T, TComparer>(
             this ReadOnlySpan<T> span, T value, TComparer comparer)
             where TComparer : IComparer<T>, allows ref struct
         {
-            if (comparer == null)
+            if (comparer is null)
                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.comparer);
 
             var comparable = new SpanHelpers.ComparerComparable<T, TComparer>(
@@ -3156,6 +4474,97 @@ public static unsafe void Replace<T>(this Span<T> span, T oldValue, T newValue)
             SpanHelpers.Replace(ref src2, ref src2, oldValue, newValue, length);
         }
 
+        /// <summary>
+        /// Replaces all occurrences of <paramref name="oldValue"/> with <paramref name="newValue"/>.
+        /// </summary>
+        /// <typeparam name="T">The type of the elements in the span.</typeparam>
+        /// <param name="span">The span in which the elements should be replaced.</param>
+        /// <param name="oldValue">The value to be replaced with <paramref name="newValue"/>.</param>
+        /// <param name="newValue">The value to replace all occurrences of <paramref name="oldValue"/>.</param>
+        /// <param name="comparer">The <see cref="IEqualityComparer{T}"/> implementation to use when comparing elements, or <see langword="null"/> to use the default <see cref="IEqualityComparer{T}"/> for the type of an element.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe void Replace<T>(this Span<T> span, T oldValue, T newValue, IEqualityComparer<T>? comparer = null)
+        {
+            if (typeof(T).IsValueType && (comparer is null || comparer == EqualityComparer<T>.Default))
+            {
+                if (RuntimeHelpers.IsBitwiseEquatable<T>())
+                {
+                    if (sizeof(T) == sizeof(byte))
+                    {
+                        ref byte src = ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span));
+                        SpanHelpers.ReplaceValueType(
+                            ref src,
+                            ref src,
+                            Unsafe.BitCast<T, byte>(oldValue),
+                            Unsafe.BitCast<T, byte>(newValue),
+                            (uint)span.Length);
+                        return;
+                    }
+                    else if (sizeof(T) == sizeof(ushort))
+                    {
+                        // Use ushort rather than short, as this avoids a sign-extending move.
+                        ref ushort src = ref Unsafe.As<T, ushort>(ref MemoryMarshal.GetReference(span));
+                        SpanHelpers.ReplaceValueType(
+                            ref src,
+                            ref src,
+                            Unsafe.BitCast<T, ushort>(oldValue),
+                            Unsafe.BitCast<T, ushort>(newValue),
+                            (uint)span.Length);
+                        return;
+                    }
+                    else if (sizeof(T) == sizeof(int))
+                    {
+                        ref int src = ref Unsafe.As<T, int>(ref MemoryMarshal.GetReference(span));
+                        SpanHelpers.ReplaceValueType(
+                            ref src,
+                            ref src,
+                            Unsafe.BitCast<T, int>(oldValue),
+                            Unsafe.BitCast<T, int>(newValue),
+                            (uint)span.Length);
+                        return;
+                    }
+                    else if (sizeof(T) == sizeof(long))
+                    {
+                        ref long src = ref Unsafe.As<T, long>(ref MemoryMarshal.GetReference(span));
+                        SpanHelpers.ReplaceValueType(
+                            ref src,
+                            ref src,
+                            Unsafe.BitCast<T, long>(oldValue),
+                            Unsafe.BitCast<T, long>(newValue),
+                            (uint)span.Length);
+                        return;
+                    }
+                }
+
+                ReplaceDefaultComparer(span, oldValue, newValue);
+                static void ReplaceDefaultComparer(Span<T> span, T oldValue, T newValue)
+                {
+                    for (int i = 0; i < span.Length; i++)
+                    {
+                        if (EqualityComparer<T>.Default.Equals(span[i], oldValue))
+                        {
+                            span[i] = newValue;
+                        }
+                    }
+                }
+            }
+            else
+            {
+                ReplaceComparer(span, oldValue, newValue, comparer);
+                static void ReplaceComparer(Span<T> span, T oldValue, T newValue, IEqualityComparer<T>? comparer)
+                {
+                    comparer ??= EqualityComparer<T>.Default;
+                    for (int i = 0; i < span.Length; i++)
+                    {
+                        if (comparer.Equals(span[i], oldValue))
+                        {
+                            span[i] = newValue;
+                        }
+                    }
+                }
+            }
+        }
+
         /// <summary>
         /// Copies <paramref name="source"/> to <paramref name="destination"/>, replacing all occurrences of <paramref name="oldValue"/> with <paramref name="newValue"/>.
         /// </summary>
@@ -3239,6 +4648,112 @@ ref Unsafe.As<T, long>(ref dst),
             SpanHelpers.Replace(ref src, ref dst, oldValue, newValue, length);
         }
 
+        /// <summary>
+        /// Copies <paramref name="source"/> to <paramref name="destination"/>, replacing all occurrences of <paramref name="oldValue"/> with <paramref name="newValue"/>.
+        /// </summary>
+        /// <typeparam name="T">The type of the elements in the spans.</typeparam>
+        /// <param name="source">The span to copy.</param>
+        /// <param name="destination">The span into which the copied and replaced values should be written.</param>
+        /// <param name="oldValue">The value to be replaced with <paramref name="newValue"/>.</param>
+        /// <param name="newValue">The value to replace all occurrences of <paramref name="oldValue"/>.</param>
+        /// <param name="comparer">The <see cref="IEqualityComparer{T}"/> implementation to use when comparing elements, or <see langword="null"/> to use the default <see cref="IEqualityComparer{T}"/> for the type of an element.</param>
+        /// <exception cref="ArgumentException">The <paramref name="destination"/> span was shorter than the <paramref name="source"/> span.</exception>
+        /// <exception cref="ArgumentException">The <paramref name="source"/> and <paramref name="destination"/> were overlapping but not referring to the same starting location.</exception>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe void Replace<T>(this ReadOnlySpan<T> source, Span<T> destination, T oldValue, T newValue, IEqualityComparer<T>? comparer = null)
+        {
+            nuint length = (uint)source.Length;
+            if (length == 0)
+            {
+                return;
+            }
+
+            if (length > (uint)destination.Length)
+            {
+                ThrowHelper.ThrowArgumentException_DestinationTooShort();
+            }
+
+            ref T src = ref MemoryMarshal.GetReference(source);
+            ref T dst = ref MemoryMarshal.GetReference(destination);
+
+            nint byteOffset = Unsafe.ByteOffset(ref src, ref dst);
+            if (byteOffset != 0 &&
+                ((nuint)byteOffset < (nuint)((nint)source.Length * sizeof(T)) ||
+                 (nuint)byteOffset > (nuint)(-((nint)destination.Length * sizeof(T)))))
+            {
+                ThrowHelper.ThrowArgumentException(ExceptionResource.InvalidOperation_SpanOverlappedOperation);
+            }
+
+            if (typeof(T).IsValueType && (comparer is null || comparer == EqualityComparer<T>.Default))
+            {
+                if (RuntimeHelpers.IsBitwiseEquatable<T>())
+                {
+                    if (sizeof(T) == sizeof(byte))
+                    {
+                        SpanHelpers.ReplaceValueType(
+                            ref Unsafe.As<T, byte>(ref src),
+                            ref Unsafe.As<T, byte>(ref dst),
+                            Unsafe.BitCast<T, byte>(oldValue),
+                            Unsafe.BitCast<T, byte>(newValue),
+                            length);
+                        return;
+                    }
+                    else if (sizeof(T) == sizeof(ushort))
+                    {
+                        // Use ushort rather than short, as this avoids a sign-extending move.
+                        SpanHelpers.ReplaceValueType(
+                            ref Unsafe.As<T, ushort>(ref src),
+                            ref Unsafe.As<T, ushort>(ref dst),
+                            Unsafe.BitCast<T, ushort>(oldValue),
+                            Unsafe.BitCast<T, ushort>(newValue),
+                            length);
+                        return;
+                    }
+                    else if (sizeof(T) == sizeof(int))
+                    {
+                        SpanHelpers.ReplaceValueType(
+                            ref Unsafe.As<T, int>(ref src),
+                            ref Unsafe.As<T, int>(ref dst),
+                            Unsafe.BitCast<T, int>(oldValue),
+                            Unsafe.BitCast<T, int>(newValue),
+                            length);
+                        return;
+                    }
+                    else if (sizeof(T) == sizeof(long))
+                    {
+                        SpanHelpers.ReplaceValueType(
+                            ref Unsafe.As<T, long>(ref src),
+                            ref Unsafe.As<T, long>(ref dst),
+                            Unsafe.BitCast<T, long>(oldValue),
+                            Unsafe.BitCast<T, long>(newValue),
+                            length);
+                        return;
+                    }
+                }
+
+                ReplaceDefaultComparer(source, destination, oldValue, newValue);
+                static void ReplaceDefaultComparer(ReadOnlySpan<T> source, Span<T> destination, T oldValue, T newValue)
+                {
+                    for (int i = 0; i < source.Length; i++)
+                    {
+                        destination[i] = EqualityComparer<T>.Default.Equals(source[i], oldValue) ? newValue : source[i];
+                    }
+                }
+            }
+            else
+            {
+                ReplaceComparer(source, destination, oldValue, newValue, comparer);
+                static void ReplaceComparer(ReadOnlySpan<T> source, Span<T> destination, T oldValue, T newValue, IEqualityComparer<T>? comparer)
+                {
+                    comparer ??= EqualityComparer<T>.Default;
+                    for (int i = 0; i < source.Length; i++)
+                    {
+                        destination[i] = comparer.Equals(source[i], oldValue) ? newValue : source[i];
+                    }
+                }
+            }
+        }
+
         /// <summary>Finds the length of any common prefix shared between <paramref name="span"/> and <paramref name="other"/>.</summary>
         /// <typeparam name="T">The type of the elements in the spans.</typeparam>
         /// <param name="span">The first sequence to compare.</param>
@@ -3252,7 +4767,7 @@ public static int CommonPrefixLength<T>(this Span<T> span, ReadOnlySpan<T> other
         /// <typeparam name="T">The type of the elements in the spans.</typeparam>
         /// <param name="span">The first sequence to compare.</param>
         /// <param name="other">The second sequence to compare.</param>
-        /// <param name="comparer">The <see cref="IEqualityComparer{T}"/> implementation to use when comparing elements, or null to use the default <see cref="IEqualityComparer{T}"/> for the type of an element.</param>
+        /// <param name="comparer">The <see cref="IEqualityComparer{T}"/> implementation to use when comparing elements, or <see langword="null"/> to use the default <see cref="IEqualityComparer{T}"/> for the type of an element.</param>
         /// <returns>The length of the common prefix shared by the two spans.  If there's no shared prefix, 0 is returned.</returns>
         [OverloadResolutionPriority(-1)]
         public static int CommonPrefixLength<T>(this Span<T> span, ReadOnlySpan<T> other, IEqualityComparer<T>? comparer) =>
@@ -3309,7 +4824,7 @@ ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(other)),
         /// <typeparam name="T">The type of the elements in the sequences.</typeparam>
         /// <param name="span">The first sequence to compare.</param>
         /// <param name="other">The second sequence to compare.</param>
-        /// <param name="comparer">The <see cref="IEqualityComparer{T}"/> implementation to use when comparing elements, or null to use the default <see cref="IEqualityComparer{T}"/> for the type of an element.</param>
+        /// <param name="comparer">The <see cref="IEqualityComparer{T}"/> implementation to use when comparing elements, or <see langword="null"/> to use the default <see cref="IEqualityComparer{T}"/> for the type of an element.</param>
         /// <returns>The length of the common prefix shared by the two spans.  If there's no shared prefix, 0 is returned.</returns>
         public static int CommonPrefixLength<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> other, IEqualityComparer<T>? comparer)
         {
@@ -3797,6 +5312,85 @@ ref MemoryMarshal.GetReference(span),
                 span.Length);
         }
 
+        /// <summary>Counts the number of times the specified <paramref name="value"/> occurs in the <paramref name="span"/>.</summary>
+        /// <typeparam name="T">The element type of the span.</typeparam>
+        /// <param name="span">The span to search.</param>
+        /// <param name="value">The value for which to search.</param>
+        /// <param name="comparer">The <see cref="IEqualityComparer{T}"/> implementation to use when comparing elements, or <see langword="null"/> to use the default <see cref="IEqualityComparer{T}"/> for the type of an element.</param>
+        /// <returns>The number of times <paramref name="value"/> was found in the <paramref name="span"/>.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe int Count<T>(this ReadOnlySpan<T> span, T value, IEqualityComparer<T>? comparer = null)
+        {
+            if (typeof(T).IsValueType && (comparer is null || comparer == EqualityComparer<T>.Default))
+            {
+                if (RuntimeHelpers.IsBitwiseEquatable<T>())
+                {
+                    if (sizeof(T) == sizeof(byte))
+                    {
+                        return SpanHelpers.CountValueType(
+                            ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
+                            Unsafe.BitCast<T, byte>(value),
+                            span.Length);
+                    }
+                    else if (sizeof(T) == sizeof(short))
+                    {
+                        return SpanHelpers.CountValueType(
+                            ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span)),
+                            Unsafe.BitCast<T, short>(value),
+                            span.Length);
+                    }
+                    else if (sizeof(T) == sizeof(int))
+                    {
+                        return SpanHelpers.CountValueType(
+                            ref Unsafe.As<T, int>(ref MemoryMarshal.GetReference(span)),
+                            Unsafe.BitCast<T, int>(value),
+                            span.Length);
+                    }
+                    else if (sizeof(T) == sizeof(long))
+                    {
+                        return SpanHelpers.CountValueType(
+                            ref Unsafe.As<T, long>(ref MemoryMarshal.GetReference(span)),
+                            Unsafe.BitCast<T, long>(value),
+                            span.Length);
+                    }
+                }
+
+                return CountDefaultComparer(span, value);
+                static int CountDefaultComparer(ReadOnlySpan<T> span, T value)
+                {
+                    int count = 0;
+                    for (int i = 0; i < span.Length; i++)
+                    {
+                        if (EqualityComparer<T>.Default.Equals(span[i], value))
+                        {
+                            count++;
+                        }
+                    }
+
+                    return count;
+                }
+            }
+            else
+            {
+                return CountComparer(span, value, comparer);
+                static int CountComparer(ReadOnlySpan<T> span, T value, IEqualityComparer<T>? comparer)
+                {
+                    comparer ??= EqualityComparer<T>.Default;
+
+                    int count = 0;
+                    for (int i = 0; i < span.Length; i++)
+                    {
+                        if (comparer.Equals(span[i], value))
+                        {
+                            count++;
+                        }
+                    }
+
+                    return count;
+                }
+            }
+        }
+
         /// <summary>Counts the number of times the specified <paramref name="value"/> occurs in the <paramref name="span"/>.</summary>
         /// <typeparam name="T">The element type of the span.</typeparam>
         /// <param name="span">The span to search.</param>
@@ -3835,6 +5429,36 @@ public static int Count<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> value) whe
             }
         }
 
+        /// <summary>Counts the number of times the specified <paramref name="value"/> occurs in the <paramref name="span"/>.</summary>
+        /// <typeparam name="T">The element type of the span.</typeparam>
+        /// <param name="span">The span to search.</param>
+        /// <param name="value">The value for which to search.</param>
+        /// <param name="comparer">The <see cref="IEqualityComparer{T}"/> implementation to use when comparing elements, or <see langword="null"/> to use the default <see cref="IEqualityComparer{T}"/> for the type of an element.</param>
+        /// <returns>The number of times <paramref name="value"/> was found in the <paramref name="span"/>.</returns>
+        public static int Count<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> value, IEqualityComparer<T>? comparer = null)
+        {
+            switch (value.Length)
+            {
+                case 0:
+                    return 0;
+
+                case 1:
+                    return Count(span, value[0], comparer);
+
+                default:
+                    int count = 0;
+
+                    int pos;
+                    while ((pos = span.IndexOf(value, comparer)) >= 0)
+                    {
+                        span = span.Slice(pos + value.Length);
+                        count++;
+                    }
+
+                    return count;
+            }
+        }
+
         /// <summary>Writes the specified interpolated string to the character span.</summary>
         /// <param name="destination">The span to which the interpolated string should be formatted.</param>
         /// <param name="handler">The interpolated string.</param>