Number Parity Expression Keyword

[toupswork]

Would adding language support for checking whether a number is odd or even have merit?

So instead of using the modulo operator as we do now, we'd have a more expressive syntax.

Moreover, in the lowered code, it would use the faster bitwise operation myNumber & 1

A rough draft of what it might look like is the following, although there are multiple other ways of doing if your concern is that expression keywords should be available to all types, not just numeric. even and odd could be keywords:

if(myNumber is even)
{
    // Handle even number
}
else if(myNumber is odd)
{
    // Handle odd number
}

OR something like this

var num = 4;
if(num is { Even: true }) { ... }

[HaloFour]

That is already legal type-test syntax.

[toupswork]

I tried it and it doesn't compile

[HaloFour]

That's because you don't have a type named even in scope:

https://sharplab.io/#v2:EYLgtghglgdgNAFxANwKYCcoDMCecAmIA1AD4ACATAIwCwAUGQMwAElzqaMzA3swL716TVhWYBhHvWbTWLMgBZmAWQAUASkl0Z25lJ3NkEdMxgBXMMwC8zRgG49Os2CJF7W/dhVPmUAM7tODTIqAE4VACIOVBhwtTdtATo+IA===

using System;

public class even { }

public class C {
    public void M() {
        
       var num = 3;
       num++;
       if(num is even) Console.WriteLine("even");
    }
}

[toupswork]

My fault for not being clearer in my question. So I meant that even and odd would be a keyword.

[HaloFour]

I definitely don't think these use cases deserve keywords.

Either way, that is legal syntax and would compile today if those types are in scope, so that would introduce a breaking change that would necessitate contextual keywords.

[toupswork]

I definitely don't think these use cases deserve keywords.

I respect that.

[TahirAhmadov]

public static class Int32Extensions
{
  public static bool IsOdd(this int This) => This % 2 == 1;
  public static bool IsEven(this int This) => This % 2 == 0;
}

int a = 123;
if(a.IsOdd())
{
}

[toupswork]

We should at least be able to:

       var num = 4;

       if(num is { IsEven: true}) Console.WriteLine("even");

[HaloFour]

Extension properties would probably enable that.

[toupswork]

Extension properties would probably enable that.

You're right. Ok well then that's something to look forward to. Thank you.

[tannergooding]

You don't even need extensions. We've provided APIs built-in to all primitive and in-box numeric types since .NET 7:

• https://learn.microsoft.com/en-us/dotnet/api/system.int32.iseveninteger?view=net-8.0
• https://learn.microsoft.com/en-us/dotnet/api/system.int32.isoddinteger?view=net-8.0

So you can simply do int.IsEvenInteger(x) and get the expected result.

These are also available as part of the System.Numerics.INumberBase<TSelf> interface: https://learn.microsoft.com/en-us/dotnet/api/system.numerics.inumberbase-1?view=net-8.0

They are named such because they also exist on non-integer numeric types, like float and double, where it is important to qualify they are testing that the represented value is a whole integer that is even or odd (therefore 2.2 is neither even nor odd, but 2.0 is even).

[toupswork]

@HaloFour Here is another question. Why does the design team disagree with having an operator for "is".
I am imagining the possibilities this would provide, which makes me curious why that would be a bad idea. Because currently it only supports types, constants, or pattern matches.

Examples

public struct Even
{
    public static bool operator is(int number, Even e) => (number & 1) == 0;
}

public struct Odd
{
    public static bool operator is(int number, Odd o) => (number & 1) == 1;
}

public struct Prime
{
    public static bool operator is(int number, Prime p) => {...}
}

int num = 7;

var result = num switch
{
    Even => $"{num} is even",
    Odd => $"{num} is odd",
    Prime => $"{num} is prime",
    _ => $"{num} does not match any known condition"
};

Console.WriteLine(result);

[HaloFour]

Active patterns are something that the language team has expressed interest in.

[toupswork]

Nice! Appreciate it!

[FaustVX]

Not related to the proposal, but the last 2 branches of your switch can't be reached, as every number is either even or odd. switch are evaluated top to bottom.