Proposal: Simplified "If" statement for comparing the same value

[doktrova]

Lets say we have an if statement like below:

if ( Car.Make("Benz").Body.Wheels.Count == 4 || Car.Make("Benz").Body.Wheels.Count == 3)
    //Do something...

Since some times the properties chain can be long and we can have even more ors(||) added. it can get ugly. One solution is to introduce a variable.

var numWheels = Car.Make("Benz").Body.Wheels.Count;
if ( numWheels == 4 || numWheels == 3)
  //Do Something..

Can we do something where in these cases we don't have to introduce a variable or have long ifs?
Here is an idea. Maybe someone else can have a better looking syntax.

if ( Car.Make("Benz").Body.Wheels.Count == 4 || == 3)
    //Do something...

if ( Car.Make("Benz").Body.Wheels.Count == 4 || == 3 && != 26 && >1)
    //Do something...

[mattwar]

You can already write:

if ( (Car.Make("Benz").Body.Wheels.Count is var wheels) && (wheels == 4 || wheels == 3) )
   // Do something...

[bondsbw]

We had a discussion about a similar feature (partial infix expressions) in #812.

[TonyValenti]

I just recently asked for something similar and learned a nice way to do it:

if ( Car.Make("Benz").Body.Wheels.Count is var Wheels && (Wheels == 3 || Wheels == 4)) {

}

I want to point out that "is var" is not the same as "is ". IsVar always returns true and always assigns a value to the following variable. Is only returns true if it can assign a non-null value.

[TonyValenti]

#899

[doktrova]

@mattwar that's pretty cool I didn't know about that, but In my opinion it is the same amount of code and it looks more confusing than declaring a new variable.

[DavidArno]

This can be worked around using is var:

if (Car.Make("Benz").Body.Wheels.Count is var wheelsCount && wheelsCount == 4 || wheelsCount == 3)

but it's long-winded. Allowing as var would make the code tidier:

if (Car.Make("Benz").Body.Wheels.Count as var wheelsCount == 4 || wheelsCount == 3)

[Pzixel]

Am I alone thinkinh that using is for just create a variable where value goes is a broken idea? Really, we already have a syntax for declare a variable var foo = 42, so I don't understand at all why even write if (42 is var foo). The former is nicier in all ways. I think use is for declaring variables is just a feature abuse.

I'd like more idea about expression if or blocked a ? { b } : { c } operator but that's another story...

[HaloFour]

@Pzixel

It's not is that is creating the variable, it is the variable pattern var. The use in these simple cases could be considered "abuse" only in that it's weird shorthand for something someone could already do if they weren't so bent on single-line expressions. Where variable patterns will become more useful is in recursive pattern matching where it can be used to extract a value from within a more complicated expression.

Either way, it's in the language already.

And you already have an expression if, it's called ?:.

Conversely, you already have a blocked ?:, it's called if.

[Pzixel]

@HaloFour when I'm taling about blocking if I'm talking about if's like in Rust

    let big_n =
        if n < 10 && n > -10 {
            println!("n is a small number, increase ten-fold");
            10 * n
        } else {
            println!("n is a big number, reduce by two");
            n / 2
        };

Today I'm trying to extract a method where I can but it's not always possible/preferable.
So extending either if to be an expression or ? : to accept statements would do it. But being said, that's another story. And it may be solved with upcoming match keyword.

It's not is that is creating the variable, it is the variable pattern var

I was never understanding this always matching pattern. Why even introduce it? I can understand if ((object)42 is int i && i > 10) .., but if pattern always succeed why not just store it in a ol' good way? Maybe there are some scenarious, but I haven't seen any.

[HaloFour]

@Pzixel

In Rust all statements are either declarations or expressions. That is not the case in C# and it wouldn't make sense to try to force it onto C#.

I was never understanding this always matching pattern. Why even introduce it?

Sets the foundation for recursive patterns where some other part of the pattern might not succeed. Or it could be combined with pattern guards to filter based on more complex logic that can't be directly mapped to a pattern.

The use case described in this proposal isn't a wrong use of the var pattern. But if you don't like it you're free to continue pre-declaring and assigning your variables prior to comparing them.

Note that Rust has top-level always-matching variable bindings also:

let x = 1;

match x {
    y => println!("x: {} y: {}", x, y),
}

[Pzixel]

In Rust all statements are either declarations or expressions. That is not the case in C# and it wouldn't make sense to try to force it onto C#.

Do not substitute concepts, I'm talking about extensing ? : operator, not about having all blocks return values :)

The use case described in this proposal isn't a wrong use of the var pattern. But if you don't like it you're free to continue pre-declaring and assigning your variables prior to comparing them

It's just my IMHO that that's a misuse of the feature. No more, no less.

Sets the foundation for recursive patterns where some other part of the pattern might not succeed. Or it could be combined with pattern guards to filter based on more complex logic that can't be directly mapped to a pattern.

Could you provide an example, please?

[DavidArno]

@Pzixel,

One example of recursive patterns would be with tuples:

(bool succss, int value) TryParse(string s) ... 

if (TryParse("123") is var (success, value) && success)
{
    // use value here

[HaloFour]

@Pzixel

Do not substitute concepts,

You're the one who mentioned expression if.

Take a look at #377, that would enable the scenario that you described:

var big_n = (n < 10 && n > -10)
    ? (Console.WriteLine(", and is a small number, increase ten-fold"); 10 * n)
    : (Console.WriteLine(", and is a big number, reduce by two"); n / 2);

[DavidArno]

@Pzixel,

Am I alone thinkinh that using is for just create a variable where value goes is a broken idea?

I doubt you are alone, but I disagree it's a broken idea. I have to confess, I haven't found a use for x is var y yet, but I use x is T y a lot. It provides a compact way of testing whether a variable is of a given type and introducing a new variable of that type all in one go:

SomeType Foo(IEnumerable<T> collection) =>
    collection is List<T> list ? HandleAsList(list) : HandleAsEnumerable(collection);

[Pzixel]

@DavidArno this example is completely valid. I'm talking about some bizzare things like:

SomeType Foo() =>
   new int[1,2,3] is var collection ? HandleAsEnumerable(collection) : null;

instead of

SomeType Foo()
{
   var collection = new int[1,2,3];
   HandleAsEnumerable(collection);
}

just because it's singleline.

Here is plenty example in issues where they are using just to copy a value:

SomeType Foo()
{
   var collection = new int[1,2,3];
   if (collection is var collectionCopy)
   {
      HandleAsEnumerable(collectionCopy);
   }
}

or more realistic example:

if ( (Car.Make("Benz").Body.Wheels.Count is var wheels) && (wheels == 4 || wheels == 3) )

and so on.

[HaloFour]

@DavidArno

I believe he means that he's using the "leaky" scope to write validation code where he intends the variable to remain usable:

if (!(arg is Foo foo))
    throw new ArgumentException($"{nameof(arg)} ain't no Foo!");

foo.Pity();

[jnm2]

@DavidArno @HaloFour yes, particularly when there are many early exit conditions or when foo is referenced in multiple statements following the early exit check.

Also, I dislike leaving the last line of a method a throw statement to handle some error condition. I want that to be the main return. The only exception to this is a pure switch or dispatch-style method.

[jnm2]

See, corefx does this even more than me:

https://github.com/dotnet/corefx/blob/c4e03f00fe667aed5a4a79a4b039a8c842fdfcc4/src/System.Drawing.Common/src/System/Drawing/Font.cs#L476-L498

[jnm2]

Here's a similar example with more detail, using out var scope the same way. I see how you could argue the clarity of it either way, but it just feels clean to me:

[jnm2]

Oops, missed that I didn't need to assign info anymore. Even closer to its usage now. 😄

[DavidArno]

@jnm2 & @HaloFour,

Thanks, makes sense now.

Ask me again in a year and I may have changed my mind. In the meantime, I still think it an ugly pattern and the leakiness is too high a price to pay for convenience. If topLevel is going to be used beyond the if, I'd want to write it as:

var topLevel = enumTypeReference as TopLevelTypeReference;
if (topLevel == null) throw(...

// use topLevel here.

[jnm2]

It ends up feeling like a lot of repeated two-statement boilerplate to me. But who knows, maybe in another year I'll agree with you. =D

[jcouv]

An extension method would do the trick: if ( Car.Make("Benz").Body.Wheels.Count.IsIn(3, 4) ).
You can have a couple of overloads with different numbers of parameters.

[Pzixel]

@jcouv public static bool IsIn(this int value, params Span<int> values) => values.Contains(value);

[calin-darie]

Read this whole thing hoping for a revelation, but I'm sad to say I'm still with @Pzixel here.

    if (Car.Make("Benz").Body.Wheels.Count is var wheels && wheels == 4 || wheels == 3)

• [pro] it's saving you one instance of typing wheels
• [con] it's making the boolean expression harder to read, you have to figure out it translates to

if (true && wheels = 4 || wheels == 3)

• [con] it's inlining declaration and usage, assignment and control flow. I've got no double standards here, I prefer writing

var success = int.TryParse("42", out i); 
if (!success) return;

and it would have been tree lines instead of two with no pattern matching. I really love that pattern matching enables declaration and initialization to go on one line. I don't care about declaration+initialization+(first use). Same applies to the recursive patterns example:

var (success, value) = TryParse("123");
if (success) {...

I generally love where C# syntax is going, and I'm adopting new features early, but in this case the old syntax is clearer for the same amount of keystrokes.

• [con] most important con of all if you ask me it doesn't solve this issue! I want to write if wheels == 4 || == 3 || (>42 && <50) and saving me just one initial mention of wheels is not much of a consolation

Speaking of the original issue, I always wanted a ternary math-like less-than:

if (18 < age && age < 72)

=>

if (18 < age < 72)

with all the variations of course

< <=
<= <
> >
> >=
>= >

Didn't give it a proper thought though. Hopefully there's no ambiguous syntax resulting from these ternary operators.

[quinmars]

Why not use a switch?

switch (Car.Make("Benz").Body.Wheels.Count)
{
    case 3: case 4:
    //Do something...
    break;
}

[calin-darie]

If all you need to do is test against a few const values, you could go with a switch, or, better yet for brevity, with the .IsIn( LINQ extension proposed above. But if you need to test against a range, or set of ranges, or some arbitrarily complex expression, a switch won't help much. Also, you can't treat a switch as a boolean expression to further compose it, not without making a method/local function of it anyway.
A solution could be:

...
    //usage
    if (42.Is(InRange(30, 50).Or(InRange(100, 200))));
...
    public static class BoolExpressionExtensions
    {
        public static bool Is<T>(this T value, params Predicate<T>[] predicates) => 
            predicates.All(p => p(value));

        public static Predicate<T> InRange<T>(T rangeMin, T rangeMax)
            where T:IComparable<T> => 
            value => value.CompareTo(rangeMin) >= 0 &&
                     value.CompareTo(rangeMax) <= 0;

        public static Predicate<T> Or<T> (this Predicate<T> predicateA, Predicate<T> predicateB) => 
            v => predicateA(v) || predicateB(v);
    }

Is there a library for this? I couldn't find one, and I'm tempted to write one.

[quinmars]

@calin-darie, not what you are looking for, but Fluent Assertions goes in a similar direction.

[Acerby]

With pattern matching you can now just say:
if ( Car.Make("Benz").Body.Wheels.Count is 3 or 4)
{
}

[DavidArno]

And it's even possible to say:

if ( Car.Make("Benz").Body.Wheels.Count is 4 or 3 and not 26 and >1)
    //Do something...

though I'm less clear why one would want to write that 😃

I wonder if there's more gems like this hidden away in the discussion backlog that have been effectively implement and could be close.

[AraHaan]

I could have sworn one could do this today ever since C# 10:

if ( Car.Make("Benz").Body.Wheels.Count is 3 or 4 )
    //Do something...