Add MemoryExtension APIs to get parity with array APIs

[ahsonkhan]

As part of completing the MemoryExtensions feature - https://github.com/dotnet/corefx/issues/24880 - here are the proposed Span extension APIs that should get added to get parity with the available APIs on array.

Proposed API Additions

public static class MemoryExtensions
{
    // Slice + CopyTo APIs can be used instead, hence we don't need the overloads
    //public static void Copy<T>(this ReadOnlySpan<T> sourceSpan, Span<T> destinationSpan, int length);
    //public static void Copy<T>(this ReadOnlySpan<T> sourceSpan, int sourceIndex, Span<T> destinationSpan, int destinationIndex, int length);
    
    // Span CopyTo API is already "constrained" in that if it throws an exception, the destination remains unchanged. Hence, we don't need this API
    //public static void ConstrainedCopy<T>(this ReadOnlySpan<T> sourceSpan, int sourceIndex, Span<T> destinationSpan, int destinationIndex, int length);
    
    public static bool Exists<T>(this ReadOnlySpan<T> span, Predicate<T> match);

    public static T Find<T>(this ReadOnlySpan<T> span, Predicate<T> match);
    public static int FindIndex<T>(this ReadOnlySpan<T> span, Predicate<T> match);
    // Slice the span before calling the method above, hence we don't need the overloads
    //public static int FindIndex<T>(this ReadOnlySpan<T> span, int startIndex, Predicate<T> match);
    //public static int FindIndex<T>(this ReadOnlySpan<T> span, int startIndex, int count, Predicate<T> match);
    
    public static T FindLast<T>(this ReadOnlySpan<T> span, Predicate<T> match);
    public static int FindLastIndex<T>(this ReadOnlySpan<T> span, Predicate<T> match);
    // Slice the span before calling the method above, hence we don't need the overloads
    //public static int FindLastIndex<T>(this ReadOnlySpan<T> span, int startIndex, Predicate<T> match);
    //public static int FindLastIndex<T>(this ReadOnlySpan<T> span, int startIndex, int count, Predicate<T> match);
    
    // Requires allocation
    public static T[] FindAll<T>(this ReadOnlySpan<T> span, Predicate<T> match);
    // Alternative to avoid allocation
    public static bool TryFindAll<T>(this ReadOnlySpan<T> span, Predicate<T> match, Span<T> result);

    public static void Reverse<T>(this Span<T>);
    // Slice the span before calling the method above, hence we don't need the overload
    //public static void Reverse<T>(this Span<T>, int index, int length); 

    public static bool TrueForAll<T>(this ReadOnlySpan<T> span, Predicate<T> match);

}

Sample Usage and Rationale

The API usage should be almost identical to the Array API usage. Getting API parity with array makes it easier for customers to port their array-based code to Span wherever possible.

Example sample usage:

public static void UseTrueForAll()
{
    ReadOnlySpan<string> values1 = new string[] { "Y2K", "A2000", "DC2A6", "MMXIV", "0C3" };
    ReadOnlySpan<string> values2 = new string[] { "Y2", "A2000", "DC2A6", "MMXIV_0", "0C3" };

    Assert.False(values1.TrueForAll(value => 
    {
        return int.TryParse(value.Substring(value.Length - 1), out int s);
    }));
    Assert.True(values2.TrueForAll(value => 
    {
        return int.TryParse(value.Substring(value.Length - 1), out int s);
    }));

    Assert.False(values1.TrueForAll(EndsWithANumber));
    Assert.True(values2.TrueForAll(EndsWithANumber));
}

private static bool EndsWithANumber(string value)
{
    return int.TryParse(value.Substring(value.Length - 1), out int s);
}

cc @KrzysztofCwalina, @dotnet/corefxlab-contrib, @stephentoub, @jkotas

[terrajobst]

Video

Let's only add Reverse and not the rest. Reason being that delegate invocations could potentially become a perf trap; the have obvious 1 - 5 line replacements for the caller. Reverse can be optimized and seems generally useful.