Proposal: extend pattern matching for types

[AlexRadch]

Proposal: extend pattern matching for types.

Pattern matching for types will be useful if we want to use a method that is appropriate for our type under a certain condition, for example the method has a where constraint on some interface.

For example, we want to write the IndexOf method for Span and type T without limits: public static int IndexOfEquals<T>(this Span<T> span, T value).

We can notice that if the type T implements the interface IEquatable<T> then for such T corresponding method is already exists and we just need to call it, but the compiler will not allow us to do that.

        public static int IndexOfEquals<T>(this Span<T> span, T value)
        {
            if (T is IEquatable<T> Equatable)
                return System.MemoryExtensions.IndexOf(span, (Equatable)value);
            // something else           
        }

So I suggest to extend compiler to enable code with pattern matching for types.

[stepanbenes]

You can use this instead

public static int IndexOfEquals<T>(this Span<T> span, T value)
{
    if (value is IEquatable<T> equatable)
    {
        return System.MemoryExtensions.IndexOf(span, equatable);
    }
    return -1;
}

[AlexRadch]

@stepanbenes your code is incorrect because we have Span<T> span but not Span<IEquatable<T>> span

[DavidArno]

EDIT - I noticed after posting that stepanbenes had already provided the same code example as me. I'm confused, @AlexRadch, by your "we have Span<T> span but not Span<IEquatable<T>> span" comment. That is the purpose of the value is IEquatable<T> equatable check is to determine if the item in Span<T> is IEquatable<T> or not. Perhaps you need to expand your OP to explain this in more detail?

[AlexRadch]

@DavidArno your code is incorrect because we have Span<T> span but not Span<IEquatable<T>> span

[stepanbenes]

@AlexRadch then add the type constraint where T : IEquatable<T> to your method.

[stepanbenes]

public static int IndexOfEquals<T>(this Span<T> span, T value) where T : IEquatable<T>
{
    if (value is IEquatable<T> equatable)
    {
        return System.MemoryExtensions.IndexOf(span, equatable);
    }
    return -1;
}

[AlexRadch]

@AlexRadch then add the type constraint where T : IEquatable to your method.

Then it will be copy of MemoryExtensions.IndexOf method, but I am creating new method for any T

[AlexRadch]

If add where T : IEquatable<T> then if (value is IEquatable<T> equatable) is always true.

[stepanbenes]

@AlexRadch Yes, you are right. I was confused by your example. You should have mentioned that you want to extend the functionality of MemoryExtensions.IndexOf<T>(...) where T : IEquatable<T> method to work with unconstrained T.

[AlexRadch]

@AlexRadch Yes, you are right. I was confused by your example. You should have mentioned that you want to extend the functionality of MemoryExtensions.IndexOf(...) where T : IEquatable method to work with unconstrained T.

I think there are many cases where pattern matching for types will be useful. I added only one small example for Span.

[DavidArno]

@AlexRadch,

You have posted the same code example here and in #1840 and have received the same code advice three times. This suggests that you need to improve what you are asking for as it's clearly causing confusion. Could you expand your OP please to better explain things? Also, your request for pattern matching of types makes sense but gets lost due to this confusion.

[AlexRadch]

You have posted the same code example here and in #1840 and have received the same code advice three times. This suggests that you need to improve what you are asking for as it's clearly causing confusion. Could you expand your OP please to better explain things? Also, your request for pattern matching of types makes sense but gets lost due to this confusion.

You are right, but I have bad English for it. I will think how to improve my question on english.

[AlexRadch]

@DavidArno I updated my proposal. Can you correct and expand my English?

[DavidArno]

I don't see how your proposal would work:

public static int IndexOfEquals<T>(this Span<T> span, T value)
{
    if (T is IEquatable<T> Equatable)
        return System.MemoryExtensions.IndexOf(span, (Equatable)value);
    // something else           
}

would still have the problem that span needs casting too to Span<IEquatable<T>> too. How is the compiler to know that?

So I think your example wants to look something like:

public static int IndexOfEquals<T>(this Span<T> span, T value)
{
    if (T is IEquatable<> TEquatable && 
        value is TEquatable equatableValue &&
        span is Span<TEquatable> equatableSpan)
        return MemoryExtensions.IndexOf(equatbleSpan, equatableValue);
    // something else           
}

Or have I just misunderstood?

[bondsbw]

Mostly a duplicate of #631.

Edit: this one adds the ability to introduce a constrained type parameter (type variable?) in scope at that location.

[AlexRadch]

@DavidArno I think that next code:

    if (T is IEquatable<T> Equatable)
        return System.MemoryExtensions.IndexOf(span, (Equatable)value);

should work like next code

    if (T is IEquatable<T>)
        return System.MemoryExtensions.IndexOf(span, (T: IEquatable<T>)value);

It looks like that T support IEquatable interface.