A modern programming language that makes developers happier.

kotlinlang

Please explain me the difference between `+memo`, `+state`, `+model`  and when to use which one ?
I know all of this observing some value and try to recompose on value changes.

`state`  and `model` are using `memo` , they're just convenience wrappers



```fun <T> state( init: () -> T) =     memo { State(init()) }```

```fun &lt;T&gt; model(init: () -&gt; T) = memo { init() }```

And `The State class is an @Model class meant to wrap around a single value`

So if you just want to cache a single value, you can use `state` , if you have multiple values and grouping them makes sense, you can use `model` for that (with a `@Model` annotated class).

And what is the difference in `+memo` and `+model`

From the implementation above none it seems, it's just an alias

Or maybe the compiler is doing something different with `model`  calls

Can you explain me `+stateFor` take multiple value and so how to access that values and change it.
Let say I use this `+stateFor&lt;V1,V2&gt; { something }`
As per of doc It says `An effect to introduce a state value of type T into a composition that will last as long as the inputs v1 and v2 do not change.`
So how to acccess this values and change it accordingly.

Let's say you have a `userCounter` state, eg:
`val userCounter = +state { 0 }`

and everytime you press a button, you'll increment this value, and a textfield will get updated somewhere.

Now let's say that the user can change, and if that's the case, the counter should reset to 0.

You could do something like

`val userCounter = +stateFor(userId) { 0 }`

With this, when userId changes, the counter will reset.

This example is a bit simplified, and could be replaced by adding a `counter`  property in a `User` model instead

(I highly recommend that you read this awesome article <http://intelligiblebabble.com/compose-from-first-principles/> , it explains in a simplified way what `memo` actually does)