Identity function expression

[tiakun]

It is quite often I need to develop something a bit abstract than usual and need to use Func<T, T> to abstract instance building away. As I start to adopt nullable reference type, Func<T, T> becomes non-nullable and I need to assign f => f to it. Consider this method

void Execute(Func<T, T> builder)

The problem is that for me the builder parameter exists only to support small use cases. If I would like to make it optional, I would need to write it as

void Execute(Func<T, T>? builder = null)

but then the implementation will need to check against null value. The perfect solution would be

void Execute(Func<T, T> builder = f => f)

This would allow me to use builder without null-checking, but it is invalid because f => f is not a compile-time constant. Should C# provide something like identity function that works at compile-time to support use case like this? A StackOverflow user has discussed about this since 2009 so I guess I'm not alone.

[YairHalberstadt]

There have been a number of requests for non constant optional parameters. Whilst I could see the general proposal happening (given a suitable design), I dont think the identity function is special enough To warrant special treatment on is own

[Unknown6656]

One idea might be relaxing that for parameters of a delegate type when the default value is a direct reference to a method, e.g.:

class C<T>
{
    static T id(T x) => x;

    void M(Func<T, T> func = id)
    {
    }
}

I think (correct me if I'm wrong) that would not require any CLR change, as the compiler would use some kind of unique numeric token to identify id, which could then be used as default parameter for func.

[HaloFour]

Also pretty easily solved with overloads:

private static readonly Func<T, T> IDENTITY = f => f;

void Execute() => Execute(IDENTITY);
void Execute(Func<T, T> builder) { ... }

[tiakun]

This is kind of solve it locally. Overload is not even needed if user knows IDENTITY is there. But one thing is that IDENTITY is not the language's feature like it is in F#. If it were, we can just provide void Execute(Func<T, T> builder) and let user call it with something like IDENTITY without resorting to f => f every time.

[svick]

If it were, we can just provide void Execute(Func<T, T> builder) and let user call it with something like IDENTITY without resorting to f => f every time.

Are you saying Execute(IDENTITY) is better than Execute(f => f)? Why?

[tiakun]

One thing is that because it is clearer to other people who look at my code so they don't have to doubt or double check with me if I forgot to transform f to something else.

[pinkfloydx33]

This would allow me to use builder without null-checking

If it's part of your public API surface you should still null check it. Even with a default parameter someone could pass null to it (directly or indirectly), and without compiler warnings if nullable is not enabled. Even with nullable enabled, a null! could be passed in.

Obviously it depends on your consumers. If it's all internal (like for your company) and you can enforce nullable enabled, warnings as errors and maybe a few analyzers to boot, you might be safe without null checking. But if this is for public consumption (and likely even if it wasn't), I personally wouldn't elide the checks.

[TonyValenti]

Although not exactly what you're asking for, I implement non-constant optional parameters by making the optional parameters default to null and then ??ing them against the default value.