How do InlineIfLambda vs OptimizedClosures.FSharpFunc relate to one another?

[abelbraaksma]

For a long time, when you created a function that takes another function, which gets used many times over, the best way to optimize it was to use OptimizedClosures.FSharpFunc. Then came InlineIfLambda as the new best thing for optimizations.

Can or should these things be combined? I'd estimate that if I tried, it could not be inlined anymore. However, when using OptimizedClosures.FSharpFunc, this optimizes curried functions and I'm not sure if InlineIfLambda applies to curried functions, or only to lambdas like fun x -> x + 3.

What would the new advice be for function params that are used in iteration scenarios like List.map2? I do see that the original F# Core still uses OptimizedClosures, so to me this suggests there's either a sweet spot between choosing one over the other, or this still needs to be updated in F# Core (or, doing so would cause binary incompatibility, but doing so would have been beneficial).

Any thoughts on this? /cc @dsyme @vzarytovskii @gusty @TheAngryByrd (sorry for the spam, I just guestimated that most of you have considered this before)?

Reason for asking: I'm writing a library for TaskSeq and am wondering which of the two, or both, or neither I should use in stuff like TaskSeq.mapi or TaskSeq.map2 (i.e., two variables or more in the lambda).

I should note that this is for library functions, not the CE itself. I kinda assume that InlineIfLambda is preferred in the CE code considering the resumable state machine being inlined itself.

[dsyme]

@abelbraaksma Great to see the TaskSeq work!

These are really different mechanisms - and I guess I'd just say "use them how they're used in FSharp.Core".

• Use InlineIfLambda for things that hugely benefit from inlining and flattening, especially things over super-high-perf primitives like arrays.

• Use OptimizedClosures.FSharpFunc in non-inlined things taking curried functions as parameters and using them in loops

For something like TaskSeq I would not see much use for the former. The latter could reasonably be used quite widely.

[abelbraaksma]

Thanks, this is very useful advice and an excellent summary!

Slightly OT: @dsyme can I ping you/bug you for a little pair-programming session, or some other way of a back and forth on resumable state machines in the context of TaskSeq? There's a bug that disallows restarting the IAsyncEnumerable from the CE (i.e., calling GetAsyncEnumerator() twice leads to problems). I've spend a fair deal fixing it, and most is fixed, but there's something in the "resetting of state" that doesn't appear to happen. Case in point, this PR: fsprojects/FSharp.Control.TaskSeq#42.

[dsyme]

@abelbraaksma Yes, certainly, message me on FSSF Slack?