Does .NET understand caching values for Expression body definition

[Xyncgas]

I was looking at this code in my program

and I was wondering if .NET can cache some of the values instead of calling the method represented by the expression body definition (=> operator) thus wasting computation resources

[sakno]

I don't think so. Method call can have side effects (such as Console.WriteLine() or Environment.Exit()) not explicitly expressed by its arguments. In other words, the method call is cannot be considered as idempotent operation. CLR doesn't have a concept of pure function. However, inline expansion provided by JIT can convert method body into constant value in some (very limited) circumstances.

[Xyncgas]

Well I guess

[Xyncgas]

I would still want cases like

where the instance is created from expression body definition to be possible to be reused when passing it to its member functions it's calling, perhaps with the help of a keyword or attribute or just analysis of the source code by the compiler in the future

I can of course just not declare TitleLayout as expression, but in a niche case it's natural for me to do because sometimes depending on the environment the values indeed changes, I just think that it would be awe if you can add this kind of smartness™ in the product

[Xyncgas]

It would be nice if we can actually see functions that are pure function and optimizes these cases.
For example if we know methodA() is ok we can replace ten calls to MethodA() * 1.5 to one call, of course I want cases when methodA() is returning from a buffer to be optimized this way too, so having a good understanding of the fact that if methodA() doesn't change what it's returning from unless the value changes from the source, we can replace these calls too

[sakno]

What is the benefit from this? How many CPU cycles you want to save? Is PutAtCenter a heavyweight operation? If yes, probably it's not a pure function.

[Xyncgas]

Maybe we can add a stale keyword to suggests that the body of expressions will cache every values returned by method calls, therefore same signature call site should have their return values cached.
for example nowadays we can do :

void MyMethod()
{
    var CachedValue = GetValue(0);
    this.a = CachedValue * 0.5;
    this.b = CachedValue * 0.6;
    //Instead of
    //this.a = GetValue(0) * 0.5;
    //this.b = GetValue(0) * 0.6;
}

and with the stale keyword added this function body :

void stale MyMethod()
{
     this.a = GetValue(0) * 0.5;
     this.b = GetValue(0) * 0.6;
}

Would be equivalent to the method above.
It would also be helpful for expressions with record types like :

internal Layout SomeLayout => GetValue(0);
internal stale Layout MyVariable => SomeLayout with { height = SomeLayout.height*0.5, width = SomeLayout.width*0.6};

[sakno]

You can achieve the same with static readonly fields:

internal static readonly Layout SomeLayout = GetValue(0);
internal static readonly Layout MyVariable = SomeLayout with { height = SomeLayout.height*0.5, width = SomeLayout.width*0.6};

[Xyncgas]

Yet, the desire effect is for a value to be cached when using a stale keyword, which from it being generated to being cache to being reused is non-static and CAN CHANGE once GetValue(0) changes