Require a delegate parameter to avoid closure

[ladeak]

Background and Motivation

Enforce a delegate parameter not to capture closure.

Proposed API

The following code prints 5 to the console.

using System;
int a = 4;
Console.WriteLine(Increment(()=>a));
int Increment(Func<int> valueProvider) => valueProvider()+1;

The proposal adds a C# language constraint on valueProvider parameter, so that the following code returns a compile time error:

using System;
int a = 4;
Console.WriteLine(Increment(()=>a));
int Increment(someModifier Func<int> valueProvider) => valueProvider()+1;

But the following would compile:

using System;
Console.WriteLine(Increment(()=>4));
int Increment(someModifier Func<int> valueProvider) => valueProvider()+1;

This would allow (for the author of Increment API) to avoid accidental boxing or enforce that the delegate can only work with validated parameters:

Usage Examples

using System;
using System.Collections.Frozen;
using System.Collections.Generic;

var myset = new HashSet<int>().ToFrozenSet();
var myset2 = new HashSet<int>([1,2,3,4]).ToFrozenSet();
Console.WriteLine(SomeOperationValidatesInputs(3, myset,
                                               (a,b) => myset2.Count + a));

int SomeOperationValidatesInputs(int inputA, 
                                 FrozenSet<int> inputB,
                                 Func<int, FrozenSet<int>, int> valueProvider)
{
    if(inputA < inputB.Count)
        throw new Exception("Invalid input");
    
    int result = valueProvider(inputA*2, inputB);
    //... do something with result
    return result;
}

Using myset2 would cause a compile time error in (a,b) => myset2.Count + a)

[HaloFour]

If the caller does not want the lambda to capture state they can apply a static modifier:

using System;
int a = 4;
Console.WriteLine(Increment(static ()=>a)); // error CS8820: A static anonymous function cannot contain a reference to 'a'.
int Increment(Func<int> valueProvider) => valueProvider()+1;

[ladeak]

This would be a constraint at the definition of Increment not at the callsite.

[HaloFour]

I understand that, however I don't agree that the callee should have an opinion as to how the callee has implemented a delegate.

IMO, if that's something you would want to enforce in your codebase that would seem to be better handled through an analyzer.

[CyrusNajmabadi]

Agreed. If this is a declaration-side rule that applies to consumers, this should be done with an analzyer.

[ladeak]

In the proposal I did not use static or mentioned it. I used someModifier because static would allow static members captured.

I understand that, however I don't agree that the callee should have an opinion as to how the callee has implemented a delegate.

It allows enforces that the implementation can use values or references that are validated by the callee. You could do this in case of a plugin model.

The opposite direction:

string.Create with the SpanAction overload already has "the opposite" restriction. You can define ref struct parameters on the delegate that do not allow those parameters to escape from the delegate.

[ladeak]

After some additional considerations, I think even if such a language feature exists, there would be only certain method signatures* that could ever work with them in a reasonable way. That defeats the purpose; hence I will close the proposal.

*the delegate could have generic arguments, and the parameter types could be only limited set. Otherwise, it is prone to more errors in a plugin model.