Proposal: Nicer delegates

[dreikin]

(Forgive me if this isn't formatted correctly or is missing required information. I looked around and didn't see any relevant templates or such. I've also looked for issues regarding this idea and did not find any)

Issues

There are two issues I've noticed with delegates that seem like they could be relatively easy to fix:

1. Manual null checks are required in some cases, which seems like something that can and should be handled by the compiler.
2. Delegates only return the last result obtained, rather than all of them.

Demonstration of proposal

By way of example, let's start with a simple program using the current delegates:

class RegularDelegates
{
    public delegate string RegularDelegate(int x);
    static RegularDelegate converters;

    static void Main(string[] args)
    {
        // Problem 1: Unnecessary null checks.
        var result = converters?.Invoke(42); // Check that the delegate is not null.
        if (result != null) // Check that the result is not null.
        {
            System.Console.WriteLine(result);
        }

        // Problem 2: Returning only the last result obtained.
        converters += ConvertToString;
        converters += ConvertToHexString;

        result = converters(42);
        System.Console.WriteLine(result);

        Console.ReadLine();
    }

    public static string ConvertToString(int x)
    {
        return x.ToString();
    }

    public static string ConvertToHexString(int x)
    {
        return x.ToString("X");
    }
}

Result is:

0x2A

Problem 2 can be handled by having the nicer delegates return a collection:

class PartiallyNicerDelegates
{
    public delegate string PartiallyNicerDelegate(int x);
    static PartiallyNicerDelegate converters;

    static void Main(string[] args)
    {
        // Problem 1: Unnecessary null checks.
        var results = converters?.Invoke(42); // Check that the delegate is not null.
        if (results != null) // Check that the results collection is not null.
        {
            foreach (var result in results)
            {
                System.Console.WriteLine(result);
            }
        }

        // Problem 2, Fixed: Now returns all the results in an IEnumerable<string>.
        converters += ConvertToString;
        converters += ConvertToHexString;

        results = converters(42);
        foreach (var result in results)
        {
            System.Console.WriteLine(result);
        }

        Console.ReadLine();
    }

    public static string ConvertToString(int x)
    {
        return x.ToString();
    }

    public static string ConvertToHexString(int x)
    {
        return "Ox" + x.ToString("X");
    }
}

Result is:

4
0x2A

Problem 1 can be partly solved by making the null check on the delegate implicit and automatic:

class MostlyNicerDelegates
{
    public delegate string MostlyNicerDelegate(int x);
    static MostlyNicerDelegate converters;

    static void Main(string[] args)
    {
        // Problem 1, Partly fixed: Unnecessary null checks.
        var results = converters(42); // Compiler rewrites this to the null-conditional form.
        if (results != null) // Check that the results collection is not null.
        {
            foreach (var result in results)
            {
                System.Console.WriteLine(result);
            }
        }

        // Problem 2, Fixed: Now returns all the results in an IEnumerable<string>.
        converters += ConvertToString;
        converters += ConvertToHexString;

        results = converters(42);
        foreach (var result in results)
        {
            System.Console.WriteLine(result);
        }

        Console.ReadLine();
    }

    public static string ConvertToString(int x)
    {
        return x.ToString();
    }

    public static string ConvertToHexString(int x)
    {
        return "Ox" + x.ToString("X");
    }
}

(Results are the same as last example).

Then we can remove the remaining null check by having the compiler automatically return an empty collection if the delegate is null:

class NicerDelegates
{
    public delegate string NicerDelegate(int x);
    static NicerDelegate converters;

    static void Main(string[] args)
    {
        // Problem 1, Fixed: Null handling done automatically by the compiler
        var results = converters(42); // Compiler rewrites this to the null-conditional form with default.
        foreach (var result in results)
        {
            System.Console.WriteLine(result);
        }

        // Problem 2, Fixed: Now returns all the results in an IEnumerable<string>.
        converters += ConvertToString;
        converters += ConvertToHexString;

        results = converters(42);
        foreach (var result in results)
        {
            System.Console.WriteLine(result);
        }

        Console.ReadLine();
    }

    public static string ConvertToString(int x)
    {
        return x.ToString();
    }

    public static string ConvertToHexString(int x)
    {
        return "Ox" + x.ToString("X");
    }
}

In particular, the first instance of var results = converters(42); is replaced by the compiler with something like:

var results = converters?.Invoke(42) ?? new List<string>();

In the second instance, the compiler should be able to detect that converters can't be null and so leave it as-is.

Discussion

I think the solution presented should be relatively simple compared to many other language features, as it's largely just a slight modification of the existing delegate usage. The three biggest problems or hurdles I see with implementing this proposal are:

1. Solving issue two in the way proposed probably requires a new type, annotation, setting, and/or keyword for the nicer delegate style, as it changes the expected return type from the invocation.
2. Getting the compiler to rewrite the invocations without incurring unnecessary overhead when the delegate can't be null will probably require more than the minimal effort the rest of the proposal ought to take (in the technical aspects).
3. Deciding if anything that depends on delegates should be changed to handle, or even prefer, the new variety.

[HaloFour]

How exactly would this be implemented?

For point 1 the compiler could theoretically just emit a null-check, but I would argue that this is definitely not the appropriate nor expected behavior. In most cases the lack of a value would indicate an invalid state and the program should throw. If it's not a problem, the null propagation operator makes a combined null-check and invocation pretty easy.

Point 2 is interesting but I don't know that there's much that the compiler can do here. Multicast delegates are a part of the CLR, as is their behavior. The compiler could potentially unwrap the invocation list of a delegate and invoke them individually, collecting their results. IIRC there'd be no way to write a general purpose helper method to accomplish this given that the signature of each delegate can be different and they are nominally typed. I do think that if considered that it should have a special syntax indicating what the compiler should do:

string result = converters(42); // normal delegate invocation

IEnumerable<string> results = converters*(42); // multicast delegate invocation
// logically equivalent to
Delegate[] $list = converters.GetInvocationList();
List<string> results = new List<string>($list.Length);
for (int i = 0; i < $list.Length; i++) {
    results.Add($list[i].Invoke(42);
}

[svick]

For point 1, I think being explicit with null handling is better. Things to consider:

• If the return type is a value type, null checking changes the return type, so it should not be done automatically.
• Delegates are not really special in this regard. Why should delegate invocations have special rules for null checks, when other types don't? And while fairly big changes are planned when it comes to handling null in the form of nullable reference types (Champion "Nullable reference types" (16.3, Core 3) #36), they don't really change anything about that.

For point 2, multicast delegates that return values are not used often and I think they are not a good feature and so their use should not be encouraged by adding new features for them.

If you want to have a collection of delegates, then I think it's best to be explicit about it and have e.g. IEnumerable<RegularDelegate>. Then it's clear that to invoke them all, you have to use something like delegates.Select(d => d()).

If you still want to use multicast delegates, you could write a helper method that does what you want:

static IEnumerable<string> InvokeAll(this RegularDelegate d, int x)
{
    foreach (RegularDelegate innerDelegate in d.GetInvocationList())
    {
        yield return innerDelegate(x);
    }
}

It's true that you have to write that method for each delegate type, but that's not going to be that bad if you use the Func family of delegates.

[DaZombieKiller]

If it saves anyone some time, I generated all the necessary extension methods for the Func<[...,] TResult> family

public static class FuncExtensions
{
    public static IEnumerable<TResult> InvokeAll<TResult>(this Func<TResult> f)
        => f.GetInvocationList().Select(i => ((Func<TResult>)i)());

    public static IEnumerable<TResult> InvokeAll<T1, TResult>(this Func<T1, TResult> f, T1 t1)
        => f.GetInvocationList().Select(i => ((Func<T1, TResult>)i)(t1));

    public static IEnumerable<TResult> InvokeAll<T1, T2, TResult>(this Func<T1, T2, TResult> f, T1 t1, T2 t2)
        => f.GetInvocationList().Select(i => ((Func<T1, T2, TResult>)i)(t1, t2));

    public static IEnumerable<TResult> InvokeAll<T1, T2, T3, TResult>(this Func<T1, T2, T3, TResult> f, T1 t1, T2 t2, T3 t3)
        => f.GetInvocationList().Select(i => ((Func<T1, T2, T3, TResult>)i)(t1, t2, t3));

    public static IEnumerable<TResult> InvokeAll<T1, T2, T3, T4, TResult>(this Func<T1, T2, T3, T4, TResult> f, T1 t1, T2 t2, T3 t3, T4 t4)
        => f.GetInvocationList().Select(i => ((Func<T1, T2, T3, T4, TResult>)i)(t1, t2, t3, t4));

    public static IEnumerable<TResult> InvokeAll<T1, T2, T3, T4, T5, TResult>(this Func<T1, T2, T3, T4, T5, TResult> f, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5)
        => f.GetInvocationList().Select(i => ((Func<T1, T2, T3, T4, T5, TResult>)i)(t1, t2, t3, t4, t5));

    public static IEnumerable<TResult> InvokeAll<T1, T2, T3, T4, T5, T6, TResult>(this Func<T1, T2, T3, T4, T5, T6, TResult> f, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6)
        => f.GetInvocationList().Select(i => ((Func<T1, T2, T3, T4, T5, T6, TResult>)i)(t1, t2, t3, t4, t5, t6));

    public static IEnumerable<TResult> InvokeAll<T1, T2, T3, T4, T5, T6, T7, TResult>(this Func<T1, T2, T3, T4, T5, T6, T7, TResult> f, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7)
        => f.GetInvocationList().Select(i => ((Func<T1, T2, T3, T4, T5, T6, T7, TResult>)i)(t1, t2, t3, t4, t5, t6, t7));

    public static IEnumerable<TResult> InvokeAll<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(this Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult> f, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8)
        => f.GetInvocationList().Select(i => ((Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult>)i)(t1, t2, t3, t4, t5, t6, t7, t8));

    public static IEnumerable<TResult> InvokeAll<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult>(this Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult> f, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9)
        => f.GetInvocationList().Select(i => ((Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult>)i)(t1, t2, t3, t4, t5, t6, t7, t8, t9));

    public static IEnumerable<TResult> InvokeAll<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult>(this Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult> f, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10)
        => f.GetInvocationList().Select(i => ((Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult>)i)(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10));

    public static IEnumerable<TResult> InvokeAll<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult>(this Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult> f, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11)
        => f.GetInvocationList().Select(i => ((Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult>)i)(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11));

    public static IEnumerable<TResult> InvokeAll<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TResult>(this Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TResult> f, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12)
        => f.GetInvocationList().Select(i => ((Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TResult>)i)(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12));

    public static IEnumerable<TResult> InvokeAll<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TResult>(this Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TResult> f, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13)
        => f.GetInvocationList().Select(i => ((Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TResult>)i)(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13));

    public static IEnumerable<TResult> InvokeAll<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TResult>(this Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TResult> f, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14)
        => f.GetInvocationList().Select(i => ((Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TResult>)i)(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14));

    public static IEnumerable<TResult> InvokeAll<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TResult>(this Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TResult> f, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15)
        => f.GetInvocationList().Select(i => ((Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TResult>)i)(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15));

    public static IEnumerable<TResult> InvokeAll<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, TResult>(this Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, TResult> f, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16)
        => f.GetInvocationList().Select(i => ((Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, TResult>)i)(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16));
}