(Proposal) Inline the Lambda.

[AdamSpeight2008]

Premise
Allow lambda function (in particularly LINQ) to rewritten by the compiler as inline version of the algorithm. No Closures, No Delegates

Syntax
This would be enable by prefixing the lambda with inline eg
inline (x,y)=> ;

Example

The foreach aspect of the pull request #209 could written via Aggregate.

int hash = Hash.Combine(_location.GetHashCode(), 
                       Hash.Combine(_severity.GetHashCode(), _warningLevel)); 

hash =  _messageArgs.Aggregate( hash, inline (_h, item)=> HashCode.Combine( _h, item) );
hash = HashCode.Combine( _descriptor, hash)
return hash;

would be rewritten as an inline implementation.

int hash = Hash.Combine(_location.GetHashCode(), 
                       Hash.Combine(_severity.GetHashCode(), _warningLevel)); 
/* Begin Inline (Aggregate) */
 var _h = hash;
 foreach(var item in _messageArgs)
 {
    HashCode.Combine( _h, item);
 }
hash = _h
/* End Inline ( Aggregate ) */

hash = HashCode.Combine( _descriptor, hash)
return hash;

Admittedly the produce code is slightly less efficient (an extra variable).

[gafter]

How do you propose that the compiler know what is inside the method Aggregate, especially considering that most compilations are against a reference assembly?

How would this affect binary compatibility?

[mattwar]

We considered this when originally doing LINQ operators, with the assumption was that we, the compiler writers and the original LINQ API authors, knew precisely the implementation. However, that's not likely to always be true.

[omariom]

@mattwar, Why not to implement this for the stock Linq operators from System.Linq namespace only?
The compiler could do many optimizations which are not available for Enumerable.* methods.

It would just increase deepness of integration of queries into the language :)

[AdamSpeight2008]

I would implement it via a template function ( #174 ) , and have the compiler build it.

[omariom]

The motto for the effort could be:
✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨
✨Let's make Linq to Objects as performant as loops!✨
✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨

[RichiCoder1]

👍

[AdamSpeight2008]

@gafter It could also do some form of internals embedding. ie clone and mutation of the IL of the .Aggregate and then splice it into our code.

Existing precedence Embedded Interops

[mpawelski]

Is this feature somewhat similar to inline in F#? (msdn stackoverflow)
but here you would mark Aggregate function as inline?

[AdamSpeight2008]

@mpawelski That's looks (to me) to more making sure the function is polymorphic.

Let's say that .Aggregate is a pure function, then there is nothing stopping you from in-lining the body of the function, as the use site (call-site / callee-site)?

[dsaf]

Wouldn't it better to introduce a short-hand custom attribute applicable to local code instead of yet another keyword? This would be similar to F#'s units-of-measure technique.

[Inline] (_h, item)=> HashCode.Combine( _h, item);
//Equivalent of [MethodImpl(MethodImplOptions.AggressiveInlining)] (_h, item)=> HashCode.Combine( _h, item)

http://www.dotnetperls.com/aggressiveinlining

[mburbea]

@dsaf, delegate invocations never get inlined, last I checked, so the attribute isn't helping the situation.

[mattwarren]

BTW, you can have these optimisations in LINQ if you use the LinqOptimizer library, it does these optimisations:

• Lambda inlining
• Loop fusion
• Nested loop generation
• Anonymous Types-Tuples elimination
• Specialized strategies and algorithms

However you need to re-write your queries like so:

var query = (from num in nums.AsQueryExpr()
             where num % 2 == 0
             select num * num).Sum();

which gets turned into:

int sum = 0;
for (int index = 0; index < nums.Length; index++)
{
   int num = nums[index];
   if (num % 2 == 0)
      sum += num * num;
}

[MgSam]

👍
As Linq is one of the most powerful parts of the language, and is heavily used for data manipulation, I think looking into optimizations around it is certainly a worthwhile use of time for the languages team.

[dsaf]

@mburbea I meant using an attribute instead of introducing a keyword, rather than what that specific attribute is currently doing.

[gafter]

What about the language disallows this today?

Why is this something that should be done by compilers as opposed to being done by the runtime?

[gafter]

Since the compiler is already allowed to do this (when it can prove the result is semantically identical), there is nothing to do.

Having said that, this is something traditionally done in the JIT.