Proposed: a 'static' modifier on delegate argument declaration

[ActivistInvestor]

I want to know how I can declare a method that requires
a delegate as an argument to be passed a static delegate,.

public class Query<T>
{
   IEnumerable<T> input;

   public Query(IEnumerable<T> input) {this.input = input; }

   public IEnumerable<T> Execute(Func<T, bool> predicate)
   {
      // execute using the supplied predicate
   }
}

public class QueryConsumer
{
   void Run()
   {
      Query<int> query = new Query<int>(Enumerable.Range(0, 100));
      var result = query.Execute(static i => i > 50 && i < 88);

      int min = 44;
      int max = 88;

      // Error CS8820:
      var result = query.Execute(static i => i >= min && i <= max);
   }
}

So, how I can require the Execute() member to be passed a static delegate, as is done in the above example?

For example, why should it not be possible for the called API to require its delegate argument to be static, perhaps by doing something akin to this:

public class Query<T>
{
   IEnumerable<T> input;

   public Query(IEnumerable<T> input) { this.input = input; }

   // Proposal:
   // The use of a 'static' modifier on delegate argument
   // effectively makes the use of 'static' on the passed
   // delegate implicit:

   public IEnumerable<T> Execute(static Func<T, bool> predicate)
   {
      /// execute using the supplied predicate
   }
}


public class QueryConsumer
{
   void Run()
   {
      Query<int> query = new Query<int>(Enumerable.Range(0, 100));

      // no error because a static delegate is required
      // by Execute():

      var result = query.Execute(i => i > 50 && i < 88);

      int max = 88;
      int min = 44;

      // Error CS8820: because the theoretical 'static' modifer
      // is used in the Execute() declaration, signaling that the
      // delegate argument must be static:

      var result = query.Execute(i => i >= min && i <= max);
   }
}

[HaloFour]

You could use an analyzer to enforce that the delegate passed to a particular is a static lambda. I'm not sure I understand the use case of wanting to try to enforce that from the method. Why does it care what delegate was passed to it or how it was created?

[ActivistInvestor]

As a consumer that has code with numerous calls to Execute(), each having different delegate arguments, I can avoid having to apply the static modifier to each delegate?

[HaloFour]

Even if this feature were added I would not expect that the callsite would be changed at all. At most it'd be an error to not include a static modifier on the lambda. Otherwise it'd be impossible to understand what the code is doing at a glance, you also need to be aware of the signature of the method. It also doesn't make a lot of sense as to how that would apply to delegates not created through lambdas.

The addition of the static modifier only enforces that the lambda doesn't capture. If you want to forbid captures without requiring the modifier, you could accomplish that through an analyzer also.

[ActivistInvestor]

The intent of declaring the argument as 'static' is precisely the same as declaring each delegate passed to it as static. It's just another way of achieving the same objective, differing only in semantics, and that the former avoids pollution of calling code clarity.