This PR was merged into the repository by commit 0a48d58.

The changes were merged into the following branches: main

I have a question on this if its ok here. With using myInput() several times like myModel().someLoop myModel().options.hideOnClose, will let improve „getting“ the value or does it make no performance differences in doing a @let = myModel()?

If you do @let foo = myModel(), myModel() will still be invoked every time the template function runs, but it won't be invoked again when you use it.

If you do @let foo = myModel(), myModel() will still be invoked every time the template function runs, but it won't be invoked again when you use it.

So this isn't template computed right? Just a variable assignment. Is there any future plans to support template computed?

The plan is to eventually have it be like computed in the template, but at the moment the main benefits are:

1. Allows you to reuse the expression across the template.
2. Has better type narrowing.

That wasnt what I meant. Will multiple myModel() calls in the template infect the performance or will do one @let = myModel() make the performance better because of just one call? I don't know what internally happens on Signals when I call them multiple times, it always feels like they are being "executed" instead of just returning a value like a getter.

Made an example what I meant: https://stackblitz.com/edit/stackblitz-starters-mnwyqx?file=src%2Fmain.ts

I don't know what internally happens on Signals when I call them multiple times, it always feels like they are being "executed" instead of just returning a value like a getter.

A signal will always return its latest value (this applies to signals and computed signals) unless a dependency of a computed changed. In this sense those are "smart getters" and definitively help with performance of expensive computations.

That wasnt what I meant. Will multiple myModel() calls in the template infect the performance or will do one @let = myModel() make the performance better because of just one call?

It will be one call. The performance benefits will be getting bigger as you've got more calls to myModel() and calls to myModel() are "expensive" - which again is not the case for signals. In this sense there is no performance benefit of putting let assignments in front of computed signals - even if those are accessed in a template multiple times.

What is about scope of visibility of @let variable?

@let value = 0;
  
@if (true) {
    @let value = 1; 
    {{value}}  //will output 1
}
 
<ng-template #tpl>
    @let value = 2; 
    {{value}}  //will output 2
</ng-template>
<ng-container *ngTemplateOutlet="tpl"/>

<a-comp>
      @let value = 3; //ups, cannot declare @let called 'value' as there is another symbol in the template with the same name.
      {{value}} 
</a-comp>

As I understand from above named block creates scope of visibility, ng-template also creates scope of visibility, but other markup elements don't.
Am I right?

This issue has been automatically locked due to inactivity.
Please file a new issue if you are encountering a similar or related problem.

Read more about our automatic conversation locking policy.

_{This action has been performed automatically by a bot.}