Need implicit type convert in "is" constant pattern matching

[ahdung]

this code obj is 0, if i'm not sure the obj's type is int, then i dare not write like this, because the result is probably not as expected.

byte a = 0;
object obj = a;
obj is 0 // false

This limits the use of is, so i hope it do type convert.

[alrz]

Try obj is (byte)0.

You need the same type when you are unboxing. 0 is int..

[333fred]

explicit Convert might cause exception, like DBNull, it's not a good option.

We couldn't automatically generate anything that worked better. You're just including the default language built-in numeric types here. You could have a Rational number type, or an Imaginary number type, and checking them for being 0 would also be valid. But we have no way of generating that code.

[ahdung]

@333fred In my opinion, just implicit convert obj to the type of this constant(this case is int) is enough. If the conversion fails, just return false.

[svick]

@ahdung That's still not possible. To perform an implicit cast, the compiler needs to know the the type to cast from. Or it would have to do something similar to reflection or dynamic, but those are generally not acceptable without explicit opt-in.

[ahdung]

Anyway, obj is 0 return false just because obj is not an int, this is not graceful.

[huoyaoyuan]

The limitation comes from type system, not pattern matching.

[HaloFour]

This feels like perhaps a use case for active patterns?

[theunrepentantgeek]

Rereading this thread, I was struct by something in this block:

if    (obj is int a && a > 0
    || obj is byte b && b > 0
    || obj is short c && c > 0
    || obj is long d && d > 0
    || obj is sbyte e && e > 0
    || obj is ushort f && f > 0
    || obj is uint g && g > 0
    || obj is ulong h && h > 0
    || obj is float i && i > 0
    || obj is double j && j > 0
    || obj is decimal k && k > 0
    )
{
    DoSomething();
}

Across all these different types of numbers (different ranges, precisions, etc), comparisons with zero (0) are about the only meaningful common operation.

Addition and subtraction can't be generalized because of the differences in range (code that could never overflow with int is extremely likely to with byte, for example). Same for multiplication.

Division is a whole 'nother can of worms - some of the types support floating point division, others only integer based.

Even if we restrict ourselves to just comparison operators, things don't work.

Let's imagine for a moment that this desired code worked:

if (obj is < 6) {
    DoSomething();
}

(The only differences are using < and changing the boundary to 6)

If obj contained 5.7 (a double value) then implicit conversion can't work because there's no implicit conversion from double to int.

If it was forced (say, using Convert.ToInt32(5.7)) then the answer would be wrong, with the condition returning false (because Convert.ToInt32(5.7) == 6).

I don't think relying on implicit conversions is a good idea.

Instead, within the current bounds of C#, and assuming that obj does contain some kind of numeric type, you can convert it pretty easily:

var value = (double)Convert.ToDouble((dynamic)obj);

Using dynamic forces overload resolution to happen at runtime (instead of compile time), so any of the numeric types supported by Convert.ToDouble() will be handled cleanly.

Issues to be aware of include performance (dynamic is slow, but not that slow, especially if you're working with human perceptible speeds), and exceptions (if obj is not a numeric type, thing will blow up).