Will compiler optimize nested lambda that doesn't capture intermediate values?

[glen-nicol]

Consider the following:

IService service = ...;

CallFunc(x => CallFunc2(y => service.Process(y));

Since the inner lambda doesn't capture x, does the compiler optimize the creation of the y lambda such that its created once and then captured in the x lambda or is service captured and y recreated in each invocation of the x lambda?

Does this technique or something like it have a name?

[CyrusNajmabadi]

That a look at the IL :-). It's the definitive answer here.

[glen-nicol]

^ yeah but see I don't know IL much or the best way to look at it. Is sharplab current/accurate?

If it is it seems like the nested lambda is in fact cached as an action field in this particular IL example?

[RikkiGibson]

Choose Results->Decompile->C# in sharplab. That will give you a fairly comprehensible view of what the compiler is doing. The compiler version is old but I don't think this behavior has changed recently.

[glen-nicol]

Fascinating, seems the compiler does a cached lazy load of the nested lambda action?

Does this type of optimization where the closures are analyzed and simplified have a specific name?

[CyrusNajmabadi]

Closure and capture analysis

[RikkiGibson]

https://github.com/dotnet/roslyn/blob/main/src/Compilers/CSharp/Portable/Lowering/ClosureConversion/ClosureConversion.cs

[glen-nicol]

Thank you both for your guidance and help!