[Proposal] switch expression as function

[alex-netkachov]

Consider the following case:

var area = shapes.Sum(s => s switch {
  Rect r => r.width * r.height,
  Circle c => c.d * Math.Pi,
});

the s => s seems redundant here. It would be a bit simpler to have

var area = shapes.Sum(switch {
  Rect r => r.width * r.height,
  Circle c => c.d * Math.Pi,
});

The switch { ... } in the functional context could be resolved to Func<T, V>.

Similar concept exists in F# - it is pattern matching function:

let foo1 x = 
    match x with
    | 1 -> "one"
    | _ -> "not one"

let foo2 = function 
    | 1 -> "one" 
    | _ -> "not one"

[HaloFour]

If #91 were implement then theoretically you could do:

var area = shapes.Sum(@ switch {
  Rect r => r.width * r.height,
  Circle c => c.d * Math.Pi,
});

[alex-netkachov]

Thank you. Yes, it is close, but a bit different.

I've thought a bit more about my proposal and it is transforming into the more general one but more complicated as well:

• when the expression has undefined variables, automatically convert it to generic function
• when generic function is supplied, infer types from the context.

So to say, x + y should not error. Instead it should be converted into something like Func<T1, T2, T3>, where T3 is actually derivable during compile time.

Then "magically", instead of writing

var query = db.Orders
    .Where(order => order.Value > 50.0m)
    .Select(order => order.Employee)
    .OrderBy(employee => employee.Name);

you can write

var query = db.Orders
    .Where(order.Value > 50.0m)
    .Select(order.Employee)
    .OrderBy(employee.Name);

And it just works, assuming that there is no order or employee defined in the scope.

[bandleader]

Re: original suggestion: too specific IMHO, better to solve via #91.
Re: new suggestion, which replaces #91: I think it's not as good as #91 itself, for reasons I've posted there.

Keep the suggestions coming!

[alex-netkachov]

Thank you for comment.

Re: original suggestion: too specific IMHO, better to solve via #91.

Yes, it is more specific than #91, but due to its specific it might be still implemented if #91 gets rejected.

BTW, I've remembered that it exists in F# - it is pattern matching function.

let foo1 x = 
    match x with
    | 1 -> "one"
    | _ -> "not one"

let foo2 = function 
    | 1 -> "one" 
    | _ -> "not one"